# Engineering Fundamentals Are Now the Agent Interface > Source: > Published: 2026-08-16 07:08:17+00:00 [Dev Tools](https://sourcefeed.dev/c/dev-tools)Article # Engineering Fundamentals Are Now the Agent Interface The delivery data behind AI coding says tests, boundaries, and review are what the tools actually run on. [Lenn Voss](https://sourcefeed.dev/u/lennart_voss) Joseph Heck's essay ["Software engineering fundamentals matter more than ever"](https://rhonabwy.com/2026/08/15/software-engineering-fundamentals-matter-more-than-ever/) spent Friday on the Hacker News front page, and it would be easy to file it under graybeard nostalgia — the recurring genre where a veteran reminds everyone that testing and architecture still exist. That's not what's interesting about it. What's interesting is that three years into the agentic-coding era, the empirical record now backs the fundamentals crowd more strongly than their own rhetoric does. The essay is right, and if anything it undersells the case. ## What the data actually says Start with the numbers, because this argument has been vibes-versus-vibes for too long. [DORA](https://dora.dev/dora-report-2025/)'s 2025 State of AI-assisted Software Development report — the largest ongoing study of delivery performance — landed on a blunt conclusion: AI is an amplifier. Teams with strong platforms, fast feedback loops, and healthy review culture converted AI assistance into real throughput. Teams with brittle processes got their dysfunction accelerated. The tool didn't determine the outcome; the surrounding engineering system did. [METR](https://metr.org/blog/2026-02-24-uplift-update/)'s randomized controlled trial made the sharper point about perception. Experienced open-source developers working in mature repositories were 19% *slower* when allowed to use early-2025 AI tools — while estimating, afterward, that the tools had made them 20% faster. METR has since flagged the result as historical and is rerunning the experiment against current tooling, which is fair; agents in mid-2026 are meaningfully better than Cursor with Claude 3.7. But the perception gap itself is the durable finding. Developers are demonstrably bad at judging whether these tools are helping, which means the only trustworthy signal is external measurement — instrumentation, benchmarks, delivery metrics. That's a fundamentals skill. Then there's the code itself. [GitClear](https://www.gitclear.com/ai_assistant_code_quality_2025_research)'s analysis of 211 million changed lines found duplicated code blocks up roughly eightfold in 2024, copy-pasted lines exceeding refactored ("moved") lines for the first time in the dataset's history, and refactoring collapsing from 24% of changes in 2020 to under 10%. That's the shape of a codebase written by a tool that finds it cheaper to generate a new function than to discover an existing one. Nobody who's watched an agent reimplement a utility that already lives three directories away will find this surprising. ## Fundamentals stopped being virtues and became the interface Here's the reframe Heck gestures at that deserves to be said louder: the classic disciplines didn't survive the AI transition as moral hygiene. They survived because they turned into the *operating controls* for the tools themselves. Heck's formula for effective agent use is "good, concise data to work from, at the right time, and providing deterministic validation tooling." Decode that and it's a list of things senior engineers were already supposed to be good at, repurposed as machine interfaces: **Tests are the reward function.** An agent iterating against a red/green loop converges; an agent iterating against "looks right to me" wanders. Heck explicitly prompts models to work TDD-style, and this matches what every serious agent harness has converged on — the test suite is no longer a safety net you maintain out of guilt, it's the primary channel through which you specify intent to a system that, as he puts it, doesn't reason but predicts.**Types and linters are deterministic feedback.** A strict compiler gives the model a signal it can't argue with. Dynamically typed, loosely linted codebases give agents the most room to hallucinate plausibly.**Architecture is context-window economics.** Small, layered, composable modules were always nice. Now they're the difference between an agent that can hold the relevant blast radius in context and one that's pattern-matching against fragments. The GitClear duplication explosion is partly a story about codebases whose structure defeats discovery — by humans and models alike.**Security boundaries are non-negotiable.** Heck leans on[Simon Willison](https://simonwillison.net/2025/Jun/16/the-lethal-trifecta/)'s lethal trifecta: an agent with private-data access, exposure to untrusted content, and an exfiltration channel is exploitable by construction, because prompt injection has no reliable model-level fix. The mitigation is capability design — deciding what the agent simply cannot touch — which is systems thinking, not prompting. The inversion here is worth sitting with. The skill AI actually commoditized — producing syntactically correct code quickly — was never the bottleneck on real teams. The bottlenecks were specification, decomposition, verification, and review. Agents made those *more* scarce, because they multiplied the volume of plausible code flowing toward them. ## What to do about it, concretely If you run a team, the practical agenda falls out directly. Invest in the deterministic layer first: strict typing where the language allows it, aggressive linting, fast hermetic test suites — because every hour there now pays out twice, once for humans and once for every agent run. Write and maintain the repo-level context files (`AGENTS.md` , `CLAUDE.md` , whatever your tooling reads) as engineering docs, not prompt hacks; they're the "concise data at the right time" in Heck's formula. Treat review capacity as the constraint it now is — GitClear's churn numbers (new code revised within two weeks nearly doubled since 2020) are what merged-but-unreviewed slop looks like at scale. And audit your agents against the trifecta before someone else does. One caution against overcorrecting: "fundamentals first" is not a license to sit out. DORA's amplifier finding cuts both ways — disciplined teams using AI outperform disciplined teams that don't. The essay's real claim, and the right one, is about sequencing. The organizations winning with agents in 2026 aren't the ones that adopted fastest. They're the ones whose testing, architecture, and boundaries were strong enough that adoption had something to amplify. Everyone else is discovering that an agent pointed at a weak engineering system is just entropy with good manners. ## Sources & further reading - [Software engineering fundamentals matter more than ever](https://rhonabwy.com/2026/08/15/software-engineering-fundamentals-matter-more-than-ever/)— rhonabwy.com - [Software Engineering fundamentals matter more (discussion)](https://news.ycombinator.com/item?id=49314902)— news.ycombinator.com - [State of AI-assisted Software Development 2025](https://dora.dev/dora-report-2025/)— dora.dev - [Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity](https://arxiv.org/abs/2507.09089)— arxiv.org - [We are Changing our Developer Productivity Experiment Design](https://metr.org/blog/2026-02-24-uplift-update/)— metr.org - [AI Copilot Code Quality: 2025 Data Suggests 4x Growth in Code Clones](https://www.gitclear.com/ai_assistant_code_quality_2025_research)— gitclear.com - [The lethal trifecta for AI agents](https://simonwillison.net/2025/Jun/16/the-lethal-trifecta/)— simonwillison.net [Lenn Voss](https://sourcefeed.dev/u/lennart_voss)· Cloud & Infrastructure Writer Lenn writes about cloud platforms, Kubernetes internals, and the infrastructure decisions that quietly make or break engineering organizations. Based in Berlin's vibrant tech scene, they have a talent for turning dense platform-engineering topics into prose that people actually finish reading. ## Discussion 0 No comments yet Be the first to weigh in.