“I built this application in three hours with AI.”
Great. How much time are you spending looking after it six months later?
I’m genuinely pleased that we can build useful applications this quickly. I work with AI agents myself, and there are projects I can now justify taking on that wouldn’t have made sense before.
But the build time only tells me part of what I want to know. If an application saves me an afternoon upfront and then interrupts me every week, I’d like to include those interruptions in the calculation.
“It only takes fifteen minutes to fix”
Suppose an automated import fails on Monday morning. The fix takes fifteen minutes.
Before that, someone notices that the data is missing, checks whether the import is still running, and sends a message. I stop what I’m doing, recover the context, find the problem, and fix it. Then I need to check whether rerunning the import will duplicate anything and whether the people using the data can trust it again.
The code change may be tiny. Looking after the incident isn’t.
And if this happens regularly, the users start checking the import themselves every morning. Now the automation also comes with a manual supervision task that probably wasn’t part of the original estimate.
That’s the kind of cost I want to avoid when I design software. I want to be able to leave it alone and get on with other work. So do the people using it.
What changes when an agent does the fixing?
Quite a lot, potentially. An agent can investigate a failure, propose a correction, run tests, and save me much of the technical work. I use that help.
But a quick fix doesn’t necessarily settle the incident. If an import skipped records before failing, those records still need recovering. If a billing bug produced incorrect invoices, fixing the calculation doesn’t correct the invoices already sent.
Someone, or an automated process we’ve deliberately put in place, still needs to establish what happened and deal with the effects.
We can automate more of this too. We can detect failures, make retries safe, check results, and provide a way to recover. But those capabilities have to be designed and verified. They don’t arrive automatically because an agent can edit the code.
I’d rather use the agents to help make the import dependable than repeatedly ask them to repair it on Monday mornings.
What I’d actually measure
Alongside development time, I’d like to know how many hours of human attention an application needs each year to keep doing its existing job.
That includes investigating failures, checking suspicious results, carrying out manual recovery steps, and helping users work around problems. Planned feature development is a separate question.
Even a rough record would give us a more useful comparison than build time alone. Two hours a month is seventy-two hours over three years, before counting the time spent by affected users.
That doesn’t prove we should have spent another two weeks building the application. The cheaper version might still be the right choice, especially for a short-lived tool with minor consequences when it fails.
For software people will use for years, or where an interruption stops several people from working, the calculation can look very different. I’d rather make that trade-off explicitly than assume the fastest build is the cheapest option.
Hours of attention aren’t the whole picture either. A rare failure that loses important data can matter more than frequent small interruptions. But they’re a useful thing to track, and they’re easy to overlook when all we’re showing is how quickly the first version appeared.
We also need to choose what to build
There’s another reason this matters: we’re going to build a lot more software.
An idea that once wasn’t worth a week of development can now become an application in an afternoon. That’s useful, but if every new tool needs regular attention, the maintenance adds up. A few small applications each needing two hours a month can become a substantial part of someone’s job.
Before building, I’d want to know how often the problem occurs, how much work the tool will actually save, and whether something we already use could do the job. An application that saves an hour a month but needs two hours of looking after isn’t much of an improvement, however quickly we built it.
Some ideas are worth trying precisely because trying them is now cheap. But I want to be able to retire an experiment that isn’t useful, rather than keep maintaining it because a handful of records or a forgotten integration make it awkward to remove.
Choosing what deserves to become a lasting part of the business matters more when we can produce so much of it.
Where I want to spend the time we save
With agents handling much of the implementation, there’s more room to work on what happens after delivery: testing failure cases, checking that backups can actually be restored, making problems visible, and removing recurring manual interventions.
The priorities depend on the application. I don’t need an elaborate recovery setup for a throwaway experiment. For a tool someone relies on every day, I do want to know how we’ll find out it’s broken and how we’ll get it working again.
That’s part of delivery for me, not an optional cleanup once the features are finished.
I still enjoy getting an application working in a few hours. But I’d be much happier to hear, six months later, that people are using it every day and haven’t needed to call me.
This is the third of four follow-up articles to Cheap to build does not mean disposable.
Valérian de Thézan de Gaussan