Do Coding Agents Make Software Engineering Harder? A Counterintuitive Take

A Counterintuitive Verdict

In most discussions around AI programming tools, the dominant narrative centers on "efficiency gains" and "unleashing productivity." But Simon Willison — prominent developer and co-creator of Django — offered a strikingly different observation in a brief note: the more time he spends working with coding agents, the more convinced he becomes that these tools make software engineering harder, not easier.

His exact words: "The more time I spend working with coding agents, the more convinced I am that they make software engineering even harder." It's a statement worth pausing on for every developer who's embracing AI-assisted programming.

The Other Side of Powerful Capabilities: Extreme Demands on Discipline and Knowledge

Simon isn't dismissing the value of coding agents — quite the opposite. He readily acknowledges that "we can do amazing things with them." The real issue lies in what follows: unlocking their full potential requires extraordinary discipline and knowledge.

This observation cuts to the core tension in today's AI programming tools. On the surface, agents lower the barrier to writing code — you can describe requirements in natural language and have them generate entire blocks of code. But producing software that's genuinely reliable and maintainable with these tools actually demands a deeper engineering foundation than ever before.

Why the Bar Rises Instead of Falls

There are several dimensions to this "harder":

The review burden increases. Agents generate code far faster than humans, but output quality varies widely. Developers shift from being "the ones who write code" to "the ones who review code" — and reviewing large volumes of AI-generated code requires clear judgment about intent, potential vulnerabilities, and edge cases. Developers without experience simply won't spot the problems.

Context management becomes a new skill. Getting high-quality results from an agent requires precisely providing context, decomposing tasks, and setting constraints. This is itself a craft that requires deliberate practice — not something you can accomplish by just "saying the word."

Hallucinations and errors are more concealed. Agents can produce code that looks entirely reasonable but contains subtle flaws. Identifying these issues requires an understanding of the underlying tech stack that goes well beyond "knowing how to use it."

---

Simon Willison's background lends this judgment particular weight. He is a co-creator of the Django web framework — still one of the most widely used frameworks in the Python ecosystem, powering large-scale products like Instagram and Pinterest. He also maintains a long-running blog at simonwillison.net, where he continuously documents his hands-on experiments with LLMs and AI tools. He's one of the rare public technical voices who combines deep engineering credentials with extensive first-hand use of AI programming tools. His perspective comes from practice, not theoretical speculation — which sets it apart from both generic "AI bubble" skepticism and uncritical AI enthusiasm.

"Coding agents" differ meaningfully from standard AI code completion tools like early GitHub Copilot. Code completion tools are essentially passive context-aware suggestions — the developer still drives every step. Coding agents, by contrast, have autonomous planning and multi-step execution capabilities. They can read and write files, invoke terminals, run tests, and iteratively revise based on feedback, completing a series of subtasks independently once given a goal. This "autonomy" is precisely what makes them powerful — and what makes them risky. Errors in an agent's work can compound and amplify across a multi-step chain, and the final output may diverge significantly from what was intended, with intermediate steps that are hard to trace. Representative products include Devin, Claude Code, OpenAI Codex (in agent mode), and various LLM-based ReAct/tool-calling frameworks.

---

What This Means for Developers

Simon's observation throws a bucket of cold water on the prevailing hype. While marketing narratives paint AI programming as enabling "anyone to build software," feedback from practitioners points in the opposite direction: the more powerful the tool, the higher the demands on the person using it.

This isn't a new pattern. Every major productivity leap in history has come with a redefinition of what it means to be a capable practitioner. Compilers, IDEs, and high-level frameworks all made "getting started" easier — but the bar for producing excellent software never truly dropped. It simply shifted to a new level.

For individual developers, this means coding agents shouldn't be treated as an excuse to cut corners, but as professional tools that require serious mastery. For teams and organizations, it means resisting the illusion that "now that we have AI, we can hire fewer senior engineers" — if anything, it's precisely senior engineers who can unlock the full potential of these tools.

---

This phenomenon — where the capability demands on users rise in lockstep with tool capability — has a corresponding concept in software engineering history: the "abstraction tax." Whenever a powerful abstraction layer appears (high-level languages, ORMs, managed cloud platforms), it does shield users from a great deal of low-level complexity. But the moment a problem crosses abstraction boundaries, users lacking foundational knowledge are often left helpless. AI coding agents push this phenomenon to a new extreme: the abstraction layer now covers the "thinking process" itself, making the mental models required for debugging and problem diagnosis harder to build than with any previous tool. This is precisely why senior engineers' value hasn't been diluted — it has become more pronounced as AI tools proliferate. They're the ones who can make accurate judgments at the boundaries where abstraction breaks down.

---

A Thread Worth Continuing

Simon's brief note precisely identifies a blind spot in the AI programming boom. It reminds us that a tool's capability ceiling and the capability required to operate that tool tend to rise together. Coding agents can indeed do amazing things — but the prerequisite for that "amazing" is a user who brings matching discipline and knowledge to the table.

While embracing AI programming tools, continuously sharpening your own engineering judgment may be the most important competitive moat a developer can build in this era.