AWS Builder Center
Which SDLC checks the AI-Driven Development Lifecycle moves

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)

  1. …
  2. 4
    Which SDLC checks the AI-Driven Development Lifecycle moves This article
Global Sr. Solutions Architect, Private Equity
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.
Three columns. Move fully to the spec, 4 checks: use-case validation, threat model in the spec, revi

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.
Five stages from left to right. Spec and design covers the threat model, scope, and rules. Build and

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

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)

  1. …
  2. 4
    Which SDLC checks the AI-Driven Development Lifecycle moves This article
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article