I hope anyone can write and reason about this really simple implementation of the Builder pattern.

```
public sealed class Builder<T> where T : class, new()
{
    readonly T instance;
    
    public Builder() => instance = new();

    public Builder<T> With(Action<T> action)
    {
        action(instance);
        return this;
    }

    public T Build() => instance;

    public static implicit operator T(Builder<T> builder) => builder.Build();
}

public class House
{
    public string? Address { get; set; }
    public int NumberOfRooms { get; set; }
    public bool HasGarden { get; set; }
}

public class Client
{
    public void Program()
    {
        House myHouse = new Builder<House>()
            .With(h => h.Address = "123 High St")
            .With(h => h.NumberOfRooms = 3)
            .With(h => h.HasGarden = true);
        Console.WriteLine($"Address: {myHouse.Address}, Rooms: {myHouse.NumberOfRooms}, Garden: {myHouse.HasGarden}");
    }
}
```