AI Will Not Remove Overengineering. It Will Accelerate It

Overengineering is when you solve a simple problem in a complicated way: a landing page on microservices, Kubernetes for ten users, an architecture built for a million requests while the traffic is modest. You pay with money and time for a solution far more complex than the problem itself.

That is how the incentives are arranged. A complex solution reads as professional, a simple one as unfinished. Nobody was ever fired for choosing Kubernetes. People were fired for not thinking about scaling. With that asymmetry, playing it safe is rational, and developers play it safe.

AI learned from open source code and articles, and what dominates there are the solutions of large companies: they write the blogs, publish the frameworks, set the fashion. Their problems are different ones: millions of users, hundreds of developers, regulatory requirements.

Asked to "write authentication", the model produces what it has seen most often: a layered structure with abstractions, interfaces, and handling for scenarios you will never have. It is a correct answer to the average request from the internet. Your project is not that average.

Complexity used to be paid for in time. Writing five layers of abstraction was a week of work. Somewhere around day three a person would start doubting whether they were really needed. The price worked as a brake.

Now those same five layers are generated in a minute. The code reads well, the tests pass, the feature works. On the surface everything is fine. But the main cost of complexity falls on maintenance, not on writing. In six months something in that code will need to change, and the bill arrives then. This is technical debt taken on instantly and without a conscious decision.

The only natural brake on overengineering is gone. It is not about the quality of the generation: the code can be excellent. It is that the code became too cheap.

Use AI as an editor

The common scenario looks different: a developer asks for a module to be generated from scratch, gets 500 lines, and drops them into the project. Nobody is going to work out which parts are unnecessary. The code works. That is how overengineering enters a project in a single generation.

The reverse order gives a different result:

1. Write it yourself first. Thirty lines, a simple JWT, one verification function. In exchange, you understand every line.
2. Then hand it to AI for simplification. "Here is the code. Remove everything it can keep working without. Show me what can be thrown away."
3. Go through the suggestions. Some will miss, but the model works better in this mode: it spots what is redundant more accurately than it invents what is needed.

When editing, there is a reference point, your code and your understanding of the task. When generating, there is no reference point, so the model substitutes the average one.

Two more techniques:

• Constraints in the prompt. If you are generating from scratch, set the frame explicitly: "The simplest solution that works. No frameworks, no layers of abstraction. SQLite, one file."
• Project context. The phrase "I have 100 users and a ten dollar server" changes the answer more than any refinement of wording.

The companies that adopted AI agents most deeply built an entire layer of constraints around generation.

Stripe, according to public descriptions, runs more than a thousand pull requests a week through AI. Tasks for agents are framed narrowly: not "build a feature" but a strictly bounded change. The tools available to an agent are selected by hand. Every result goes through review. The company deliberately sacrificed the scale of the task for the predictability of the outcome.

At Google, Shopify, and Airbnb the architectures differ, there is no single industry standard, and each builds for its own risks. What they share is that agents are embedded into existing processes (GitHub, Slack, Linear) and surrounded by checks.

None of them takes the output of a generation as is. The value comes from the frame around the generation.

AI amplifies what is already in the developer's head. It will act out a tendency to overcomplicate in seconds, and a habit of cutting the excess just as fast.

The decision that this code is too complex for this task is still made by a person. AI only carries it out faster.