AI DeliveryPreview Learning Center

Before and after

The same seven stages. Watch what each one hands to an agent, and what it keeps.

The classic lifecycle on top, the AI lifecycle below. Play the lanes, then drag the slider through each role to see how the day changes for a developer, an architect, a tester, a platform engineer, an SRE and security.

the AI actsa person actsa gate: a person or the repository decides

By role

Drag the line: your day, before and after

Pick a role, then drag. The left is how the work was done; the right is how it is done when agents are in the loop, with the thing to watch for underneath.

    Before

    After

    Stage by stage

    Every change, with its source

    01 Plan

    Intent becomes a spec both people and agents can read

    Before

    • Requirements live in tickets, chats and slides; the code is the only complete description of what was built.
    • Estimates are made by hand and the backlog is sliced by people's availability.
    • Which AI tools may be used is unsaid, so every team decides alone.

    After

    • Intent is written as a spec that agents read as their brief and people read as the contract. GitHub's Spec Kit calls the phases Spec, Plan, Tasks and Implement, each producing a Markdown artifact that feeds the next [6].
    • The organization states its AI stance in writing: expectations for AI use, support for experimentation and which tools are permitted. DORA found this to be the first of seven capabilities that magnify AI's positive impact [2].
    • Work is cut into small batches on purpose, because small batches amplify AI's positive influence on product performance and reduce friction [2].

    The Plan stage in full →

    02 Architect

    Cloud design reviewed against principles, as code, before anything is built

    Before

    • Architecture is drawn in slides and reviewed in a meeting; the drawing and the cloud drift apart within weeks.
    • Design reviews happen once, before the project; the system that goes live was never reviewed as built.
    • Reliability, cost and security are separate checklists owned by separate teams.

    After

    • Architecture is written as code and decision records, and an agent reviews each change against written principles. The AWS Well-Architected Generative AI Lens states six: design for controlled autonomy, implement comprehensive observability, optimize resource efficiency, establish distributed resilience, standardize resource management, and secure interaction boundaries [7].
    • Google SRE's own account describes agents that help make reliability part of system design through the design, launch and deployment phases, where a number of issues can be detected and auto-addressed before they need to be reviewed by a person [3].
    • Infrastructure is generated and validated with no cloud credentials before it is ever applied; the validation ladder is shown, with real runs, in the test center [14].

    The Architect stage in full →

    03 Build

    Agents write under rules the repository enforces, not rules it hopes for

    Before

    • A developer types every line; a peer reviews the diff; style and safety rules live in a wiki.
    • A mistake is caught in review if the reviewer happens to look there.
    • Local tooling is personal: whether tests run before a push depends on who is pushing.

    After

    • Coding agents work from a brief in the repository (CLAUDE.md, AGENTS.md) and under hooks that run deterministically: Claude Code fires PreToolUse before a tool call and can block it, and PostToolUse after one succeeds, among its lifecycle events [9].
    • Enforcement moves from the wiki into the machine. A PreToolUse hook that exits with code 2 blocks the action and its message goes back to the agent, so a protected file or a destructive command is refused every time, not usually [9].
    • The expectation is checked, not assumed. In METR's randomized trial of early 2025, 16 experienced open-source developers working on 246 real issues from their own repositories took 19% longer with AI allowed, while forecasting a 24% speed-up and believing afterwards they had been 20% faster; METR notes that newer results, current as of early 2026, have since been released [8]. DORA's 2025 survey found 90% using AI at work, more than 80% believing it raised their productivity, and 30% reporting little or no trust in AI-generated code [1].

    The Build stage in full →

    04 Test

    Every incident earns a test, and every AI-written test carries its provenance

    Before

    • Testing is a phase at the end; a QA team finds what the sprint left behind.
    • A flaky suite is tolerated and re-run until green.
    • Nobody can say who wrote a test, against which requirement, or whether it was ever seen to fail.

    After

    • Tests are written with the code, by the same agent or a subagent that may not touch the source, and every real incident in the Learning Center becomes a test in the test center that would have caught it [11].
    • A test an agent wrote carries a passport: who or what wrote it, to which spec, with what evidence, healed by whom [12].
    • AI output is not deterministic, so evals gate on a pass rate with a confidence bound instead of one green run, with promptfoo and pytest shown on real runs [13].

    The Test stage in full →

    05 Release

    Continuous delivery with provenance, canaries and a person at the production gate

    Before

    • Releases wait for a train and a change board; the batch is large because the ceremony is expensive.
    • What is in the build is whatever the build machine had; nobody can prove it.
    • Rollback is a plan on paper.

    After

    • Every build carries provenance. SLSA v1.1's build track exists so that an artifact can be verified as built as expected; at Build L1 the package has provenance showing how it was built, L2 means forging it requires an explicit attack, L3 that forging it requires exploiting a vulnerability [5].
    • The change volume AI brings is the risk. DORA 2025 found AI adoption positively related to throughput but still negatively related to delivery stability, because more change without robust controls means instability [1]. Its model names the controls: strong version control with frequent commits and frequent rollback, and working in small batches [2].
    • The agent drafts the release notes and the risk summary; a protected environment with a required reviewer is the only path to production, as the deploy workflow in the AI SDLC example shows [10].

    The Release stage in full →

    06 Operate

    Agents on call: anomaly detection, enriched alerts, drafted postmortems, people where it matters

    Before

    • Alerts fire on static thresholds and most of them are noise.
    • Runbooks go stale between incidents; the person on call searches a wiki at 3 a.m.
    • The postmortem is written days later from memory.

    After

    • Google SRE describes augmenting threshold alerts with anomaly detection on deviations from regular behavior, agents that group, pre-process and enrich alerts, and autonomous alert handlers that can address or mitigate issues, with a likely significant reduction in the alerts SREs review [3].
    • Agents monitor and improve playbooks from how they are used during incidents and can generate new playbooks from incidents; in incident management they summarize data, create hand-off documents, draft postmortems and manage communications [3].
    • The limits are stated as clearly as the gains: an agentic approach does not necessarily imply removing people, specifically for higher-risk services and features, but it does significantly reduce the time people need to spend [3].

    The Operate stage in full →

    07 Govern

    Policy as code, evidence as a by-product, a framework written for AI software

    Before

    • Policy is a PDF; evidence is gathered once a year for the audit.
    • Security reviews the system after it is built and files findings the roadmap never reaches.
    • Nobody has a list of which agents exist, what they can reach and who approved them.

    After

    • The standards now name AI software. NIST published SP 800-218A in July 2024, a community profile of the Secure Software Development Framework for generative AI and dual-use foundation models, and released the initial public draft of SSDF 1.2 (SP 800-218r1) for comment in December 2025 [4].
    • The agent-specific risks have a list: the OWASP Top 10 for Agentic Applications, covered test by test in the test center and incident by incident in the Learning Center [11].
    • Evidence is produced by the pipeline as it runs: provenance from the build [5], the hook log from the agent's session [9], the approval from the environment gate [10], and an audit trail of every agent action, which the Learning Center lists as a weakness when it is missing.

    The Govern stage in full →