Better models should make AI cheaper. Faster inference, lower API costs, more accurate outputs - the economics should improve over time. But for most development teams, the opposite is happening.
As codebases mature, AI becomes harder to use safely. Verification costs rise. Rework increases. Human oversight becomes mandatory. The cost per useful output goes up, even as the cost per token goes down.
A recent article on DEV Community breaks down why this happens - and what teams should do about it.
The Problem: Context Without Understanding
Modern AI models have massive context windows. GPT-4 can process 128,000 tokens. Claude can handle 200,000. That's enough to fit an entire codebase into a single prompt.
But a large context window doesn't mean the model understands your system. It can see the code, but it can't reason about dependencies, edge cases, or the design decisions that led to the current architecture. When it generates code, it produces plausible-looking output that fits the pattern - but might break assumptions buried three layers deep.
The larger the codebase, the more likely this is to happen. In a small project, the entire system fits in your head. In a mature codebase, nobody fully understands all the interactions. AI doesn't either - it just looks like it does.
Hallucinations Scale with Complexity
AI models hallucinate - they generate confident, plausible, incorrect outputs. In a small project, hallucinations are easy to spot. The model suggests a function that doesn't exist, or uses an API incorrectly, and you catch it immediately.
In a large codebase, hallucinations blend in. The model generates code that looks reasonable, uses real function names, and follows the project's style. But it makes subtle mistakes: calls a function with the wrong signature, assumes a state that doesn't exist, or introduces a race condition that only triggers under load.
These errors don't break the build. They pass code review. They ship to production. And then they cause incidents.
Verification Becomes the Bottleneck
The solution is verification: test the AI-generated code, review it carefully, run it in a staging environment. But verification takes time. For simple changes, it's faster to write the code yourself. For complex changes, you spend more time verifying the AI's work than you would have spent writing it from scratch.
This is the paradox. AI is supposed to make you faster. But in a mature system, the verification overhead often outweighs the time saved.
Multi-Agent Pipelines Don't Solve This
The current trend is multi-agent systems: one agent writes code, another reviews it, a third tests it, and they iterate until the output is correct. In theory, this reduces hallucinations through cross-checking.
In practice, it increases cost without increasing reliability. Each agent call costs tokens. Each iteration adds latency. And agents don't catch each other's mistakes as often as you'd expect - they make correlated errors, because they're trained on the same data and use similar reasoning patterns.
Multi-agent systems work for well-defined, isolated tasks. They struggle with complex, interconnected codebases where the correctness of a change depends on understanding the entire system.
Where AI Still Works: Boilerplate, Documentation, Simple Logic
AI is excellent at generating code that doesn't require deep system understanding. Boilerplate - repetitive, predictable code that follows a template. Documentation - summaries, explanations, and inline comments. Simple logic - functions that operate on local state without touching critical infrastructure.
These tasks have clear inputs, clear outputs, and low risk. If the AI makes a mistake, it's easy to catch. And the time saved is real - you're not writing the same boilerplate for the tenth time, and your documentation actually gets updated.
The article recommends constraining AI to these use cases in mature systems. Let it handle the tedious, low-risk work. Keep it away from architecture decisions, state management, and anything that could break production.
Cost Rising Faster Than Value
The economic problem is simple: as your codebase grows, AI's error rate stays constant, but the cost of each error increases. A hallucination in a prototype is annoying. A hallucination in production infrastructure is a critical incident.
At the same time, the verification cost per change increases. You need more tests, more careful review, more staging validation. The time saved by AI shrinks. The time spent verifying grows.
Eventually, you hit a crossover point where AI is net negative: it costs more to use safely than it saves in development time. For many teams working on mature systems, that point has already arrived.
The Human Oversight Tax
The hidden cost is human oversight. Every AI-generated change requires a human to understand it, verify it, and take responsibility for it. That human has to maintain enough understanding of the system to catch errors - which means they can't fully offload the cognitive work to AI.
This is the opposite of the promise. AI was supposed to let developers work at a higher level of abstraction, focusing on design and letting the model handle implementation. Instead, developers are working at two levels simultaneously: designing the system AND verifying the AI's implementation.
The Recommendation: Constrain AI to Safe Domains
The article's conclusion is pragmatic: in mature systems, constrain AI to tasks where errors are cheap and verification is fast. Use it for boilerplate, documentation, and simple logic. Don't use it for critical infrastructure, complex state management, or anything that touches production data.
This isn't a permanent limitation. As models improve, they'll handle more complex tasks safely. But right now, for most teams, the safe approach is to limit AI's scope rather than expand it.
Better models won't fix this on their own. The problem isn't model capability - it's the gap between generating plausible code and understanding system-level correctness. Until that gap closes, the cost of verification will continue to rise faster than the cost of generation falls.
The full breakdown, including specific examples and cost calculations, is available in the original article on DEV Community.