Writing code used to be the hard part. It is not anymore. AI assistants now produce working code in seconds, and the cost of typing a function into a computer has fallen close to zero. But shipping software a business can actually trust has not gotten cheaper. The hard parts, designing a system that holds together, verifying that it works, keeping it secure, and keeping it maintainable, are still human judgment, and in several measurable ways AI is making them harder. This is where the bottleneck moved, and the evidence is now clear enough to act on.
Writing code got cheap
Start with the part almost everyone agrees on. Producing code has been commoditized. Simon Willison, one of the most widely read voices in practical AI engineering, put the economics plainly in his 2026 guide “Writing code is cheap now”: “Delivering new code has dropped in price to almost free.” The same guide states the catch in a single line: “delivering good code remains significantly more expensive than that.”
That gap is the whole story. If the job is to produce a well-defined piece of code, AI does it fast. The trap is assuming that is the same as delivering software.
Faster typing is not faster delivery
It is not. The most rigorous study on this is a 2025 randomized controlled trial from METR, which measured experienced open-source developers working on real issues in large codebases they knew well. The result ran against everyone’s intuition: developers using AI tools took 19% longer to complete their issues. The same developers believed the tools had made them roughly 20% faster. The perception gap is the finding. People feel faster while shipping slower.
Addy Osmani, an engineering leader at Google, named the mechanism in “The 70% Problem”: AI gets you most of the way, then stops. “The hard parts of software development, understanding requirements, designing maintainable systems, handling edge cases, ensuring security and performance, still require human judgment.” For senior engineers, he adds, that last 30% is often slower than writing the code from scratch yourself.
The pattern: more code, written faster, with the real cost pushed downstream into review, integration, and trust. Once typing stops being the constraint, four older constraints decide whether the work is any good.
Architecture and quality: the system still has to hold together
More code is not better code, and the data on AI-era codebases is not flattering. GitClear, analyzing 211 million changed lines from 2020 to 2024, found that copy-pasted code rose from 8.3% to 12.3% of all changed lines, while refactoring, the work of moving and consolidating existing code, collapsed from 25% of changes to under 10%. For the first time in their records, copy-paste exceeded reused code, and code churn is on track to double against its pre-AI baseline. Duplication going up while consolidation goes down is the signature of accumulating maintenance debt. The system still needs a coherent design and a human deciding how the parts relate, and that judgment is exactly what a model generating code in the small does not supply.
Verification: more output means more to check
When writing gets cheaper, reviewing does not, and the work piles up downstream. Google’s 2024 DORA report, the largest ongoing study of software delivery, found that AI adoption raised individual productivity and yet “negatively impacts software delivery stability and throughput.” As reported by InfoQ, AI adoption was associated with a 7.2% decrease in delivery stability, and 39% of developers reported low or no trust in AI-generated code. The report’s own explanation is mechanical: AI makes each change bigger, and bigger changes are riskier to ship. The constraint moved from writing the change to confirming the change is correct.
Security: the model will not police itself
This is the constraint with the clearest evidence and the highest stakes. A Stanford study presented at ACM CCS found that developers with an AI assistant “wrote significantly less secure code than those without access,” and, worse, were more likely to believe their code was secure. The overconfidence rides along with the vulnerability. The fix is not a better prompt.
Security has to be an enforced property of the system, not something you ask a model to remember. That is a design and review problem, not a generation one.
This is where the work moved
Put the four together and a single picture forms. The cost of writing code fell, so the binding constraints are now the things a model cannot be trusted to do on its own: design a coherent system, keep it maintainable, verify that it works, and prove that it is secure. These are exactly the judgment-heavy, expert-bottlenecked parts of building software, and they get more important as more generated code flows past them.
This is the work we build around at Soba Labs. We build AI-native software where agents handle the volume and a person stays at the edge, approving what matters, with confidence gates and review points on the parts that carry real risk. We sell the outcome at a fixed price, not developer hours, and we run our own company on the same closed loop we build for clients. Sitting on architecture, verification, security, and quality is not a preference. It is where the constraint actually is.
Two of those constraints have had their own posts since. Once agents handle the volume, the binding resource becomes the context window, and the harness gives you four separate levers on it, not one. The volume also arrives with a bill: routing our own coding agents through an open source CLI proxy saved 49.6% of tokens across 1,457 commands.
The takeaway
“Coding is no longer the bottleneck” is not a claim that engineering got easy. It is a claim that the hard part moved. The teams that win the AI-native shift will stop measuring output in lines of code and start investing in the judgment that turns generated code into software a business can trust. Build for where the bottleneck is now, not where it used to be.
Sources
- Simon Willison, “Writing code is cheap now,” Agentic Engineering Patterns, 2026: https://simonwillison.net/guides/agentic-engineering-patterns/code-is-cheap/
- METR, “Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity,” 2025: https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/
- Addy Osmani, “The 70% Problem: Hard Truths About AI-Assisted Coding,” 2025: https://addyo.substack.com/p/the-70-problem-hard-truths-about
- GitClear, “AI Copilot Code Quality: 2025 Research” (211 million changed lines, 2020 to 2024): https://www.gitclear.com/ai_assistant_code_quality_2025_research
- Google DORA, “Accelerate State of DevOps Report 2024” (figures via InfoQ): https://dora.dev/research/2024/dora-report/ and https://www.infoq.com/news/2024/11/2024-dora-report/
- Perry, Srivastava, Kumar, Boneh, “Do Users Write More Insecure Code with AI Assistants?”, ACM CCS 2023: https://arxiv.org/abs/2211.03622