Agentic AI Is Not About Writing Code Faster
Most discussions about AI in software development focus on productivity.
Can AI write code faster?
Can AI replace developers?
Can AI generate pull requests?
I think these questions miss the biggest opportunity.
The real opportunity is not faster coding. It is making software engineering practices economically viable that were previously too expensive to maintain.
A Lesson From Outsourcing
Years ago, many companies outsourced software development.
The results were mixed.
The common explanation was that the external teams were less capable than the internal teams.
I think a more interesting explanation exists.
Outsourcing exposed a problem that had always been there: most organizations were poor at defining requirements.
Internal teams compensated for missing information because they possessed context, history, and domain knowledge. They knew what stakeholders really meant. They understood the unwritten assumptions.
Once development moved elsewhere, those assumptions became visible.
The same thing is happening with AI coding agents.
When an agent produces unexpected output, we often conclude that the agent is unreliable.
Sometimes it is.
But often the agent is simply exposing ambiguity that was already present.
The difference is that a human developer would have filled in the gaps.
We Have Always Known What Good Engineering Looks Like
Most engineers would agree with the following principles:
- A feature should be clearly defined.
- Requirements should completely describe the intended feature.
- Requirements should be testable.
- Every requirement should have a validation strategy.
- Every line of code should be traceable to at least one feature.
- Requirements across features should complement each other and not contradict each other.
None of these ideas are new.
Safety-critical industries have operated this way for decades.
The problem was never that these ideas were wrong.
The problem was that maintaining the necessary traceability was expensive.
Documentation drifted.
Tests became disconnected from requirements.
Code accumulated without clear ownership or purpose.
People stopped maintaining the links because the cost exceeded the perceived benefit.
The Industry Chose Pragmatism
Over time, software development optimized itself around human limitations.
Humans are good at handling ambiguity.
Humans can infer intent.
Humans can fill in missing context.
As a result, many organizations learned to tolerate incomplete specifications because experienced developers could compensate.
The process worked well enough.
Until it didn't.
The cost appears later:
- inconsistent implementations
- undocumented behavior
- fragile systems
- knowledge silos
- expensive maintenance
- onboarding difficulties
- endless discussions about intent
These costs are often accepted as unavoidable consequences of software development.
I am not convinced they are.
The Cloud Analogy
When cloud computing emerged, many organizations asked:
"How can we run our existing servers on somebody else's infrastructure?"
The most successful organizations asked a different question:
"How should systems be designed when infrastructure becomes elastic and programmable?"
The winners were not the ones that copied existing practices into the cloud.
The winners were the ones that changed their architecture.
I believe AI presents a similar opportunity.
Most organizations currently ask:
"How can AI help developers write code faster?"
A more interesting question is:
"How should software development work when traceability, review, testing, and analysis become dramatically cheaper?"
AI Changes the Economics of Rigor
Historically, maintaining strong traceability required discipline.
People forget.
People skip documentation.
People postpone testing.
People move on to the next deadline.
The challenge was never understanding what should be done.
The challenge was consistently doing it.
Agentic AI changes this equation.
An agent can continuously verify:
- every feature has requirements
- every requirement has tests
- every test maps back to requirements
- every code change maps to features
- requirements do not contradict each other
- dead code has no valid traceability
None of these activities are particularly difficult.
They are simply tedious.
Humans avoid tedious work.
Machines do not.
Stop Treating AI Like a Human Developer
A common mistake is viewing AI as a simulated engineer.
Can it reason like a senior developer?
Can it replace a team member?
Can it perform code reviews?
These questions frame AI as a human substitute.
I think that is the wrong mental model.
Nobody asks whether Git thinks like a developer.
Nobody asks whether Kubernetes thinks like an operator.
Nobody asks whether a compiler thinks like a programmer.
These tools changed software development because they performed tasks humans could not perform efficiently.
AI may follow the same path.
Its greatest value may not be writing code.
Its greatest value may be maintaining consistency across an entire engineering system.
The Real Opportunity
I am not arguing that requirements-driven development is a new idea.
I am arguing that it may finally be practical.
For decades, software teams have accepted trade-offs because the overhead of rigor was too high.
Now that overhead is shrinking.
The opportunity is not to make today's process 20% faster.
The opportunity is to rethink the process itself.
Instead of asking:
"How can AI fit into our current way of working?"
We should ask:
"What engineering practices have we avoided because they were too expensive, and what happens when they are no longer expensive?"
That is the experiment worth running.
And I suspect the organizations that win in the age of agentic AI will not be the ones that generate the most code.
They will be the ones that generate the most clarity.