battlingcomplexity

Clif's notes on engineering, architecture, leadership

AI Will Write the Code. Who Will Battle the Complexity?

AI has made producing code almost free. Understanding code costs just as much as it always did, and that gap is where the next wave of complexity is coming from.

By Clif Render 4 min read

I’ll start by saying I’m not an AI skeptic. AI coding tools are remarkable, and teams that use them well are getting real, measurable gains. If you’re a technology leader and you’re not exploring them, you should be.

But I’ve been in this industry long enough to recognize a pattern. When something that used to be expensive suddenly becomes cheap, we make a lot more of it. That’s usually good. It isn’t always.

AI has made writing code dramatically cheaper. It has not made understanding code any cheaper. It hasn’t made operating, securing, debugging, or changing code any cheaper either. Those costs are where complexity lives, and they scale with how much code you have, not with how fast you produced it.

How AI adds complexity

None of these are hypothetical. If you’re using AI tools at any scale, you’ve probably seen most of them:

  1. More code than anyone needs. Ask an AI to solve a problem and it will often give you a complete, well-commented, thoroughly handled solution that’s three times the size of what a thoughtful engineer would have written. Every line works. A lot of the lines shouldn’t be there.
  2. Duplicates instead of reuse. Generating a new helper function is faster than finding the existing one. Over time you end up with five slightly different versions of the same logic, and nobody knows which one is the real one.
  3. Dependencies by default. Need to parse a date? Here’s a new library. The model doesn’t know or care about your approved technology list or your complexity budget.
  4. Code nobody fully understands. When a developer writes code, at least one person understands it. When a developer accepts generated code they only skimmed, possibly nobody does. That’s a new kind of technical debt, and it doesn’t show up on any report.
  5. Prototypes become production faster. The “quick proof of concept” used to take two weeks, which gave someone time to ask whether it should exist. Now it takes an afternoon, and it’s in production by Friday.

What still matters (more than ever)

The good news is that the principles that kept systems simple before AI still work. They just matter more now.

  • Design before you generate. The AI is a great implementer and a poor architect. Decide on the boundaries, the interfaces, and the data ownership first. Then let the tools fill in the details. If you let the AI design by accident, you’ll get its default architecture, which is usually more of everything.
  • Review for complexity, not just correctness. The question in code review used to be, “Does this work?” Now it also has to be, “Does this need to exist?” and “Is there a smaller way?” Deleting generated code is one of the most valuable things a reviewer can do.
  • Standards are guardrails, not paperwork. Approved libraries, reference architectures, and paved paths matter more when code is cheap, because they’re how you keep a thousand fast decisions consistent. Write them down where the tools, and the people using them, can find them.
  • Lightweight documentation, especially decisions. Architecture Decision Records are the perfect counterweight to AI-generated code. The code tells you what. Only a human can record why.
  • Measure the right thing. Lines of code and pull requests merged were always bad metrics. With AI they’re actively misleading. Measure delivery outcomes, change failure rates, and time-to-understand, the kinds of measures the DORA research has long pointed to.

A word on agents

The same goes for AI systems themselves. It’s tempting to build a fleet of autonomous agents with elaborate orchestration because the demos are impressive. Even the people building the models suggest otherwise. Anthropic’s guidance on building effective agents comes down to this: start with the simplest thing that works, and add complexity only when it clearly improves the result. That’s good advice for any technology. It’s nice to see it given about the newest one.

The job hasn’t changed

People keep asking me whether AI will make architects and senior engineers obsolete. I think it does the opposite. When anyone can generate code, the scarce skill is knowing what not to build, where the boundaries should go, and how to keep a system understandable as it grows.

That was always the job. AI just made it harder to ignore.