AI Writes the Code. Verifying It Is Still on Us
A year and a half of building software with AI has changed literally everything.
Eighteen months ago, LLMs were fairly capable coding assistants: autocomplete on steroids, generating functions, refactoring, that sort of thing. Today, AI writes almost all of our code. It feels like writing code has stopped being a developer's main job altogether.
So what's left for us?
The job moved up a level
Architecture, system design, feature design. Even there we rarely start from a blank page anymore. Usually we ask an LLM for a draft, review it, point out the problems, argue, and send it back for another round. In short, we work with it much like we would with another developer. At some point we sign off on the design and move on.
If the task is big enough, it has to be broken down — and more often than not, the AI does the breakdown too. We check the plan, fix the dependencies, define the stages, and launch agents to implement it all.
It looks like a perfectly reasonable process, and on the whole it already works pretty well. But there is one problem that, in my view, is becoming the central one in this whole story.
How the hell do we verify the result?
And I don't just mean the code.
Say an agent has produced a system design. How do we know it's correct? That we haven't missed some important constraint? That the chosen architecture actually solves our problem, rather than just looking convincing?
Fine, the design is approved. The agent has broken it down into tasks. How do we check that nothing got lost along the way? That every requirement is covered? That the tasks don't contradict each other?
Then the agents write the code. Tests are green, the linter is quiet, everything builds.
Great. But is this actually what we asked for?
Generating is cheap. Verifying isn't
This, I think, is where we hit the most interesting problem in AI-driven development today:
Generating artifacts keeps getting cheaper. Verifying them doesn't.
What's more, the more work we delegate to agents, the more output we have to check. And the further we are from the actual implementation, the harder it is to tell where exactly things went wrong.
Sure, we can ask another agent to check the first one. Then a third one to check the second. But that doesn't solve the fundamental problem — we're just adding another layer of generation, whose output also has to be verified somehow.
And I'm not saying a human should reread every line of code by hand. Do that, and we lose a big chunk of the benefit of all this automation.
Every stage needs a proof
What we need is a process where every stage has a clear way to prove that the result meets expectations:
- From requirements to system design.
- From design to breakdown.
- From breakdown to implementation.
- From implementation to a working system.
And not just "the agent said everything is fine", but something checkable: criteria, invariants, contracts, tests, requirements traceability. Something you can trust no matter who wrote the code.
Where the engineering is now
Maybe that's where the main engineering work is right now. Not in learning to prompt better. Not in running more agents in parallel. Not even in coming up with the perfect system design.
It's in building a process that lets us reliably establish that we got exactly what we wanted.
Because AI is already perfectly capable of writing the code for us. But knowing that it wrote the right system is still our problem — and it doesn't seem to be getting one damn bit easier.