WEBVTT

00:00.000 --> 00:02.677
The AI delivery lifecycle

00:02.677 --> 00:10.622
Intent arrives
A product owner writes what should change and why, in a spec, not a chat message. The spec is the first artifact of the lifecycle and the one everything later is checked against.

00:10.622 --> 00:19.171
The agent drafts the plan
An agent reads the spec and the repository, proposes a technical plan and a task list, and flags what the spec leaves open. Spec Kit's phases name exactly this hand-off: Spec, then Plan, then Tasks.

00:19.171 --> 00:25.562
A person owns the spec
Nothing moves until a named person accepts the spec and the plan. The agent can propose; it cannot decide what the product is.

00:25.562 --> 00:33.609
The agent proposes a design
From the spec, an agent drafts the architecture: services, data flows, trust boundaries, the cloud resources as code, and a first threat model of where untrusted input meets a tool.

00:33.609 --> 00:41.092
Principles review it
A second pass checks the design against written principles, the six of the AWS Generative AI Lens among them, and against the organization's own decision records.

00:41.092 --> 00:48.889
An architect decides
A person signs the decision record. Controlled autonomy is the first of the Lens's principles for a reason: the boundaries of what the system may do are set here, by people.

00:48.889 --> 00:57.100
The agent takes a task
From the task list, an agent opens a branch, reads the brief in the repository and starts to write. Everything it does runs under the hooks and permissions configured for that repository.

00:57.100 --> 01:05.941
Hooks run on every edit
After each edit, a PostToolUse hook formats the file and runs the fast tests; before each shell command, a PreToolUse hook can refuse it with exit code 2. The rule holds whether the agent remembers it or not.

01:05.941 --> 01:14.743
A pull request opens
The agent opens a pull request with the tests that prove the change. From here on the repository, not the author, decides what merges; the full real example is the AI SDLC on GitHub page in the test center.

01:14.743 --> 01:23.055
Tests arrive with the change
The pull request carries unit, property and contract tests written against the spec. A subagent that may only write tests grades them by mutation score, so a test that cannot fail is caught.

01:23.055 --> 01:30.701
Checks run in parallel
Lint, unit, property, contract, the eval suite and the Test Passport check all start on the pull_request event; each is a required status check, so none can be skipped.

01:30.701 --> 01:38.138
The pass rate decides
For the AI parts, the gate is a pass rate with a confidence bound over repeated runs, not a single green. The number is in the repository, where a person set it.

01:38.138 --> 01:44.624
Build once, attest
Main is built once; the artifact is signed and its provenance recorded, so what reaches production is verifiably what was tested.

01:44.624 --> 01:52.805
Canary and verify
The build goes to staging through short-lived cloud credentials, then to a canary slice of production, while an agent compares its signals with the baseline and drafts the release notes.

01:52.805 --> 01:59.550
A person opens production
The production environment requires a reviewer. The agent has prepared everything it can; the approval is a human act, logged with a name.

01:59.550 --> 02:07.733
Signals, not thresholds
Agents collect signals and feed a model that flags deviations from regular behavior, then group and enrich what fires, so the person on call sees one enriched incident, not forty alerts.

02:07.733 --> 02:15.076
Investigate and propose
Using observability data, topology and dependencies, an agent forms hypotheses and proposes mitigation steps; for some low-risk cases it mitigates on its own.

02:15.076 --> 02:24.549
A person holds the risky ones
For higher-risk services a person decides, with the agent's reasoning in front of them: Google's principles require agents to explain why and how they acted and what they rejected, favoring transparency over black-box automation.

02:24.549 --> 02:32.619
Policy becomes code
Security writes the rules as policy code and hooks: what an agent may never run, which files it may never touch, which egress is allowed. The rules are reviewed like any code change.

02:32.619 --> 02:41.342
The pipeline produces the evidence
Each run leaves attestations, logs and approvals behind it. An agent assembles them against the controls of a framework such as the SSDF, so the audit reads the pipeline rather than interviewing the team.

02:41.342 --> 02:51.767
People own the exceptions
An exception to a policy is a pull request with a named approver and an expiry. The loop closes: what governance learns here becomes the next stance in Plan, and the lifecycle starts again.
