Everyone has a plan until they get punched in the mouth

The biggest problem in software has always been the feedback loop between having an idea and validating whether it actually works.

For a long time, the response was to plan more. Big Design Up Front: map everything out, reduce uncertainty, and only then start building. It didn't work then, and it doesn't really work now. Not because planning is useless, but because planning alone can't eliminate uncertainty.

Mike Tyson put it better than most engineering methodologies ever have:

Everyone has a plan until they get punched in the mouth.

In software, the goal isn't to avoid the punch. It's to recover quickly and adjust.

That works because software is cheap to change. Unlike hardware or infrastructure, we can be wrong and still recover.

For years, we've tried to shorten that learning loop with Agile, CI/CD, and feature flags. Then coding agents arrived and changed the economics again. Implementation has become cheap. And when implementation becomes cheap, the bottleneck moves.

Understanding the problem

When I start working on something, my strategy hasn't changed much. I still start by building a high-level understanding of the problem: constraints, risks, and how it fits into the existing system.

What has changed is speed. Tools like Claude can read, summarise, and cross-check context far faster than I can, and I use them to surface forgotten constraints and validate assumptions early. The result is still the same mental model, just reached faster.

Exploring solutions

This is where the tension shows up. We now have tools that can produce working implementations in minutes, yet we frequently use them to write increasingly detailed specifications instead. Claude Code is optimised to write code, not to act as a requirements system. And solution design, at its core, is still exploratory.

Agents are excellent at producing first drafts and iterating quickly. But humans still decide what "right" looks like, what trade-offs matter, and when something is going off track. You can fully specify everything up front if you want, but you'll still get punched in the mouth.

The value isn't in eliminating uncertainty, it's in shortening the loop between trying something and learning from it.

Humans explore. Agents execute.

The bottleneck has moved

For a long time, implementation was expensive, so we invested heavily in planning. We wrote detailed specs, debated architecture, and ran structured demos because mistakes were costly. It was often cheaper to spend an hour in a meeting with ten people than to build the wrong thing for another week.

Now implementation can happen in hours, but validation hasn't become cheaper. Understanding whether we're building the right thing is still the hard part.

It's now cheaper to prototype multiple approaches than to debate the "right" one in advance, not because thinking is obsolete, but because experimentation is faster than argument. So where do we go from here?

Stop planning, start owning. Coding agents are the lever. Or, if you prefer the Spider-Man version, with great power, comes great responsibility.

We don't need more permission slips. We need enough context to make good decisions independently: the user, the constraints, and what success actually looks like.

When implementation is cheap and validation is still expensive, autonomy becomes the only way to preserve speed without drowning in process and dependencies.

Getting punched in the mouth

Software has never been about avoiding mistakes. It's about not making any fatal mistakes, and about recovering quickly from small ones.

Now we can make these small mistakes faster and cheaper than ever, while the increased rigidity of the tooling we use gives us the guardrails to more easily prevent the big ones. More than ever, the job becomes iteration rather than prediction. We build, we learn, we adjust.

Because nobody learns to dodge punches from a perfect plan.