As AI handles coding reliably, most software bugs shift from implementation errors to specification errors

Claim

When AI agents can reliably produce correct implementations of stated intent, the dominant bug class shifts from implementation errors (wrong code) to specification errors (wrong ask).

Mechanism

Coding bugs exist because of the gap between human intent and machine execution. When AI narrows that gap reliably, failures concentrate at the earlier boundary: what the human asked versus what the human actually needed. Specification bugs survive AI because they originate before code generation begins. They are not coding problems. No amount of AI coding capability eliminates the error of asking for the wrong thing.

Conditions

Holds when: AI coding reliability is high enough that implementation errors are rare for the task class at hand.

Fails when: AI reliability is still partial, and implementation errors remain frequent enough to warrant traditional debugging and code review.

Evidence

Ball published these beliefs from direct experience building and shipping with Amp. His framing is direct:

"Most bugs won't be 'coding' bugs...they'll be 'you asked for the wrong thing' bugs"

Signals

• Bug reports increasingly describe behavior that was correctly implemented but wrong by product intent.
• Post-mortems trace failures to requirement ambiguity rather than coding mistakes.
• Engineers spend more time clarifying requirements and reviewing specs than reviewing code.
• The question "did it do what I asked?" replaces "did it do it correctly?"

Counter-evidence

Code review and testing remain relevant while AI reliability is partial in the current period. Security vulnerabilities can emerge from AI-generated code in ways that bypass specification-level thinking entirely. Safety-critical domains may retain high implementation error rates for some time because stakes demand additional human verification layers.

Cross-references

• Engineers who dismiss AI-generated code as low-quality apply the same professional bias that causes domain experts to over-intervene within their specialty: the pattern of humans over-correcting AI because they cannot evaluate output at speed, which this shifts.
• Minimizing time-to-feedback is the single most valuable practice when building new software: the prior frame on software as a learning process, which specification clarity now extends.
• Engineering ownership begins with naming the actual problem, not accepting the proposed solution: the ownership principle that maps cleanly to spec-first thinking.
• Language selection criteria shift from developer preference to agent performance when agents write most of the code: the downstream consequence for stack selection when agents write the code and specification quality governs output quality.
• When agents write code, the decisive technology selection criterion is whether failure modes are legible to the agent: the infrastructure criterion that surfaces specification-level failures early in agent-written systems.