TL;DR:AWS open-sourced AI-DLC (AI-Driven Development Life Cycle) : It’s a methodology that transforms Claude Code from an autocomplete tool into a disciplined, phase-driven engineering partner. In this article, you’ll learn what AI-DLC is, how it works, and how to use it with Claude Code with a real walkthrough building afrom scratch using sample project as a reference.Task Management API
Picture a Monday morning. You open Claude Code & type :
“Build me a user authentication service.”
And Claude Code immediately starts writing code.
It picks JWT (but you wanted OAuth2). It uses SQLite (your team is using PostgreSQL). It creates a new session store (you already have Redis). It uses Angular + Java (your whole codebase is in React Js + Python). It ignores your company’s error-handling conventions. And it skips tests entirely.
The code it creates is fine. But the real problem is that Nobody told the AI to ask questions first.
This is the core failure mode of what the community now calls ** vibe coding. **And it’s treating AI coding agents like a hyper-fast typist rather than a disciplined software engineer. You get output fast, but you spend the next 3 days cleaning up architectural decisions the AI made autonomously, and might be incorrectly.
AWS’s AI-DLC solves this at the methodology level. It doesn’t change how Claude Code works internally, it changes how you structure the conversation before a single line of code is written.
** AI-DLC stands for AI-Driven Development Life Cycle. **It is an open-source agent agnostic methodology published by AWS Labs at
At its core, AI-DLC is a **set of steering rules - **plain markdown files that you drop into your project directory. Claude Code reads them as persistent instructions and follows a structured, phase gated workflows instead of jumping straight to code.
The philosophy behind it, as stated by AWS is captured in four principles as follows :
**4. Adaptive Rigor : **Simple request stay lightweight whereas complex brownfield changes get comprehensive treatment. AI-DLC scales it ceremony to the task.
You might be thinking: I already have instructions in my CLAUDE.md then what is different? Right?
The difference lies in structure and enforcement.
A typical CLAUDE.md might says :
- Always use TypeScript- Follow our naming conventions- Write tests for every function
These are style preferences. They don’t govern when to write code, what questions to ask first or what documents to produce before implementation begins.
AI-DLC’s core-workflow.md (which becomes your CLAUDE.md ) is ~538 lines of structured workflow logic. It tells Claude Code :
Now, you might be clear on that it’s the difference between a ** style guide** and a
AI-DLC follows a three-phase lifecycle. Each phase is adaptive-It only executes stages that are relevant to your specific request.
This phase helps to determine the what and *why *before any design or code is discussed.
Every stage produces an artifact in aidlc-docs/inception/ . Claude Code presents it, waits, and does not proceed unit you explicitly approve them.
This phase takes the approved inception artifacts and turns them into working code. For each unit of work it helps to generate following :
Each stage reads from the previous stage’s artifacts. The AI cannot skip the functional design and jump to code the workflow gates prevent it.
(Currently marked as “future” in the official repo, with placeholder structure)
This phase will cover CI/CD pipeline generation, monitoring setup, runbook creation and deployment automation. The foundation is built-content is being added.
You can refer the below repository for reference which I’ve developed while writing this article :
GitHub - Pravin1Borate/aws_aidlc: aws_aidlc
Pre-requisites :
git clone https://github.com/awslabs/aidlc-workflows.git
You’ll have two directories:
cd your-project/# Copy the core workflow as CLAUDE.mdcp .\aidlc-workflows\aidlc-rules\aws-aidlc-rules\core-workflow.md .\CLAUDE.md# create a directorymkdir -p .aidlc-rule-details# Copy the detail rulescp .\aidlc-workflows\aidlc-rules\aws-aidlc-rule-details\* .\.aidlc-rule-details\
Your project structure now looks like:
your-project/├── CLAUDE.md ← AI-DLC core workflow (538 lines of process rules)└── .aidlc-rule-details/ ├── common/ ← Session continuity, content validation, question format ├── inception/ ← Workspace detection, requirements, design rules ├── construction/ ← Functional design, NFR, code generation rules ├── extensions/ ← Optional: security baseline, property-based testing └── operations/ ← Future: deployment, monitoring rules
Claude Code should describe the AI-DLC workflow, phases, and stage-gating behavior as below :
git add CLAUDE.md .aidlc-rule-details/git commit -m "chore: add AI-DLC workflow rules"
Everyone on your team now has the same workflow behavior no per-developer setup required.
Let’s walk through an end-to-end example using a project : a REST API for managing tasks, with user authentication, priority levels, and due date tracking.
Inside your project directory (an empty folder), launch Claude Code :
The magic phrase to activate AI-DLC is always:
Using AI-DLC, build a REST API for task management with user authentication,task CRUD operations, priority levels, and due date tracking.
The Using AI-DLC, prefix is the activation trigger. Claude Code reads your CLAUDE.md, recognizes the methodology, and does not start writing code.
Claude Code’s first action is to scan your workspace:
For a **brownfield project (i.e. existing codebase), **this stage would instead :
After completing workspace detection phase, Claude Code creates a structured questions file **not a chat message **for requirement analysis:
You can see in logs Claude Code has generated requirement-verification-questions.md:
You fill in your answers and then in Claude Code chat convey the message that you have completed the requirement questions
Claude Code reads your answers and generates aidlc-docs/inception/requirements/requirements.md:
Review checkpoint: Claude Code presents this and waits.
You review, request one change (“add FR-011: task tags/labels”), Claude Code updates the artifact, and you approve.
Once we approve the requirement analysis part, Claude Code generates INVEST-compliant user stories:
Review checkpoint: Here, you can review user stories and approve it and continue with next steps
Then it generates execution plan which you can review, request one if any change is required Claude Code updates the artifact, and you approve.
This is where AI-DLC earns its keep. Claude Code produces a high-level design document before a single file is created:
Review checkpoint. You approve (or request changes), and the stage is logged to aidlc-docs/audit.md.
Claude Code decomposes the approved design into parallel implementation units:
For each unit, AI-DLC runs the same sub-stages. Here’s Unit 01 abbreviated:
Functional Design:
NFR Requirements & Design:
Code Generation:
Only after both design documents are approved does Claude Code write files:
Every generated file is consistent with the decisions captured in the inception artifacts. No drift. No surprises.
By the time construction is complete, your project has this fully populated:
This is not throwaway scaffolding. It’s living documentation that stays in sync with your code because the AI generated the code from these documents not the other way around.
AI-DLC has a built-in extension system. Two come out of the box:
Security Baseline Extension : Adds security gates at each construction stage:
Property-Based Testing Extension: Adds generative testing requirements to the build stage.
Extensions are opt-in, triggered during Requirements Analysis:
[AI-DLC] Extension: Security Baseline━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Would you like to enable the Security Baseline extension?When enabled, security rules are BLOCKING — stages cannot proceeduntil security checks pass.
[A] Yes — enable security baseline (recommended for production APIs)[B] No — skip security extension
You can also write your own organization-specific extensions by adding rule files to .aidlc-rule-details/extensions/your-category/.
Every decision, every approval, every stage transition is logged:
When a new team member joins, they read aidlc-docs/ . They know why every architectural decision was made, not just what the code does.
AI-DLC is file-based, So even if Claude Coede’s context window fills up (which it will on large projects), you simply start a new session:
Continue AI-DLC for this project. Check aidlc-docs/aidlc-state.md for current status.
Claude Code reads the state file, sees exactly which stages are completed and resumes from where you left off. No re-explaining the entire project.
More powerfully, you can also switch IDEs mid-project. Start inception in Claude Code, hand off construction to a teammate using Cursor they read the same aidlc-docs/ artifacts and pick up seamlessly. The methodology is agent-agnostic.
A cloud engineer at AWS summit Japan 2026 used Claude Code (for diff review) alongside Kiro (for implementation) with AI-DLC running as governing workflow. Two catches from that sprint that a single-agent approach missed :
Both issues were caught before code generation at the design review stage. In a plain prompt workflow, they would have been discovered during or after production deployment.
**Start every session with the activation phrase : ****Using AI-DLC , **prefix is mandatory. Without it, Claude Code ignores the workflow rules and just starts coding.
**Answer questions concisely but specifically: **During requirements analysis, vague answers produce vague requirements. A : JWT with 15 minute access token expiry and 30-day refresh, using RS256 algorithm is infinitely more useful than A: JWT
**Resist the urge to skip stages: **It’s tempting to say skip user stories, just go to design Resists. The stories become the acceptance criteria for the test suite. Skipping them creates a gap you’ll feel later.
**Use extensions for production systems: **Enable the security baseline extension for any API that handles user data or authentication. The extra review gates are worth it.
**Commit **aidlc-docs/ to your repo: The docs are not scaffolding they are living documentation. Version them like you version your code.
Write your own extensions: If your organization has compliance requirements (SOC2, HIPAA, PCI-DSS), codify them as AI-DLC extensions. They become blocking gates that Claude Code enforces automatically on every project.
What makes AI-DLC interesting beyond the technical mechanics is the shift in mindset it encodes.
The traditional SDLC assumes humans write most of the code and AI assists. AI-DLC assumes agents do most of the writing and humans govern the decisions. This reorients where senior engineering judgment is most valuable not in implementation, but in:
Six engineers rebuilt the entire Amazon Bedrock inference engine in 76 days using agentic tools. The original estimate was 40 engineers and a full year. That compression ratio is not primarily a function of the AI writing code faster. It’s a function of the workflow being disciplined enough that the AI’s output didn’t require constant course correction.
AI-DLC is that discipline, made portable and open-source.
If this helped you move from vibe coding to disciplined AI engineering, share it with your team. The methodology is free, open-source and works with any coding agent. The only thing it requires is that you slow down long enough to plan before you build and this thing will help you to avoid long debugging hours and explaining project again and again to Claude Code.
Follow me for more practical engineering takes & usage of AI systems.
AI-DLC + Claude Code : The End Of Vibe Coding, A Complete Hands-On Guide was originally published in Towards AI on Medium, where people are continuing the conversation by highlighting and responding to this story.