A manifesto for builders

AI has made it easier than ever to build something to the 90% mark. But it's always been easy to get something 90% done! The last 10% still accounts for half the work!

If you want to ship real software that customers rely on, you need to be able to test it, monitor it, and have CI to deploy it safely.

Don't get trapped in an endless loop of finishing things 90%. Ship it.

AI is very, very good at writing code. But if you're not in the loop, thoughtfully guiding it, it will write too much code. It will write the wrong code. It will try to make you happy instead of building robust systems.

The developers who thrive with AI keep their hands tightly on the wheel.

AI is inherently probabilistic. It will solve the same problem three different ways on three different days. That can be frustrating, but this is not a bug to complain about! It's just a new reality we have to build systems around.

Locally, we build guardrails that tame the chaos: type systems that won't compile nonsense, tests that fail, state machines instead of littered if statements. Then we build CI pipelines that exercise the whole system and reject broken code before it touches production. And we add monitoring and logging so we catch the failures that slip through.

We're not trying to fight the AI. We're trying to constrain it with robust, deterministic checks. Trust the system you build around the probabilistic chaos machine.

You can't tell the AI, "Make no mistakes. Build me a Salesforce clone. Make no mistakes." That's just not going to work. You still have to be an engineer. You still have to have a project structure that makes sense. Rules files that encode your decisions. Documentation that explains why, not just what.

You still have to tell the AI how to architect the feature. There is no magic one-shot prompt for anything.

You used to be able to specialize so narrowly that nobody questioned your black box. AI has collapsed those walls. When anyone can generate code for any layer, the developer who only knows one thing becomes the bottleneck, not the expert.

The new leverage is range. Know enough about databases, infrastructure, security, and systems design to make good calls across the stack. Know when to go deep.

When anyone can generate code for any layer, that also means you can generate slop at any layer. We may have our hands on the keyboard less these days, but that doesn't mean we can stop learning about systems, architecture, patterns, and performance.

AI output that's 90% right is still 100% wrong! You may be able to prompt code faster than other developers, but the ones going a little slower than social media would suggest are the ones actually verifying the code. They're reading it, questioning the approach, changing the architecture, catching the subtle bugs that ship fine today but cause problems long term.

A lot of our work has moved to verification. Verification is engineering. Develop the instinct for when to accept AI code and when to push back.

Producing code is nearly free now! That makes it almost worthless as a differentiator. What's scarce is the judgment to know which output is good, which is garbage, what your users will find confusing, and what will delight them.

Taste extends beyond code. What features to build? Which ones to kill? Which problem is actually real and which is invented? When you can build everything with the push of a button, what you don't build matters as much as what you do.

AI can generate ten implementations of a feature that shouldn't even exist. Taste is knowing it shouldn't exist. Everyone can generate now, but the leverage belongs to the people who can edit, both the code and the roadmap.

AI can generate code. It cannot tell you which abstraction will age well, which dependency is a mistake, which shortcut will cost you six months later.

The vibe coding crowd will generate infinite slop and then wonder why nothing works. Real engineering is keeping your hands on the wheel and architecting the codebase for long-term maintainability and extensibility.

The new craft is in the decisions AI can't make for you, and forcing it to be a good engineer.

Just because the AI knows how to write performant React code (but does it really?) doesn't mean you can stop learning new things.

We may not be in the weeds as much anymore, actually typing out the code, but more than ever we need to know good architectural patterns. We need to know higher-level abstractions.

What we are learning may have changed a little bit, but we still need to learn, and we cannot abdicate that responsibility.

It's a brave new world. The gap between "idea" and "shipped product" has never been smaller. You don't need a team. You don't need permission. You don't need to wait until you're ready.

The developers who win in this era aren't waiting for the perfect tutorial or the perfect stack or the perfect moment. They're building, shipping, learning from what breaks, and building again.

AI removed the excuses. Now it's just you and the work.