Sprinting downhill in ASDLC
why shortcut speed becomes deferred failure
It took me about 10 seconds to understand what losing control feels like. I was young, running full speed down a steep hill, and crossed the point where I could no longer slow down, steer, or stop. For a moment, speed felt like skill. Then physics took over.
That is what shortcut thinking feels like in agentic engineering.
In ASDLC work, moving quickly is not the problem. The problem is assuming that because agents can move quickly, we can skip the controls that make that speed safe. I have made this mistake myself more than once in the last few months. Every time I skipped a step to “go faster,” I paid for it with wasted tokens, extra debugging time, and cleanup work that cost more than doing it right the first time.
Speed is not control
The downhill analogy works because it exposes a common confusion: teams treat velocity and control as the same thing. They are not.
When you move from chat assistance to action-capable agents, the risk profile changes. You are not just asking for text anymore; you are granting initiative. That creates momentum, and momentum multiplies mistakes.
A practical mapping:
Capability is gravity: stronger models and richer tools increase pull.
Autonomy is momentum: the more steps an agent can take without intervention, the faster consequences stack.
Guardrails are brakes and steering: permission boundaries, sandboxing, monitoring, rollback paths, and clear tool contracts.
Unknown environments are rough terrain: external APIs, weak docs, flaky dependencies, and side effects you did not model.
Once an under-constrained agent acts in unfamiliar terrain, you are not iterating rapidly. You are accelerating blind.
The warning has been clear
Anthropic’s Building Effective Agents says this directly:
“The autonomous nature of agents means higher costs, and the potential for compounding errors. We recommend extensive testing in sandboxed environments, along with appropriate guardrails.”
That is not just cautious language. It is an operational fact. Autonomous systems fail multiplicatively, not linearly.
They also note:
“Agents can handle sophisticated tasks, but their implementation is often straightforward. It is therefore crucial to design toolsets and their documentation clearly and thoughtfully.”
This is where teams get caught. The early warning signs are usually boring: vague tool descriptions, loose schemas, weak failure handling, unclear permissions. None of that feels dramatic. In an autonomous loop, though, small defects become expensive quickly.
Their sequencing advice is equally clear: start simple, then add complexity only when need is proven. Not when hype is loud. Not when demos look exciting.
What shortcut thinking costs in practice
The bill usually arrives in four currencies: tokens, time, trust, and recovery work.
1) Tokens
A runaway loop can burn serious money fast. One bad run can chew through a few hundred dollars before anyone notices. By the time spend alarms fire, the damage is already done.
This also pushes teams into bad behavior: either they overreact and freeze useful experimentation, or they normalise waste as “the cost of innovation.” Both are signs of poor control.
2) Time
Shortcut setups look efficient at first. Then the hidden cost appears. You skip 20 minutes of careful setup and lose three hours debugging interactions across prompts, tools, retries, and environment drift.
That is not acceleration. It is debt with interest.
3) Trust
Trust is the hardest thing to win back. One high-impact mistake, deleting data, pushing broken changes, making irreversible edits, and the organization swings hard to manual gates everywhere.
Once people lose confidence, no polished demo restores it. Predictable behavior does.
4) Recovery resources
After a failure, teams pay again through incident reviews, human verification, compensating scripts, policy updates, and additional approvals. Recovery is not one fix. It is a long tax on velocity.
Why some teams burn out and others do not
Gergely Orosz called tokenmaxxing “the shortest-lived trend because it’s so wasteful.” That tracks with what many teams are seeing now: rising AI costs, regular usage-limit hits, and big variation across teams doing similar work.
That variation is the point. It is not mostly a talent gap. It is a controls gap.
Kent Beck and Martin Fowler have also framed this as a familiar cycle: overcorrect, break things, then settle. We are in that middle phase for many agentic teams. The people sprinting hardest downhill are often the first to hit burnout, because energy goes into firefighting instead of compounding progress.
Fast teams that do not crash
DHH’s move toward an agent-first workflow is a useful counterexample. The takeaway is not “go all in” or “do not adopt.” The takeaway is that high adoption only works when boundaries are explicit.
The teams that move fast without wreckage usually have:
Clear scope for where agents can act and where they cannot.
Sandboxed rehearsal before live execution.
Tight tool contracts and documentation.
Observability for decisions and actions, not only final outputs.
Human checkpoints at high-impact boundaries.
Rollback paths designed before launch.
This is not bureaucracy. It is performance engineering. Race cars are fast because brakes and telemetry are first-class systems.
One operating principle to keep
In ASDLC, missing steps is not acceleration. It is deferred failure.
Deferred failure feels good at first because it creates a quick win: a demo, a commit, a temporary spike in output. But the system keeps the receipt, and payment usually comes at the worst time.
If you want sustainable speed:
Start with the simplest viable pattern.
Prove reliability in a sandbox.
Add autonomy only when current constraints are the actual bottleneck.
Instrument cost, error, and intervention rates from day one.
Treat guardrails as product features, not temporary scaffolding.
The hill is getting steeper as capability improves. The winning teams will not be the ones that sprint fastest at the top. They will be the ones that can still steer halfway down.
Related Articles: