Grow, Don't Build

There's a lot of conversation right now about how software should be made in the age of AI. Factories. Harnesses. Runtimes. Standardized production lines with quality gates and telemetry pipelines. Everyone's talking about the machine.

I've been thinking about the garden.

When you build something, you start with a blueprint. You know what the output looks like before you start. You control every step. The builder is the bottleneck. When you grow something, you start with a seed. You provide the right conditions — soil, water, light — and something emerges. You don't control every cell. You create the environment and see what thrives.

I've been working on a platform for a while now. Four generations of it. And the thing I keep learning is that the code that survives isn't the code I planned. It's the code that grew out of the right conditions.

The soil is the platform underneath. The shared services, the common contracts, the capabilities that every app needs but nobody should have to reinvent. Identity. Storage. Logging. Secrets. When the soil is consistent, anything planted in it can focus on what makes it unique instead of figuring out how to survive.

Here's where it gets interesting. What if the seed isn't code? What if it's just a description of what must be true? We tried this. We wrote test specs — no implementation, just properties that must hold — and let an AI agent grow the service. Must have these fields. Must enforce approval before mutations. Must redact secrets, even nested ones. We planted six of these seeds. 236 tests across 18 must-pass checks. An agent grew the implementations. All 18 checks passed.

No blueprint. No architecture document. Just: here's what must be true. Grow something that satisfies it.

Four generations of rethinking everything taught me this: the code that survives isn't any particular app. It's the patterns. The universal return type. The capability contracts. The way services plug into the platform. The scaffolding changes every few months — new metaphors, new models, new "right ways" to structure things. The patterns hold.

If one agent can grow a service from a spec, what happens when three try? It's like growing three rose cultivars from the same rootstock — same soil, same water, same light, different genetics. You don't pick the winner by reading the label. You watch what blooms. Score them on what passes, how much code it took, how clean it is. No subjective judging. The tests decide. What grows best, wins.

Everyone's debating the right architecture for AI-generated software. They're all solving real problems. But they're all focused on the machine. I think the more interesting question is: what conditions make good software grow?

It's better to start small and grow than wait for perfection.