
Which SDLC checks the AI-Driven Development Lifecycle moves
I tested whether the AI-Driven Development Lifecycle moves every software check to the spec. See which checks move, which stay in the pipeline, and why.
Series: A study on AI in the product lifecycle (4 articles)
- …
- 4Which SDLC checks the AI-Driven Development Lifecycle moves This article
Can a structured method move every check in your software development lifecycle (SDLC) to the spec? The AI-Driven Development Lifecycle speeds up the path from intent to code. Its output then passes through the same reviews, pipeline scans, and deployments as any other change. I sorted the 21 checks from part 1 and the security article by the earliest point each can run. Of those, 17 still need a pipeline gate or running software, and only 4 move fully to the spec. My view is that the method's value lies in moving intent and rules to the start and making those decisions auditable, while verification of built software stays in the pipeline. In this article, I sort those checks, show what the method enforces and what stays guidance, and cover how to harden it, connect it to the pipeline, and measure the result. The full check map is at the end, so you can test the count against your own list.
Which checks can move to the start?
The 4 that move fully are about intent and design, so they can finish before any code exists. Another 9 get an early version but still need a pipeline gate, and the last 8 need built or running software (Figure 1). In the figure, steering and AGENTS.md files are standing instructions the coding agent reads, and Kiro hooks run checks automatically when a file is saved or a task finishes. Reader and actor agents, from the security article , keep the agent that reads untrusted content separate from the one that takes actions. AWS Emulator tests are the local integration tests from the AWS Emulator article . That leaves 17 of the 21 checks needing pipeline or production investment, however good the spec is.

Figure 1. The 21 checks from part 1 and the security article, sorted by the earliest point each one can run. Source: author's analysis
The middle 9 need the most attention, because the AWS control framework for AI coding agents says steering biases generation toward secure defaults without guaranteeing them, and that neither author-time nor build-time controls are sufficient alone. Keep both versions of each of the 9, an early one that shortens the feedback loop and a blocking one in the pipeline that the agent can't skip. The other spec-driven methods I reviewed, BMAD-METHOD , GitHub Spec Kit , and Kiro specs , also run verification during or after implementation.
What the method enforces
The method enforces structure and human presence. Every stage in scope after initialization ends with an approval gate that needs a real message from a person. Traceability checks between phases catch missing links and orphaned artifacts before later stages build on them. By default, each unit of work is verified with a recorded command that a hand-written proof can't replace, and failures stop construction even when the team lets the agent continue on its own. Approvals and kept rules are recorded in an audit trail, so point reviewers at that trail and let a merge approval rest on recorded decisions.
What stays guidance, and how to harden it
The content of the security checks is guidance the agent reads. The method's guide to rules and the learning loop describes rules as prose the agent reads and sensors as deterministic checks. The sensors that ship with it only report findings, and none of them is a security scan. A check the team adds blocks a gate only when the team marks it as blocking.
The method's threat model sits in the nonfunctional requirements stage of construction, which runs per unit of work when its conditions apply. That stage applies STRIDE, a standard checklist of six threat categories such as spoofing and tampering. The development, security, and operations (DevSecOps) agent that contributes it runs only when supporting agents are switched on , which is the default only for enterprise work. The threat model is one of the 4 checks that can move fully, so consider writing its first version into your spec template before construction starts.
Teams can also bypass the enforced parts. A stage outside the scope has no gate, a stage the team jumps past doesn't run later on its own, and continuing automatically waives the ordinary checkpoints. Switches can turn off the sensors or the supporting agents, and turning off the supporting agents removes the threat model with them. A failing check can be overridden for one unit, and one setting turns off the human-presence check. To harden it, turn on the supporting agents for any work that touches security, and make the checks you rely on blocking. Require a second approver for skipped stages, overrides, and the human-presence setting.
One system from spec to production
The method's build and test stage runs static and dynamic analysis, dependency checks, and infrastructure as code (IaC) linting once code exists. It then hands its security gates to the agent that writes the continuous integration (CI) pipeline, which is where the rest of this series picks up. AWS Emulator runs integration tests locally at build and test, the gates from the security article block merges to the main branch, and penetration testing and gradual rollout run against deployed software (Figure 2). The method also has optional operation stages for deployment, observability, and incident response. Map each of the 9 middle checks to the pipeline stage that blocks it, so none of them depends on the agent alone.

