Generative AI coding demands what we've always known: modularity, clear boundaries, disposable components. Principles that scaled human teams are now table stakes. Here, we make the implicit explicit
A spec can contain prose, tests, schemas, formal models, even executable code. The useful boundary is not the syntax but, rather, what survives: if you throw the implementation away, what has to remain so you can build the next one?
Every mature system is carrying around lessons that were never written down. They’re encoded as validations, retries, timeouts, workflows, and exceptions. The implementation remembers. The organization forgets
Production used to be the place where software went to fail. Observability made it the place where software becomes legible. But it left one loop open. We use production telemetry to debug incidents, explain behavior, gate rollouts, and decide whether to roll back. We use it to help humans understand reality. Then a person decides what the code change should be. Instead, production truth becomes…
The architecture of a regenerative system is defined entirely by what you can't delete.
Trying to find the best tool or platform for generative software in 2026 is a mistake that could haunt you for decades
Here’s a scene every working programmer has lived. It’s 2 AM. Something is broken in production. You’re staring at a commit from eight months ago. The message says “refactor auth logic.” That’s it. The PR has two approvals—thumbs-up emoji, no comments. The Slack thread where the team debated the approach was in a channel that got archived when the org restructured. The person who wrote it left the…
For a long time we’ve treated frameworks as the target of software development. But if systems are meant to be regenerated and replaced safely, the real compilation target has to be the architecture itself.
In 2014 I gave a talk called Tiny (keep things small enough to understand) In 2026, small means something different. Small means safe to delete. New in the Phoenix Architecture series: The Regenerative GrainI
The “AI software factory” metaphor is seductive. Factories increase output. They reduce marginal cost. They turn craft into production. For decades, writing code was the bottleneck. Now generation is cheap, and it feels like we’ve industrialized software. But factories are not optimized for throughput alone. Real factories are optimized for yield. Throughput is how much you produce. Yield is how…
Here’s a simple test you can apply to any software system you work on: Imagine deleting the entire implementation. Not refactoring it. Not archiving it. Not putting it behind a feature flag. Deleting it. rm -rf src/ If that thought makes your stomach drop, pay attention. That reaction is telling you something important. It’s not telling you that you’re reckless. It’s not telling you that you lack…
Why the user interface is the last to become regenerative
When code can be thrown away and recreated, the unit of change is no longer lines of code. It’s reasons. Version control has to follow. Regenerable systems quietly invalidate an assumption that has underpinned software engineering for decades: that the text of the code is the best record of how and why a system came to be. Once an AI can reliably regenerate an implementation from specification,…
Single-developer capability isn’t a productivity story. It’s the test that tells you whether your architecture is worth keeping.
The Discipline That Looks Like Recklessness
Why Regeneration Does Not Mean Starting Over
As I mentioned in a previous post , at Wunderlist , we had a rule: any new service had to be " this big" , a constraint I'd demonstrate by holding my fingers a few inches apart. The metric wasn't about lines of code. It was about replaceability. If a service was small enough to rewrite in a day, it couldn't accumulate the kind of complexity that makes systems brittle. That rule was about resisting…
Why "Never Upgrade in Place" Now Applies to Software
Why behavior outlives implementations
Better shapes beat better prompts
Why smaller codebases win in the AI era
Why AI makes the hidden economics of software unavoidable
Not all software should change at the same speed. This has always been true, but it's easy to forget when tools make change frictionless. Generative AI dramatically lowers the cost of modification, which creates a dangerous illusion: that everything can change quickly, therefore everything should . That's how systems accumulate the kind of damage that only becomes visible in production, at 2am,…
Programming didn't die all at once. There was no single moment, no dramatic obsolescence event. Instead, something quieter happened: the core constraint that shaped software for seventy years dissolved. Writing code stopped being the hard part.
Software is entering a strange new phase. For most of its history, code was expensive to produce and cheap to keep. We treated it like a durable asset: written carefully, maintained lovingly, upgraded cautiously. Whole professions, identities, and institutions grew around this assumption. Programmers were craftsmen. Codebases were cities. Refactoring was urban renewal. Generative AI breaks this…