Pattern guide

AI-native SDLC and product delivery lifecycle

Changing how software gets specified, built and shipped once AI is in the room.

ways these programmes stall
4
steps in how we would address it
7
questions answered in full
7
In one paragraph

An AI-native SDLC changes the shape of product delivery rather than adding a coding assistant to it: requirements become a machine-readable corpus rather than tickets, gaps and contradictions are found before code exists, review and test-generation compress, and the human effort concentrates on judgement: resolving ambiguity, deciding what to proceed without, and the last few percent of correctness. Tenhaw publishes both halves of this: The Tenhaw Way as the product delivery lifecycle, and an AI-engineering-first build method that produced a working proof of concept in two weeks on a live engagement.

James Rooney, Founder

Updated

Delivered

We have done this, and here is exactly how far that goes

We have published both the delivery lifecycle and the build method in full, and applied the build method on a live client engagement where it produced a working proof of concept in two weeks, pair-programmed with the client's own engineer. What we have not yet done is roll an AI-native SDLC across an engineering organisation of several hundred people, and that is exactly the work our design and build teams are scoped for: you start from a published method and a proof point earned in two weeks, not from a pilot we are inventing on your budget.

Why this matters now

Developer tooling was among the earliest and widest enterprise AI deployments, and the useful research question has moved on from how many engineers use it. The DORA programme's 2025 report on AI-assisted software development concluded that AI acts as an amplifier, magnifying an organisation's existing strengths and weaknesses rather than delivering a uniform uplift. That is the finding worth planning around, because it explains why two organisations buying identical licences get different results, and why the unanswered question in most places is not whether engineers will use AI but why the lifecycle it was bought to change has not changed.

Ask a technical questionanswers from all 12 guides
Ask anything technical about ai-native sdlc and product delivery lifecycle and I will answer from this guide, and tell you first whether this is work we have delivered or an approach we would be taking.

Prefer to talk it through? Ask us on a discovery call →

Diagnosis

Where these programmes actually stall

Not the risks a vendor lists. The ones that stop the work.

01

Adoption plateaus, and more enablement does not move it

The first cohort adopt because they were always going to. Everyone else adopts when their actual role, measurement and definition of done change. More training does not move that, because awareness was never the constraint, and that is the single most common misdiagnosis we see. An AI programme stalled at the tooling layer looks the same from the outside every time: the licences are bought, a minority of them are in daily use, the demos went well, and the lifecycle they were bought to change has not changed at all.

02

Requirements stay in tickets and people's heads

If the model can only see one file at a time, you have bought a faster autocomplete rather than changed the lifecycle. The leverage comes from giving the model the whole requirement set, which requires the requirements to exist somewhere machine-readable, which is a process change rather than a tooling one.

03

Review capacity becomes the new bottleneck

Generation speeds up and human review does not, so the queue simply moves. Organisations that do not redesign review (what gets automated first-pass, what a human must see, what the standard is) end up with the same throughput and more code to maintain.

04

There is no enforceable standard for what good looks like

A model will happily produce code that passes tests and violates every convention the team holds. Without a standard explicit enough for an agent to enforce, output volume rises and maintainability falls, which shows up two quarters later as slower delivery.

Prescription

How we would address it

Grounded in The Tenhaw Way and the engagements written up in our case studies.

  1. 01

    Treat requirements as the source code

    Convert the requirement estate into structured markdown, map the relationships, and run the gap-and-contradiction pass before any build. This is steps one to seven of our published build method, and it is the part that changes the economics rather than the part that generates code.

  2. 02

    Move the unit of work from stories to outcome-driven epics

    The concrete change in our own definition of done: epics become outcome-driven and oriented around the behaviour of the system, rather than work being decomposed into stories describing what someone will build. Development then starts by pasting the epic into Claude or Codex in the editor and iterating until both the business objective and the code are met, which only works if the epic actually describes the outcome rather than the task.

  3. 03

    Replace human authorship with human verification of coverage

    Where a model writes most of the code, the control is no longer reading every line. It is high automated and unit test coverage, performance testing, and manual testing of the key user journeys. If all of those pass, the system is no more at risk than human-written code, the output volume is simply much higher. That is a different assurance model, and a risk function can sign it off because every control in it is testable rather than asserted: coverage, performance and the key user journeys either pass or they do not, and the evidence is on file.

  4. 04

    Make the engineering standard machine-enforceable

    We publish ours as an open-source handbook with stable rule identifiers and RFC 2119 severities, written to be enforced by an agent rather than remembered by a human. An organisation adopting this needs its own equivalent, and agreeing it is a fortnight of work that saves quarters.

  5. 05

    Treat engineer resistance as signal, not obstruction

    Resistance is expected, because change is hard, and we bring people on the journey by sitting with them and showing the value rather than mandating it. The more useful observation is that engineers who push back for a specific technical reason are very often right. Once the objection is understood it can usually be resolved by updating a skill file or an instruction so the model stops doing the thing they objected to, and those engineers then adopt fastest, because their objection was answered rather than overruled.

  6. 06

    Pair rather than hand over

    Capability transfers by building together. On our insurance engagement the client engineer who paired through a two-week build finished it 70% confident they could run the process unaided, the measure we would want across a wider adoption programme rather than counting licence activations.

  7. 07

    Measure adoption as behaviour, not seats

    Licence activation is not adoption. What matters is whether the lifecycle changed: are requirements maintained as a corpus, has review been redesigned, is the standard enforced, and has throughput moved on real work. Our Adoption Lead owns this, and it is measured monthly rather than surveyed annually.

