Sustainable Pace Just Got Faster
For years, the debate in product teams was about sustainable pace versus moving fast. Could you ship quickly without burning people out? Was "move fast and break things" reckless, or just honest about what winning requires?
That debate is over. Speed won. The question now isn't whether to go fast, it's how you sustain a pace that would have seemed unreasonable twelve months ago.
The OODA loop: why faster iteration always wins
In the 1970s, a military strategist called John Boyd developed a concept he called the OODA loop: Observe, Orient, Decide, Act. His argument was simple: in any competitive environment, the entity that can cycle through this loop faster will beat the one that cycles slower. It doesn't matter if your strategy is slightly better. If I can iterate three times while you iterate once, I'll learn faster, adapt quicker, and outmanoeuvre you.
Boyd was talking about fighter pilots and military doctrine. Then startups adopted it. Jeff Atwood summarised it well on Coding Horror:
Speed of iteration beats quality of iteration.
Now it applies to everyone building products.
AI has compressed iteration cycles so dramatically that companies who were moving "fast enough" last year are now slow.
The time it takes to go from idea to prototype to learning has collapsed. Teams using AI effectively can test hypotheses in hours that used to take sprint cycles. That changes the competitive math completely.
How AI has raised the sustainable pace baseline for product teams
Sustainable pace used to mean finding a rhythm your team could maintain indefinitely without burning out. That definition still holds. What's changed is the number.
Think of it like running. If everyone else in the race just got faster, your comfortable pace isn't sustainable anymore. It's just slow. You'll finish, but you won't be competitive.
For most product teams, the sustainable baseline just went up. Not because anyone wants to work harder, but because the tools now exist to move faster without proportionally increasing effort. Companies that figured this out are already pulling ahead. Companies clinging to 2025 velocity are wondering why they feel behind.
The verification trap: why AI tools are making some teams do everything twice
So if AI makes things faster, why is everyone exhausted?
Because most teams aren't actually moving faster. They're doing double the work.
Here's what I see happening. A team adopts AI tools. They use them to generate code, write documentation, draft designs. But they don't trust the outputs, so they verify everything manually. They review every line of AI-generated code the way they'd review a junior developer's first commit. They rewrite AI-drafted documents from scratch. They check, double-check, and sense-check.
They haven't replaced their old process. They've added a new one on top of it.
This is the verification trap.
People treat AI outputs with a level of suspicion they'd never apply to work from a colleague. When someone on your team submits a pull request, you review it, but you don't rewrite it from scratch just to make sure. When a teammate drafts a document, you edit it, you don't secretly write your own version to compare.
But with AI, people do exactly this. They use the tool, then do the work again anyway.
That's not sustainable pace at a higher baseline. That's two jobs.
What sustainable AI velocity actually looks like
The teams getting this right share one thing in common: they stop things.
They don't just add AI to their workflow. They remove the manual version. They trust AI outputs the way they'd trust a competent colleague, which means reviewing and improving, not duplicating. They delete process steps that existed because humans were slow, not because the steps added value.
Going faster with AI isn't about working harder or longer. It's about substitution, not addition.
You do the work with AI, or you do it manually. Not both.
If you're using AI tools and you're more tired than before, check whether you're actually moving faster or just doing everything twice. The pace isn't the problem. The duplication is.
Related