Tag: #AI
SaaS Isn’t Dead. Sameness Is.
Everyone suddenly wants to tell you SaaS is dead.
Most of Your Architecture Was Just Expensive Code
For decades, architectural knowledge lived inside the implementation, because the implementation was expensive to reproduce. That expense is disappearing. And as it goes, we're going to find out how much of what we called "architecture" was really the cost of change wearing a disguise.
The Specification Is Not a Document
Imagine joining a software project a few years from now.
When Does a Specification Become a Program?
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?
Production Is a Compiler Input
Production used to be the place where software went to fail. Observability made it the place where software becomes legible.
The Phoenix Primitives
The architecture of a regenerative system is defined entirely by what you can't delete.
The Generative Stack
Trying to find the best tool or platform for generative software in 2026 is a mistake that could haunt you for decades
The Conversation Is the Commit
Here’s a scene every working programmer has lived.
Your traces are the best context window an agent will ever get
Keeping your traces close to your e2e testing execution, and your feedback cycle as short as possible is more important than ever.
Compile to Architecture
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.
Why We Write
On becoming more alive
The Industrialization of Regenerative Software
The “AI software factory” metaphor is seductive.
Douglas Adams on AI, Before There Was AI
A passage from one of the author’s comic novels of the 1980s clarifies a key user flaw of our AI present
On AI Contribution Policies
You should have one, and you should say "no".
Muckin’ Around: An AI Manifesto
Why start a blog in 2026 anyway...
The Broken Trust Bridge: How AI Shattered the 70-Year CV and How to Rebuild Hiring
The foundation of the hiring process has been irreparably changed. For 70 years, the Curriculum Vitae (CV) served as the primary trust mechanism between candidates and employers. It was a tangible work sample that demonstrated writing ability, organizational skill, and attention to detail, creating a starting point for an honest dialogue.
The Deletion Test
Here’s a simple test you can apply to any software system you work on:
UI Is a Conservation Layer
Why the user interface is the last to become regenerative
RFC 9001 - The Feelings Transport Protocol (FTP)
(Internet-Draft. Expires whenever feelings do.)
Provenance Is the New Version Control
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.
n=1 Is a Design Constrain (Not a Staffing Model)
Single-developer capability isn’t a productivity story. It’s the test that tells you whether your architecture is worth keeping.
Relocating Rigor
The Discipline That Looks Like Recklessness
The System Is the Asset
Why Regeneration Does Not Mean Starting Over
Conceptual Mass and the Compaction Discipline
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.
Immutable Infrastructure, Immutable Code
Why "Never Upgrade in Place" Now Applies to Software
Evaluations Are the Real Codebase
Why behavior outlives implementations
The Gradient of Trust
Better shapes beat better prompts
Code Was Never the Asset
Why AI makes the hidden economics of software unavoidable
Pace Layers and AI Integration
Not all software should change at the same speed.
The Death and Rebirth of Programming
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.
Regenerative Software
Software is entering a strange new phase.