Code is cheap. The expensive part is what comes before and after it
- An app in two hours is the easy part. A few pages of bullet points turned into twenty modules and ten integrations. It looked finished, but it was built on guesses, not on how the business really works.
- The build ate most of the budget, but it never decided the outcome. Whether software pays off is decided by what happens before the code and after it. Today there is finally money left for that.
- More than one shot. The money the build used to eat flows into depth: build it, show it, change it and build it again until it fits.
- I stopped reading code. I check something more important: whether the system does exactly what the client and I agreed on. The most expensive bug looks like it works.
- Finished software is only the beginning. It has to take root in a messy reality, among people, old processes and exceptions. Only there do you find out whether it paid off.
AI wrote this summary from the full article. The author checked it.
I stopped reading code. I check something more important, whether the software does exactly what the business needs. Today I can build an app in two hours. Code is cheap, the expensive part is everything before it and after it.
A few days ago I built an app in two hours that a year ago would have taken a team and several months. And the whole time I felt it was the least important part of the work.
The owner of a company sent me a brief. A few pages of bullet points: what the system should do, who will work in it, where the data should come from. I handed it to my coding agents, and two hours later I was looking at a, let's say, working app. Twenty modules, more than ten user roles, ten integrations with data partners. You could click through it from the login screen to the last report.
It looked finished. And that is exactly the problem.
#The year that changed how I build software
I have been designing and building digital products for more than seventeen years, the last ten of them building software for founders and their businesses. In that time I have seen plenty of tools that were supposed to change everything. Most of them changed very little.
This year was different. At the start of the year coding agents suddenly started to really work, and over the last six months they completely changed how we build software and products. I try to stay at the edge of what is possible today, and I keep one rule: build with future in mind. I build as if whatever still creaks today will just work six months from now.
So with one of my recent proposals I tried to question everything about how I had worked until now. For years it was two separate pieces. First product discovery: two to four weeks with the client, working through their vision, designing the solution, figuring out what work the system should take off people's hands, and translating it into a technical specification. At the end the client knew exactly what we were building, how long it would take, when they would get it and what it would cost. Then came the build, which took months and carried most of the budget. Two pieces, two prices.
Today the build takes days and the first clickable version takes hours. Agents have solved execution. So where is the value now?
#Code is cheap. Software isn't.
The argument I hear most often these days goes like this. Agents cost a few euros a month, code is almost free, so software should be cheap too.
The first half is true. Code is cheap and it will get cheaper. But in my experience the code never decided whether software pays off. That was true a year ago and it was true ten years ago. What decided it was always everything that happens before the first line is written, and everything that comes after. Yet the build was so long and so expensive that those were exactly the parts left with the scraps.
So where does the money the build used to eat go? It doesn't disappear. It flows to where the outcome is decided.
For years a product got one shot. Development ate most of the budget, so we often couldn't afford to go deep. A lot of important things were overlooked, or there simply was no money left for them. Today we can afford it. We can go deep and take more than one shot: build it, show it, change it and build it again until it fits.
The same goes for the other end. Few people realise that delivered software is only the beginning, and that everything after it costs money too. There used to be nothing left for that. Today there is. For the same money you don't just get an app, you get software that actually takes root.
I don't want to turn this into a product management lecture. I just want to name what really has value today: turning the vision into a solution, and then getting that solution into reality.
It works from the other side too. Not long ago companies ordered a solution specification or an architecture design as a product of its own. Today that is almost unthinkable. A capable person designs an architecture with a coding agent very quickly. The value is not in the document. It is in what you put into it.
#Before the code: staying close to the client
Back to the two-hour app. The agents built exactly what was in the brief. But the brief was vague. Nobody had checked it, and nobody had sat down with the owner to go through it.
Reality is almost certainly different. The owner may need a different way of working than the one the agents assumed. They may want to track different data. The overview they open first thing in the morning may look completely different in their head, and they may want to run something else with it than what the agents read from the bullet points. A vague brief makes a vague app. Just very quickly.
That is why I see the most value today in the part that looks the least technical. Being in touch with the client. Working on it together, intensively and again and again. We take every bullet point of their vision, break it down into small pieces, and for each one we ask: does this really solve your company's problem? How does it solve it? What will change once it works? More revenue? Fewer people burned out by heavy admin?
The two-hour prototype isn't useless. It is a great way to start the conversation. The client sees their vision running for the first time and can immediately say what is off. But the value isn't in the prototype. The value is in that conversation.
The result is a precise specification for the coding agents. I translate the client's vision into a language in which the agents build it right. And AI won't do this translation for us for a while yet, because the answers aren't in any document. They are in the owner's head and in how their company really works. And that is usually a huge mess. Organised chaos, but chaos. You need to be able to find your way through it and see the problem that really hurts the company and that we can solve. Sometimes a whole new vision comes out of it, a new product.
Which makes it all the more important that the specification is precise. Today you need to be more careful and more thorough than ever, not faster. Once we hand it to the agents, they build it quickly and literally. What we didn't think through doesn't get caught by a developer's question over coffee. It goes straight into the code, and mistakes like that can pile up into something dangerous that we only see in the finished result.
It doesn't have to be a disaster. As I wrote in Recompile, don't refactor, when we design something wrong, I don't fix it in the code. I change the product definition and the agents rebuild the app in a few hours. Recompiling is a normal part of design today. But you still need to be thorough, so we don't build the same thing a hundred times over.
#In the code: does it do what it should?
I still meet people who review every line of code. I understand why, but I think it is unrealistic today. When AI produces a fairly complex app in two hours, no human can read and understand all that code.
And not because it's bad. Quite the opposite. The code agents write today is in many ways on par with top senior developers, and well above the average development I have seen over the years. Agents make fewer and fewer mistakes in code, and I think in six months they won't make any at all.
What you should worry about is something else. Logical and factual errors. The system looks like it works, but it doesn't do exactly what the owner intended. A number calculated the wrong way, a status that switches one step too early, a report that is only right some of the time. When you build twenty modules and ten integrations from a few pages of unchecked bullet points, it is almost certain that a bug like that is in there somewhere. And one slip that we only notice later is enough. In the meantime its damage keeps piling up.
That is why I no longer focus on whether the code is bug-free and whether a function passes a test. I look at whether the system does exactly what it is supposed to do. I set up the checks and scenarios every version has to pass before the agents write the first line, and they come straight from what the client and I talked through. And they don't stop at deployment. I keep watching what the system does afterwards, because that is exactly where these bugs show up.
All of this is guarded by a setup of agents and checks that I have tuned for hundreds of hours on systems running in production. One of them now runs field services on its own: it takes a request, picks a person and sends them on site.
That is also why the cost of code is never zero. You pay for orchestrating the agents and for the know-how from hundreds of hours of struggling and testing how to do it well. Not on experiments, but on real projects I have delivered to clients, and that know-how compounds with every new one. And above all you pay for how much you can rely on the result. That is what I put my name to: the system your people work with works the way we agreed. Nobody has a complete answer to silent bugs today. The difference is whether you look for them systematically, or wait for a customer to run into them.
#After the code: deployment into reality
For years I have been saying one thing: when we finish the software, the work has only begun. The biggest job was never writing it. The biggest job is what comes after. I call it deployment into reality.
Software has to take root in reality. And reality is messy. It runs into people who have done things their own way for years. Into old processes nobody ever wrote down. Into the exception only one person in the company knows about. Into habits, and into the fear that the new system will take someone's job. With a product for customers, into a market that first has to be opened.
You have to get it into that reality. Put it in people's hands, teach them to work with it, align that messy layer of the world around it. And then adjust it, because you never design everything right on the first try. It didn't happen a year ago, it didn't happen before coding agents, and it doesn't happen today. The difference is that a change that used to mean more weeks and another invoice now takes days. Iterating is finally cheap. Knowing what to change isn't.
#Twenty weekends
Another business owner recently told me something I keep coming back to. He knows that with AI today he could build it himself. He just doesn't want to burn twenty weekends.
He has a company and people waiting for his decisions. The company needs him to grow it. And he has a family. Every weekend spent on his own app would cost him time and focus that belong elsewhere. So he wants to hand it to someone capable, who knows the field and has done it before.
That isn't weakness. It is the right call for an owner. The question today isn't whether you can build software yourself. It's what it will cost you.
#What I believe
- Code is cheap. Software isn't. You pay for what comes before the code and after it.
- The best specification comes out of conversation. Together with the client, again and again, in depth.
- The most expensive bug looks like it works. I guard what the system does, not how it is written.
- Finished software is a beginning. It only has value once it takes root in reality.
- Build with future in mind. Agents have solved execution. Judging what to build is still up to us.
#Got a brief in a drawer?
If you have a brief like that tucked away somewhere, feel free to send it over, even if it's just a few bullet points. I'll hand it to my agents and we'll see what they build. At the very least it'll be fun, and we can look together at what's missing.
Code is cheap. Software isn't.
AI-era evangelist. I show what one person can do today: I build generative AI solutions and share what I learn along the way. Get inspired, take what’s useful, and go build. Working on something similar? Message me.