Where a model writes most of the code, the control is no longer reading every line.
Where this usually starts

Agentic Build Team

A team of three who build and ship it, under partner oversight. £70k–£85k / month · 6–12 months.

What that engagement covers

AI-native SDLC and product delivery lifecycle: your questions

What is an AI-native SDLC?

A software delivery lifecycle redesigned around AI doing the research, drafting, scaffolding and first-pass review, rather than one with a coding assistant bolted on. In practice it means requirements maintained as a machine-readable corpus rather than as tickets, gaps and contradictions resolved before code is written, review redesigned because generation is no longer the bottleneck, and an engineering standard explicit enough for an agent to enforce.

Why does AI coding tool adoption stall?

Because the first cohort adopt for their own reasons and everyone else adopts only when their role, measurement and definition of done change. Additional training and enablement reliably fail to move it, because awareness was never the constraint. Moving it requires lifecycle and operating-model change: what a story must carry, what review looks like, and what good is defined as. The 2025 DORA research points the same way from a different angle, finding that AI amplifies an organisation's existing strengths and weaknesses rather than lifting everyone equally, which is why the same licences produce different outcomes in two different engineering functions.

Does AI-assisted development make code less maintainable?

It does if there is no enforceable standard, because a model will produce code that passes tests while violating conventions the team holds, and it will do so faster than humans can review. The mitigation is a standard specific enough to be machine-enforced, applied from the first prompt rather than in review. Tenhaw publishes its own as an open-source handbook with stable rule identifiers and RFC 2119 severities.

How do you handle engineers who resist AI-assisted development?

By taking the objection seriously rather than treating it as change resistance. In our experience engineers who push back for a specific technical reason are usually correct, the model is doing something that genuinely violates a standard or a constraint they can see and you cannot. That is nearly always fixable by updating a skill file or instruction so the behaviour stops. Engineers whose objection gets answered that way tend to adopt fastest, because they were listened to rather than overruled. Sitting with people and showing the value works; mandating it does not.

If AI writes most of the code, how do you know it is safe?

By changing the control from authorship to verification. High automated and unit test coverage, performance testing, manual testing of key user journeys, and a published engineering standard the code is generated against. If all of those pass, the system carries no more risk than human-written code, the difference is that output volume is considerably higher. Tenhaw also runs static analysis, dependency and secrets scanning on every commit and a model-led security review roughly every fifth prompt, which in practice makes proofs of concept more compliant than a lot of legacy code.

How do you turn a proof of concept into production software?

Decide first whether you are hardening it or rebuilding it, and be willing to rebuild. A proof of concept is optimised to answer a question, so it usually carries shortcuts in identity, error handling and data handling that cost more to unpick than to redo, while the thing worth keeping is the requirement corpus and the evidence about what works. From there the route to production is the ordinary one: the requirements as a machine-readable corpus, a build against the whole set rather than ticket by ticket, high automated and unit test coverage, performance testing, manual testing of key user journeys, a security review roughly every fifth prompt, and a named owner who has agreed the acceptance criteria in advance. Our own evidence here: a proof of concept taken from a blank repository to working in two weeks on a live engagement inside a regulated insurer, with that build now being productionised, scoped at four to six weeks with a dedicated team, which is exactly what our build teams exist for.

How do you measure whether an AI-native SDLC is working?

Not by licence activations. By whether the lifecycle actually changed: whether requirements are maintained as a corpus, whether review has been redesigned, whether the engineering standard is enforced, whether throughput moved on real work, and how confident engineers are that they could run the method unaided. That last one is measurable, so ask them, and take the honest number.

Sources

Where the checkable claims came from

Every source below was opened and read before it was attached. Where nothing survived that check, the claim on this page was softened rather than given a plausible-looking link.

  1. 01
    DORA, State of AI-assisted Software Development 2025

    Published by Google Cloud with IT Revolution, GitHub, GitLab, SkillBench and Workhelix. Source of the amplifier finding: AI magnifies an organisation's existing strengths and weaknesses rather than delivering a uniform uplift.

Talk to us about ai-native sdlc and product delivery lifecycle.

A 30-minute call with James Rooney. We'll tell you honestly which parts of this we have done before and which we would be doing for the first time, and you'll leave with a rough scope either way.

30 minutesWith James personallyNo obligation

Most organisations start with a fixed-price Agent-Readiness Audit · £30k–£90k · 6–8 weeks