Waterfall taught us to marathon.
Agile taught us to sprint.
AI is teaching us to bolt.
For more than two decades, Agile has been the dominant model for software delivery because it matched the pace of human teams. Sprint planning, backlog refinement, estimation, daily stand-ups and retrospectives weren’t arbitrary ceremonies they evolved because people need time to understand problems, coordinate with one another and turn ideas into working software.
Artificial intelligence changes that rhythm.
As AI compresses delivery cycles, the sprint naturally collapses into a bolt the high-velocity execution cycle described by AWS AI-DLC, where planning, implementation, testing and review become a single continuous flow.
A bolt isn’t simply a shorter sprint.
It’s a fundamentally different cadence.
Instead of developers manually decomposing work into user stories before writing code, AI systems can analyse requirements, propose implementation plans, generate code, write tests and prepare infrastructure changes within minutes. Humans increasingly define intent, approve key decisions and validate outcomes rather than performing every implementation step themselves. That shift is central to the emerging AI-Driven Development Lifecycle (AI-DLC), where AI orchestrates much of the delivery process while humans retain responsibility for oversight and critical decisions. (Amazon Web Services, Inc.)
The question is no longer:
“How do we build software faster?”
The question is:
“How do we govern software that now moves faster than our delivery process?”
Agile Was Built Around Human Throughput
Agile emerged as a response to heavyweight, sequential development models.
Instead of spending months defining requirements before writing code, Agile encouraged short feedback loops, frequent releases and continuous collaboration.
Its ceremonies all serve one purpose:
Synchronising humans.
Sprint Planning aligns the team.
Backlog Refinement clarifies future work.
Daily Stand-ups coordinate progress.
Sprint Reviews gather stakeholder feedback.
Retrospectives improve team performance.
These activities aren’t about writing software.
They’re about reducing the communication overhead that naturally exists whenever groups of people collaborate.
For twenty years, that assumption held true.
People were the limiting factor.
AI-DLC Changes the Bottleneck
AI coding assistants initially appeared to accelerate only one activity: writing code.
That was the era of AI pair programming.
The latest generation of AI-DLC goes much further.
AWS describes AI-DLC as an AI-centric methodology where AI doesn’t simply generate code it proposes plans, asks clarifying questions, creates designs, produces tests and orchestrates work across the development lifecycle, while humans review and approve key decisions. (Amazon Web Services, Inc.)
That distinction matters.
The expensive part of software development has never been typing code.
It’s deciding what should be built, why it should exist and whether it satisfies business intent.
AI-DLC begins to automate much of the mechanical work between those decisions.
Execution accelerates dramatically.
Decision-making does not.
Introducing the Bolt
When execution becomes abundant, the sprint stops being the natural unit of delivery.
Instead, delivery begins to resemble a bolt.
Bolt (noun): A high-velocity, AI-orchestrated execution cycle that compresses planning, implementation, testing and review into a single objective-driven flow.
Unlike a sprint, a bolt isn’t defined by calendar time.
It’s defined by outcome.
A bolt might produce:
- a completed feature
- a security enhancement
- a database migration
- a refactoring initiative
- an infrastructure change
Some bolts may take thirty minutes.
Others may take half a day.
The defining characteristic isn’t speed.
It’s continuity.
There is little distinction between planning and execution because AI continuously transitions between them.
The Temporal Collapse of the Sprint
Once you begin working in bolts, several Agile ceremonies naturally evolve.
Sprint Planning becomes continuous objective definition.
Backlog Refinement becomes AI-assisted prioritisation.
Story point estimation becomes less meaningful because implementation effort is no longer tightly coupled to human effort.
Daily Stand-ups shift from coordinating developers to reviewing AI progress, resolving blockers and making higher-level decisions.
Retrospectives become evaluations of the delivery system itself rather than discussions about individual productivity.
Notice what’s happening.
Agile isn’t disappearing.
Its ceremonies are becoming compressed because the assumptions that created them have changed.
Governance Becomes the Constraint
Every major software methodology solved the bottleneck of its era. Waterfall solved coordination. Agile solved adaptability. AI-DLC solves execution. That leaves governance as the next bottleneck.
Much of the discussion surrounding AI software development focuses on productivity.
Productivity isn’t the interesting problem.
Governance is.
Enterprise software has always required more than developers.
Security teams.
Enterprise architects.
Compliance officers.
Risk managers.
Project Management Offices.
All exist because software isn’t merely a technical asset.
It’s a business asset that operates within legal, regulatory and organisational boundaries.
Those governance processes evolved around delivery cycles measured in weeks.
Bolts compress delivery into hours.
The governance model doesn’t automatically compress with them.
That’s where friction begins.
Why PMOs Won’t Resist AI. They’ll Resist Losing Control
It’s easy to portray PMOs as resistant to change.
I think that’s unfair.
Their role has never been to slow development.
Their role is to make organisational decisions visible, auditable and repeatable.
AI challenges that model because hundreds of implementation decisions can now occur between traditional governance checkpoints.
The concern isn’t whether AI writes good code.
The concern is whether:
- architectural standards were followed,
- compliance requirements were satisfied,
- traceability exists,
- risk was properly accepted,
- and approvals remain auditable.
Those obligations don’t disappear simply because software is produced faster.
If anything, acceleration increases their importance.
Governance Must Move into the Workflow
This is where I think AI-DLC becomes most interesting.
The answer isn’t adding more meetings.
It’s embedding governance directly into the development workflow.
Modern AI-DLC already emphasizes structured phases, persistent documentation and explicit human approval gates before progressing between stages. (AWS Builder Center)
The next logical step is to make governance executable.
Imagine every AI-generated change automatically evaluated against policies such as:
- secure coding standards,
- architectural principles,
- regulatory controls,
- testing requirements,
- documentation completeness,
- deployment constraints.
Instead of waiting for a committee to review software after it’s has been built, software continuously proves that it satisfies organisational policy before it progresses.
Governance becomes code.
Git Becomes the Natural Decision Engine
Every meaningful software change already flows through version control.
Requirements become branches.
Changes become commits.
Features become pull requests.
Deployments originate from Git.
That makes Git a logical place to enforce organisational policy.
Rather than relying on calendar-based approval meetings, organisations can embed governance into the development workflow itself.
A pull request doesn’t simply ask:
“Does this code compile?”
It also asks:
- Has every required architectural decision been recorded?
- Has the AI followed approved implementation patterns?
- Has every compliance control passed?
- Is there complete traceability from requirement to implementation?
- Has the appropriate human approved the change?
The approval becomes part of the workflow, not a meeting scheduled next Tuesday.
Humans Become Decision Architects
One misconception about AI-DLC is that it removes humans from software engineering.
I think the opposite is true.
Humans become more valuable because they spend less time implementing and more time deciding.
Developers increasingly define intent.
Architects define constraints.
Security teams define policy.
Product owners define outcomes.
AI executes.
Humans govern.
That division of responsibility is far more scalable than asking people to manually inspect every line of generated code.
Beyond Agile
Agile was one of the most important advances in software engineering because it recognised that software development is fundamentally iterative.
AI-DLC recognises something different.
Execution is no longer scarce.
Human judgement is.
As AI continues to compress delivery cycles, organisations will need a new cadence that reflects this reality.
Not the marathon of Waterfall.
Not even the sprint of Agile.
But the bolt.
A rapid, objective-driven burst where AI handles execution and humans provide intent, governance and accountability.
The organisations that succeed won’t simply adopt better AI tools.
They’ll redesign their delivery models around the new economics of software development.
Waterfall optimized for predictability.
Agile optimized for adaptability.
AI-DLC optimizes for execution.
The organisations that succeed won’t be those that generate code the fastest. They’ll be the ones that make trustworthy decisions at AI speed.
