Most software work starts the same way:
- get a happy-path flow working
- surface rabbit holes early
- produce a first draft
Then we all say the same thing: “We’ll refactor it later.”
Sometimes that happens. A lot of the time business pressure wins, and the first draft becomes production.
That’s not laziness. It’s reality.
The part that rarely happens (but creates quality)
In my experience, quality usually comes from the second draft:
- once you understand the real shape of the problem
- once you’ve hit the awkward edge cases
- once you’ve learned which “nice abstractions” are actually dead ends
You rebuild it with clearer boundaries, fewer leftovers, and less accidental complexity.
But in normal delivery mode, second drafts are a luxury.
What AI changes:
AI doesn’t just make the first draft faster.
It makes the second and third drafts cheap enough to actually do, either before shipping, or immediately after while the context is still fresh.
That sounds small, but it’s a big shift.
Because it turns “we’ll tidy it up later” from a promise into a step in the workflow.
The workflow I’m aiming for
- Spike the happy path (fast)
- Learn the rabbit holes
- Rebuild cleanly with the same behaviour
The rebuild is where you delete the junk:
- leftover methods
- half-removed approaches
- abstractions you only added because you were still learning the domain
This is basically: spike → learn → rebuild.
The difference is: now the rebuild is affordable.
Tests are the safety net (so you don’t need manual UAT every time)
None of this is safe without verification.
If you have decent test coverage, the tests become the contract. You can rebuild/refactor with confidence because you can prove:
- you didn’t break the happy path
- you didn’t regress edge cases
- you didn’t accidentally change behaviour while “cleaning up”
AI helps you iterate inside that safety net. But the safety net is still the point.
What this changes culturally
AI makes it easier to ship more.
But the real leverage is it makes it easier to ship cleaner — because second drafts stop being a fantasy.
That’s how you avoid the trap of “AI increased velocity but also increased mess.”
A simple prompt that forces the second draft
Once something works, I’ll often ask:
“Given what you know now, if you started this again from scratch, how would you build it?”
Then I implement that version (and keep the tests green).
It’s a reliable way to turn a messy first pass into a clean implementation without rewriting the world.
But the real leverage is it makes it easier to ship cleaner — because second drafts stop being a fantasy.
That’s how you avoid the trap of “AI increased velocity but also increased mess.”
A simple prompt that forces the second draft
Once something works, I’ll often ask:
“Given what you know now, if you started this again from scratch, how would you build it?”
Then I implement that version (and keep the tests green).
It’s a reliable way to turn a messy first pass into a clean implementation without rewriting the world.