P0
Diagnose
Fixed scope
Understand the constraint before proposing anything. Walk the process, read the data, talk to the people who run it at 2am.
Artefacts
- Constraint map
- Data readiness assessment
- Opportunity sizing
- Risk register
02 Approach
A method, not a methodology.
Seven phases, each with a defined intent and a defined artefact. We move through them quickly, we say out loud when a phase has failed, and we do not skip the parts that only pay off in year three.
01 The arc
Seven phases from first walk to steady state.
Phases overlap in practice. What does not move is the requirement that each one produces something a client can read, challenge and keep.
P1
Architect
Design-led
Design the target state and the sequence to reach it — with the trade-offs written down and the failure modes named.
Artefacts
- Target architecture
- ADR set
- Sequenced roadmap
- Cost & capacity model
P2
Prove
Pass / fail gated
Retire the riskiest assumption first with a hard-edged proof — real data, real constraints, a pass/fail bar agreed up front.
Artefacts
- Working proof on production data
- Evaluation results
- Go / no-go decision
P3
Build
Incremental
Engineer the system on a paved road: CI/CD, quality gates, observability and security from the first commit, not retrofitted.
Artefacts
- Production services
- Test & eval suites
- Pipelines & IaC
- Runbooks
P4
Industrialise
Overlaps build
Take it from "works" to "works at scale, everywhere" — performance, resilience, multi-site rollout and compliance evidence.
Artefacts
- Load & chaos results
- DR plan tested
- Rollout playbook
- Compliance pack
P5
Deploy
Progressive
Progressive delivery into live operations with a tested path backwards and operators who were trained before go-live.
Artefacts
- Staged rollout
- Operator enablement
- Support model
- Acceptance sign-off
P6
Operate & evolve
Continuous
Own the SLOs, watch for drift, retire the debt and keep improving — or hand over cleanly to a team we have brought up to speed.
Artefacts
- SLO reporting
- Model & dependency upkeep
- Roadmap reviews
- Handover pack
02 AI & agent-native delivery
Where the machine helps, and where it must not.
AI and agents are embedded across our lifecycle rather than bolted onto one stage. The division of labour is explicit, because the failure mode is letting a system make decisions it cannot be accountable for.
| Stage | Human owns | AI / agent accelerated |
|---|---|---|
| Specification | Problem framing, constraints, acceptance criteria | Story generation, edge-case enumeration, spec linting |
| Architecture | Trade-off decisions, failure-mode reasoning, ADRs | Option exploration, prior-art survey, diagram scaffolding |
| Implementation | Interface design, invariants, review judgement | Scaffolding, boilerplate, migrations, agent-driven refactors at scale |
| Verification | Risk-based test strategy, adjudicating failures | Test generation, coverage gap analysis, fuzz corpora, eval suites |
| Review | Design critique, security judgement, sign-off | First-pass review agents, convention enforcement, diff summarisation |
| Release | Go / no-go, blast-radius call, rollback decision | Release notes, change-risk summarisation, gate evidence assembly |
| Operations | Incident command, permanent fixes, capacity calls | Log triage agents, runbook drafting, postmortem assembly |
The uplift we see from this split sits in the 30–40% range on software delivery throughput, concentrated in specification, scaffolding, test authoring and review. It is a product-lifecycle figure, not a claim about plant productivity, and we report it against a measured baseline or not at all. How we measure it.
03 Agent-native ways of working
Agents raise the quality bar. They do not replace it.
When generation becomes cheap, review, verification and provenance become the scarce resources. Our operating rules exist to stop a throughput gain being quietly funded out of quality.
- 01
Agents propose, humans dispose
Anything irreversible — a schema migration, a production change, a commitment to a customer — needs a named human decision. Agents shorten the path to that decision; they do not take it.
- 02
One gate for all code
Generated code enters through exactly the same gate as hand-written code: review, tests, static analysis, CI. There is no fast lane, and no "it was only scaffolding" exemption.
- 03
Rework is instrumented
A team can generate faster and spend the entire saving on review and defect repair. Unless rework and change-failure rate are measured, that outcome is indistinguishable from a real gain.
- 04
The bar rises as generation cheapens
When producing a test costs almost nothing, having thin tests is no longer defensible. Cheaper generation is spent on coverage, edge cases and documentation, not on shipping more of the same.
- 05
Prompts and tools are source
Prompts, tool definitions, agent configurations and eval suites live in the repository, are reviewed, and are versioned. If it changes behaviour, it is a release.
- 06
Provenance stays attributable
Agent-assisted changes are identifiable in the history. When something needs explaining to an auditor, a regulator or a new joiner, the trail exists.
Gates every change passes, whoever wrote it
Ready
- Acceptance criteria explicit
- Constraints and NFRs named
- Test approach agreed
Done
- Tests written and meaningful
- Observability in place
- Docs and ADR updated
Review
- Human design critique
- Security judgement applied
- Convention checks automated
Release
- Progressive rollout
- Rollback tested
- Eval / regression gate green
Where agents run inside a client's own product rather than inside delivery, the same controls apply plus the runtime harness — tool contracts, sandboxing, authorisation gates, trace capture and adversarial testing. The harness in detail.
04 Non-functional baseline
The parts that are never the trade.
Scope can move. Dates can move. This list does not, because everything expensive that happens later starts with one of these being skipped.
Security & compliance
- Threat modelled per service
- Supply-chain scanning, SBOM
- Least privilege, secrets rotation
- Audit trails built for evidence
Reliability
- Explicit SLIs, SLOs, error budgets
- Failure modes documented
- DR tested, not assumed
- Chaos and load in the pipeline
Observability
- Traces, metrics, structured logs
- Dashboards per user journey
- Alerting tuned to symptoms
- Model drift and data quality
Engineering hygiene
- Trunk-based, reviewed, gated
- Architecture decision records
- Contract and integration tests
- Dependency and debt budgets
Cost discipline
- Unit economics per workload
- Right-sizing and autoscaling
- Inference cost as a first-class SLO
- Monthly run-rate reporting
Knowledge transfer
- Pairing over throwing-over-the-wall
- Runbooks and operator training
- Living documentation
- Exit plan from day one
05 What we decline
The work we turn down.
A lab is defined as much by what it refuses. Saying this early saves everyone a procurement cycle.
- 01 A pilot with no route to production and no owner named.
- 02 An AI project chosen before the problem was.
- 03 A deadline that can only be met by dropping the non-functional baseline.
- 04 Work where we would be the only ones who understand the result.
- 05 A scope that could only be delivered by lowering the seniority of the team on it.
Engagement
Start with a diagnostic, not a contract.
Most relationships begin with a fixed-scope diagnostic on a single constraint — fixed price, with a written assessment and a costed option set at the end. If the honest conclusion is that you do not need us, that is what the assessment will say.
or write directly — [email protected]