(Why building is easy and deciding is hard)

We Solved Automation

For decades, the goal was clear: automate everything.

Auto-scaling. CI/CD. Infrastructure as code. Auto-testing. Every manual step was a problem to eliminate. The question was always:

“What can we automate next?”

With AI, we’ve largely succeeded.

Code, tests, documentation, infrastructure, schemas, API designs — all generated in seconds. For many teams, building is no longer the constraint.

And that’s the problem. We automated building, but not deciding.

The Real Cost Didn’t Disappear

When building was expensive, teams were selective by default.

Every feature needed time, review, testing, and coordination. Friction filtered ideas. Only what mattered survived.

Now friction is gone.

AI will generate whatever you ask for: more features, more services, more documentation.

The cost of building has dropped dramatically. The cost of maintaining has not.

Every feature still needs review, testing, security, ongoing maintenance, and users who can understand it.

We removed the cost of creation, not the cost of ownership.

When Everything Works, the Experience Fails

This isn’t a new problem.

Open Netflix and scroll. Keep scrolling. Twenty minutes later, you’ve forgotten why you opened it.

Netflix has exceptional content, world-class recommendation algorithms, and enormous investment. Everything works, and yet the experience doesn’t.

With AI, it’s almost impossible not to create apps and services that do more than they need to, and look impressive while still failing users.

Progress isn’t adding more retries to broken pipelines or writing documentation nobody reads. It’s fixing underlying problems and resisting the urge to add more on top.

From Automation to Deliberate Simplicity

The discipline has changed.

We used to optimise for capability. “What can we automate? What are we missing? How fast can we build this? What can we add next?”

Now the harder questions are: “What should not exist? What can we remove without harm? What adds complexity without improving outcomes? How could this be simpler?”

Before, progress meant more capability. Now, progress often means more simplicity.

KISS and YAGNI were always good advice. Now they’re essential, and possibly not enough.

AI won’t tell you something is unnecessary. It will build whatever you ask, instantly and convincingly. Without resistance, everything trends towards more.

Deliberate simplicity is the counterbalance.

Just because we can build something doesn’t mean it belongs in production.

Simplicity Is About Cognitive Load

This isn’t about writing less code.

It’s about reducing the burden on users and maintainers: fewer things to learn, fewer decisions to make, fewer ways to get it wrong.

That often means writing more code — better error messages, cleaner APIs, stronger defaults, smarter curation — so people have to think less, not more.

The metric isn’t lines of code. It’s cognitive load.

AI can help here too: curating instead of listing, choosing instead of asking, hiding complexity instead of exposing it. But only if that’s the goal.

What This Means in Practice

For developers, the question isn’t how to build. The AI already knows that.

It’s whether something should exist at all, and whether it can replace something instead of adding another moving part.

For teams, the review question isn’t just “Does this work?”

It’s whether anyone would miss it if it disappeared, and what complexity the next team/person/user will inherit.

For organisations, velocity is not value. Shipping faster can simply mean accumulating maintenance debt faster. Progress is solving problems with the simplest solution that actually holds.

A Closing Thought

AI has removed many technical limits. That doesn’t mean we should remove all restraint.

The next wave of engineering excellence won’t come from building faster, but from deciding better.

Keeping things simple is no longer enough. We need to design systems that stay simple to use, operate, and maintain.

If you’re thinking about the same tension — speed versus simplicity, capability versus clarity — I’d love to hear how you’re navigating it.