Continuous Delivery & Extreme Programming
The Discipline That Makes AI Deliver.
Every team has the same AI tools. The ones pulling ahead have better engineering practices. These six are how we have worked since 2012, on every AI engineering and product development engagement.
The Chasm
Same AI Tools. Completely Different Results.
Some teams ship value at a pace that makes others look frozen. Others adopted the same tools and saw bug rates climb, tech debt compound, and their best developers leave. The difference isn't the AI. It's what was already in place before AI arrived.
Strong practices + AI = compounding returns
Tests catch mistakes in seconds. Architecture tells AI where things belong. Small batches limit blast radius.
Weak practices + AI = compounding debt
Bad patterns replicate at machine speed. The pipeline stays green because the tests never caught real bugs.
Most teams plateau at autocomplete
Six stages of agentic development. Most stop at stage 2. The ones pulling ahead build specs first and let agents execute against structured contracts.
Tests before code. Every time.
Write the test first, then just enough code to pass it. AI-generated code either passes or fails in seconds — not three weeks later in production.
- Safety net by default — every feature ships with the tests that prove it works
- Design pressure — hard-to-test code is hard-to-change code; TDD catches design problems early
- Refactoring confidence — comprehensive tests mean you can restructure without fear
Before
- Pipeline goes green because tests are weak
- Bugs silently ship to production
- Nobody dares refactor without fear
With TDD
- AI mistakes caught in seconds, not weeks
- Test suite grows with every feature
- Refactoring stays safe at every step
Architecture with clear boundaries.
Business logic separated from infrastructure. Dependencies pointing inward. When AI generates code on a well-structured codebase, it knows where things belong.
- AI follows existing patterns — clear structure means new features land in the right modules
- Change one thing, break nothing else — boundaries contain the blast radius of every change
- Testable by design — business logic runs without frameworks, databases, or network calls
Before
- AI deepens the tangle with every change
- Each modification makes the next one harder
- No separation between logic and infrastructure
With boundaries
- AI generates code that fits the structure
- Dependencies stay clean and navigable
- Business logic runs without frameworks
Small changes, shipped continuously.
One scenario. One agent session. One commit. The biggest variable in agentic development is not model selection or prompt quality — it’s decomposition discipline.
- Stop optimising prompts, start optimising decomposition — small, well-scoped work beats clever prompting every time
- One scenario = one session = one commit — the same discipline CI demands of humans, applied to agents
- Deployment becomes routine — not a ceremony, not a war room; just a normal part of the day
Before
- Risk compounds in large batches
- When something breaks, nobody can trace the cause
- Releases feel like war rooms
With small batches
- Each change is low-risk and easy to verify
- Problems trace to their source immediately
- Deployment becomes a routine, not a ceremony
Specifications define “done” before code is written.
Four artifacts form a delivery contract: intent (the why), behaviour (BDD scenarios), constraints (architectural boundaries), and acceptance criteria (the done definition). If your spec takes more than 15 minutes, the change is too large.
- Not big upfront design — one thin vertical slice at a time; specify the next unit of work, not the entire system
- Authority hierarchy — intent > architecture > tests > implementation; agents cannot redefine their authority
- Every change is traceable — all four artifacts ship with the code; incidents trace to the exact intent and constraints in effect
Before
- Teams ask AI open-ended questions
- Hours spent reviewing with no clear criteria
- Correctness is opinion, not proof
With specs
- AI is the implementer, specs are the contract
- Review becomes verification, not discovery
- Correctness is proof, not opinion
Delivery health, measured continuously.
Four metrics validated by a decade of research. They measure the health of the entire delivery system — not lines of code.
- Is AI actually helping? — DORA metrics tell you, not vanity metrics
- Speed and stability reinforce each other — elite teams deploy on demand with <15% failure rate
- Data for the board — engineering health in language leadership understands
Before
- Teams feel faster but can’t prove it
- Management can’t justify the investment
- Vanity metrics replace real insight
With DORA
- Prove whether AI is actually helping
- Speed and stability measured together
- Data the board can act on
Agent autonomy is a governance problem, not a trust problem.
Agents generate faster than humans can review and can’t read unstated context. The answer isn’t “trust the agent” — it’s structured constraints enforced by the pipeline.
- 8 non-negotiable constraints — human-owned intent for every change, agents cannot promote their own code, pipeline-red means restore only
- Separation of concerns — orchestrators don’t write code, implementation agents don’t review code, review agents don’t modify code
- Expert validation at pipeline speed — test fidelity, architectural conformance, intent alignment, security — all automated
Before
- Agents define their own scope unchecked
- Teams rubber-stamp generated code
- Nobody can trace what went wrong
With governance
- Every commit has provenance and traceability
- Expert agents validate at pipeline speed
- Audit what was told and what was produced
The Compass
Four Metrics. One Definition of Healthy.
Elite performers hit all four. Speed and stability aren't trade-offs — they reinforce each other.
On demand
Deployment Frequency
Ship when ready, not when scheduled
< 1 hr
Lead Time
Commit to production
< 15%
Change Failure Rate
Changes that cause incidents
< 1 hr
Time to Restore
Incident to recovery
These Practices Compound. Remove One and the Cycle Breaks.
Practices Are Not a Slide Deck. They Are How We Work.
In product development
- TDD, clean architecture and trunk based development on every feature
- A pipeline with quality gates from the first commit
- A code health score and DORA metrics at every milestone
- Our delivery platform enforces the practices so they hold at AI speed
In AI engineering
- Specifications first: the evaluation set is the acceptance test
- Small batches: one narrow pilot, judged before it is trusted
- Continuous delivery: nothing ships without passing the suite
- The same discipline applied to prompts, retrieval and agents as to code
In team enablement
- Pairing with your engineers on your actual codebase
- A DORA baseline, then measurable improvement
- Practices transfer through doing, not teaching
- We step back when the numbers hold without us
Work with us
The Teams That Already Have This Foundation Are Pulling Ahead.
These practices are how we build AI systems and software products, and how we coach teams until they run them alone. You do not have to change everything at once. You do have to start.