The August 2026 issue of Communications of the ACM published a claim worth sitting with: neural coding "may represent a potential endpoint for software engineering as a rigorous, intellectual discipline." The author isn't wrong to raise the alarm. They're wrong about what's ending.
There's a meaningful difference between the end of a discipline and the relocation of it. The discipline of rigorous software engineering hasn't disappeared — but where it lives has moved faster than most developers have tracked it.
What "The End of the Coder" Is Actually Pointing At
The concern in the CACM piece is grounded in something real. When DX Research tracked AI-authored code share across 500+ engineering organizations, it crossed 52% of merged production output in Q2 2026, up from 34% in Q1. The average developer now ships more code they directed an agent to write than code they wrote themselves.
That shift has a measurable human cost. DX's Developer Experience Index — an aggregated score across 500+ customer organizations — fell from 67 in Q3 2025 to 65 in Q2 2026. It is the first time in DX's history the index has moved downward. Over the same window, AI spend at the largest companies in the dataset rose approximately 28x year over year. The innovation ratio — which tracks how much engineering output is novel versus maintenance or rework — went up by about one percentage point.
That's the empirical version of the CACM concern: 28x more AI investment, a 1-point innovation gain, and a developer experience score that's deteriorating for the first time anyone has measured it. Something has gone wrong, even if outputs look better on the dashboards.
METR found a different version of the same signal when they tried to run their no-AI control group for the follow-up to their 2025 developer productivity study. The problem wasn't that developers refused to participate. It's that developers are now so integrated with AI tools they couldn't function without them. METR had to change their experimental design because the control condition was no longer possible. The discipline, or what remains of it, has become inseparable from the tool.
What the Endpoint Framing Gets Wrong
The claim that software engineering as a rigorous discipline may be ending implies the rigor is disappearing. The data suggests something different: the rigor is relocating, and a lot of developers haven't caught up to where it went.
Here's the clearest version of this. Anthropic's 2026 Agentic Coding Trends Report found that developers use AI in roughly 60% of their work but say they can fully delegate only 0-20% of tasks. That gap has been stable for over a year despite models improving substantially. It is not a model capability problem. The models can handle more than developers give them.
The delegation gap is a specification problem. When you write code yourself, imprecision is self-correcting — you encounter the edge case, you resolve it, you keep going. When you delegate to an agent, every underspecified part of your brief becomes a branch point where the agent guesses. The agent runs to completion, produces confident-looking output, and you discover three hours later that it violated an architectural constraint you didn't mention because you assumed it was obvious.
Specification precision is the rigor that matters now. It requires knowing what correct looks like before the implementation exists, which is more intellectually demanding than knowing what correct looks like while you're building it. The discipline moved upstream. Writing a brief that produces mergeable agent output on the first run is harder than writing code with the same result, not easier.
What Actually Ended
Some skills did end, or at least lost most of their value. Syntax memorization. The ability to write boilerplate fast. Knowing which method to call from an API you've used a hundred times. These were real skills before AI, and they're now table stakes at best.
What didn't end: systems thinking. The ability to hold a complex architecture in working memory and evaluate whether a proposed change degrades something three layers away. Security reasoning — knowing which patterns produce vulnerabilities before you see the output. The judgment that a plausible-looking answer is wrong because it contradicts something the agent didn't have access to.
The CACM piece describes the profession as "shifting from writing syntax to auditing complex systems." That's accurate, but it undersells what auditing complex systems actually requires. The developer who reviews an AI-generated implementation without understanding how it fits into the broader system isn't auditing — they're approving. That's a different job, and it's a less rigorous one.
The developers who are struggling with this transition aren't the ones who lack technical depth. They're often the ones whose primary skill was implementation speed. Neural coding ends the productivity advantage of writing faster. It does not end the advantage of understanding better.
Where the DXI Decline Points
The fall in DX's Developer Experience Index tells you something specific about where the transition is failing.
Developer experience degrades when the work is harder to do well without producing better outcomes. If AI tools were relocating rigor in a way developers could adapt to, experience scores would be neutral to positive — harder in some ways, but in ways that feel meaningful. The fact that they fell while AI adoption approached 100% and AI spend rose dramatically suggests that developers are absorbing the costs of the transition without capturing the benefits.
Part of this is the review problem: AI generates larger PRs that take longer to evaluate, and the expanded review burden doesn't come with a commensurate increase in reviewer capacity. Part of it is the specification burden: writing a good brief is harder than it looks, and developers who are still prompting like they're talking to a junior engineer are spending significant time on redirect cycles. Part of it is the accountability fog: when 52% of your code is AI-authored, it's less clear what you built, which makes it harder to feel ownership of what ships.
The DXI fell because the transition has been faster than the adaptation. That's not a reason to conclude the discipline is ending. It's a reason to take the relocation seriously.
The Measurement Version of This
If rigor has relocated from implementation to specification and review, then the metrics most teams are using to track engineering quality are measuring the wrong layer.
Coding time is no longer the primary constraint for most developers — and tracking it as if it were misses where quality is actually determined. The relevant signals now are things like first-pass agent success rate (how often does the output require substantial revision), downstream defect rate on AI-assisted code versus human-authored code, and specification iteration count per feature. Those numbers tell you where the rigor is and whether it's working.
Most engineering teams don't track any of them.
At xeve, we track time allocation across the full development workflow — not just the editor, but specification work, review cycles, communication, planning. The pattern in developers who are adapting well to the transition looks different from the pattern in developers who aren't: more time in specification before a session starts, shorter review cycles afterward, tighter in-session switching patterns. The rigor shows up as a rhythm, not a metric you can read off any individual tool.
What CACM Got Right
The CACM concern is legitimate. A developer who delegates 80% of their work to agents and reviews the output at low fidelity is not practicing software engineering as a rigorous intellectual discipline. They're practicing something that produces code quickly and may or may not produce good software. That's a real risk, and it's happening at scale.
But the correct response isn't to mourn the endpoint. It's to understand where the rigor went and whether you're doing it there.
The specification layer is harder than it looks. The review layer is harder than the approval rate implies. The developers who are maintaining rigor in this environment are the ones who figured out that the discipline moved — not disappeared — and who redirected their attention accordingly. The ones who haven't made that move are the ones contributing to the DXI decline.
Neural coding didn't end software engineering as a rigorous discipline. It changed the address. Most developers haven't updated their navigation yet.