Figure 2. The lifecycle and the pipeline as one system, with the return path for late findings. The method's optional operation stages can plan the deployment, observability, and incident steps
How late findings come back
The method's learning loop is how late findings reach the next spec. When a person corrects the agent and confirms the correction at a gate, the method saves it as a rule or a deterministic check and records the change. The loop starts only from a correction made inside a stage, so a production incident comes back only when someone brings it into a workflow. The National Institute of Standards and Technology (NIST) Secure Software Development Framework asks for the same step, reviewing the process after a vulnerability so its root cause doesn't recur. End each incident review with a workflow that turns the root cause into a rule or a check, so the next spec carries the fix.
How do you know it's working?
Part 1 introduced the spec one-shot rate, the share of specs that produce a mergeable pull request without revision. Track it for a quarter on work that runs through the method, along with change failure rate from the DevOps Research and Assessment (DORA) metrics. If the one-shot rate rises while change failure rate holds, the front of the loop is moving faster without pushing defects downstream. If change failure rate rises, defects are reaching production instead of being caught earlier, and one of the 9 middle checks is likely missing its pipeline gate.
Where does your team write its threat model today, in the spec, during the build, after a penetration test, or not yet?
The full check map
Each check from part 1 and the security article, the earliest point it can run, and what still has to run later. If your list differs, sort it the same way and compare the counts.
Check | Group | Earliest point it can run | What still runs later |
|---|---|---|---|
Product decision and use-case validation | Moves fully | Decide stage, before a spec | Adoption measured after launch |
Threat model in the spec | Moves fully | The spec's nonfunctional requirements | Penetration tests confirm it separately |
Reviewed spec as a scope boundary | Moves fully | Before code generation | AI review checks scope against it |
Reader and actor agent separation, Model Context Protocol (MCP) allowlist | Moves fully, as design | Architecture | Tool-call logging at run time |
Steering files and AGENTS.md | Moves partly | Session start | Deterministic pipeline gates |
Kiro hooks | Moves partly | File save, task completion | Same scanners in the pipeline |
Secrets detection, pre-commit | Moves partly | Commit | Pipeline scan and rotation |
Secrets detection, pipeline | Moves partly | First build stage | Rotation of exposed secrets |
Static application security testing (SAST) | Moves partly | Integrated development environment (IDE), on generated code | Blocking gate on main |
Software composition analysis and dependency controls | Moves partly | Vetted registry at design time | Pipeline scan and ongoing vulnerability monitoring |
IaC scanning | Moves partly | IDE policy checks | Template scan before deploy |
AI pull request review | Moves partly | Task-completion hook | Separate reviewer model, then a person |
Human approval of correctness | Moves partly | Spec review | Pull request approval |
Release readiness | Needs running software | After a change exists | None |
Local integration tests on AWS Emulator | Needs running software | Once runnable code exists | AWS Identity and Access Management (IAM) tests on real AWS |
Penetration testing | Needs running software | Deployed test environment | None |
Gradual rollout and rollback | Needs running software | Deployment | None |
Incident analysis | Needs running software | When an alert fires | Findings feed rules and tests |
Code vulnerability backlog | Needs running software | After findings exist | Human review of each fix |
DORA metrics and change failure rate | Needs running software | After deploys | Human baseline now |
Live agent metrics | Needs running software | Offline evaluations first | Re-measure after model changes |
Further reading
- Part 1: Measure AI developer productivity from idea to production (AWS Builder Center)
- Secure AI-generated code across the SDLC on AWS (AWS Builder Center)
- Test your coding agents locally with AWS Emulator (AWS Builder Center)
- AI-Driven Development Lifecycle (GitHub)
- Balancing speed and safety: A control framework for AI coding agents (AWS Security blog)
About the author
Michael Purpura is a Senior Global Private Equity Solutions Architect at AWS. He works with private equity firms and their portfolio companies to structure AI adoption around measurable business outcomes.
Series: A study on AI in the product lifecycle (4 articles)
- …
- 4Which SDLC checks the AI-Driven Development Lifecycle moves This article
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article