In the past, I wrote about AI making developers worse and AI not being economical. This time, I would like to prove typical AI coding justifications wrong.
1.) AI kills the coding bottleneck
Let’s assume that writing code is roughly about 10 to 20% of the actual job of a software engineer. Maybe it’s me, but adding AI to this layer feels like micro-optimization and not like killing a bottleneck. What’s truly time-consuming is thinking about architecture and implementation. The two actual bottlenecks not solved by AI coding agents are bureaucracy (humans) and facing a new problem for the first time along with the time necessary to learn. The latter is actually the fun part that makes good engineers and is where AI can support organizing thoughts.
2.) AI lets us focus on the architecture
Software never goes as planned. Thus, implementing the plan is often part of the architecture design process that shows design issues and helps to fix them before delivery. Writing an instruction is not the same as designing an architecture and proving it while typing. What you actually do is outsource the design decision to the AI by describing it in an ambiguous way. That’s not engineering.
3.) AI lets us focus on the fun part
I agree that architecture and solving problems (engineering) are the fun parts. But I already explained that writing code is part of the engineering process and that describing something is not the same as writing clear deterministic instructions. When AI writes all the code, you must review it. This shifts the focus of your work from engineering to reviewing. But wasn’t AI about focusing on the fun part? I don’t think that reviewing AI code is fun.
4.) AI makes us more productive
There is a limit to the code and information our brain can process. AI produces more LOC. That’s true. But this also means that we must review more code and thus we hit our limits. In reality, it’s not possible to review that amount of code, so we won’t do it carefully. We get faster results, but our products are worse. Until we reach something stable, we might be more productive by hand with proper tools (including AI).
5.) AI solves the boilerplate problem
CLI tools, IDE autocomplete, and copy and paste solve it. And they do it more reliably, faster, and cheaper. As if software development was ever about struggling with boilerplate all the time.
6.) AI makes juniors better
IMHO, the main requirement for using AI is being better than the AI agent. Over time, AI code becomes a glued mess of code snippets that no one understands if not steered based on understanding. Letting someone use a tool to create results that he or she can’t understand is just dangerous and kills the foundation for developing necessary skills. Learning something means reaching limits and overcoming them, not relying on others (AI).
7.) AI is just another evolutionary step
People talk about punching cards and no longer writing assembly. While this made software development more accessible, it didn’t change its nature. We write deterministic instructions and get the same result. Computers, higher programming languages, IDEs, and autocomplete made us more efficient by building upon trusted and deterministic layers. But AI doesn’t fit into this evolution. AI takes over the thinking part and generates non-deterministic results. It’s probably the most unreliable compiler we have ever created. Just calling it one makes me sick. But that’s what it is. It translates natural language to code.

Smiley Face

Erik

A critical examination of seven common justifications for AI coding tools, arguing that each fails under scrutiny. Key points: coding is only 10-20% of engineering work so AI offers micro-optimization, not bottleneck elimination; outsourcing code to AI shifts work from engineering to reviewing (which isn't fun); AI produces more LOC but humans can't review it all carefully, leading to worse products; boilerplate was never the real problem; AI harms junior developers by preventing skill development; and unlike previous tooling evolutions, AI introduces non-determinism into what has always been a deterministic discipline.

Prompting Isn't Engineering: Why AI Justifications Fail