
From Intent to Software: Running the AI-DLC MCP Server in Kiro
A practical guide to the AI-Driven Development Life Cycle (AI-DLC), the AWS AI-DLC MCP server, and how to wire it into Kiro (or any MCP client) to drive a full Inception to Construction to Operations workflow from a single line of intent.

AI-DLC positions AI as a central collaborator and teammate, with a cross-functional team working around it. Source: AWS DevOps Blog .
Most teams adopt AI in software development one of two ways. Either AI is bolted on as an assistant that completes lines of code and writes the occasional test, or it is handed the keys and asked to generate a whole application from a paragraph of intent. Both under-deliver. The first reinforces the slow, ritual-heavy process we already had. The second trades away the human judgment that keeps software correct and aligned with the business.
The AI-Driven Development Life Cycle (AI-DLC) is AWS's answer to that gap: a methodology that puts AI at the center of development while keeping humans in control of the decisions that matter. This post gives a quick overview of the framework, explains what the AI-DLC MCP server is and how it differs from the rules-based distribution, and walks through wiring it into Kiro to build a small but real service end to end.
It is written for solutions architects, engineers, and engineering leaders who want to try AI-DLC on a real workspace without first reading the whole method paper.
A quick overview of the AI-DLC framework
AI-DLC is an AI-centric approach to software development built on two dimensions that pull in the same direction:
- AI-powered execution with human oversight. AI systematically creates detailed work plans, actively seeks clarification, and defers critical decisions to people, because only people hold the business context needed to make those calls.
- Dynamic team collaboration. Because AI handles the routine work, teams spend their time on real-time problem solving and decision-making rather than ceremony.
The mental model that repeats at every step is simple: AI creates a plan, asks clarifying questions, and implements only after a human validates it.

That loop runs continuously. The human provides intent, AI drafts a plan and surfaces open questions, the human clarifies, AI refines, the human approves, AI executes, and the human verifies the outcome before moving on.

The AI-DLC collaboration cycle. Humans decide and validate; AI plans and executes. Source: AWS DevOps Blog .
Three phases
Work flows through three phases, each feeding richer context into the next:
- Inception decides what to build and why. AI turns business intent into requirements, stories, and units through Mob Elaboration, where the whole team validates AI's questions and proposals.
- Construction decides how to build it. Using the validated context, AI proposes a logical architecture, domain models, code, and tests through Mob Construction, with the team clarifying technical decisions in real time.
- Operations applies the accumulated context to infrastructure-as-code and deployment, with team oversight.

AI-DLC also renames a few rituals to reflect its faster cadence. Sprints become bolts (intense cycles measured in hours or days), and epics become units of work. Context persists across phases because AI stores plans, requirements, and design artifacts in your repository, so work continues cleanly across sessions.
Why it works
The payoff is velocity without losing quality. AI does the heavy lifting on artifacts, which frees people for innovation, while continuous clarification means the team builds what it actually intended rather than an AI's guess at it. Every plan, decision, and approval is logged, so you get traceability from requirement to deployment. For regulated environments, that audit trail is a feature in its own right, which is why AWS has published AI-DLC guidance specifically for financial services .
AI-DLC ships in two forms
AI-DLC is a methodology first, so AWS distributes it in two complementary forms. Both implement the same Inception to Construction to Operations workflow and both keep a human at every gate. They differ in how the workflow is enforced.
| Rules-based (awslabs/aidlc-workflows) | Server-based (AI-DLC MCP server) |
|---|---|---|
How it works | The agent reads markdown steering / rules files | The agent calls MCP tools with typed parameters |
Phase enforcement | The agent interprets the rules | The server validates each transition programmatically |
Cross-session state | The agent re-reads rules each session | current_phase.json persists state across sessions |
Prompt customization | Edit scattered markdown files | Edit a single prompts.py module |
Dependencies | None (copy files) | Python 3.10+, the mcp package |
The rules-based approach is the zero-install path: drop steering files into your project and the agent drives the workflow. The AI-DLC MCP server takes the same methodology and exposes it as structured tool calls, so phase gates, state, and prompts are enforced by code rather than by the model's interpretation of markdown. This post focuses on the MCP server, then shows the rules-based path as an alternative.
Don't confuse this with the broader AWS MCP servers
One more clarification, because the word "MCP" gets overloaded. The AI-DLC MCP server is about process — it governs how the agent moves through the lifecycle. Separately, AWS publishes a large family of MCP servers for AWS that give an agent grounded knowledge and tools: live AWS documentation, API and CLI execution, infrastructure-as-code generation, and cost and best-practice guidance.
The two layers compose cleanly:
Layer | What it does | Where it comes from |
|---|---|---|
AI-DLC (MCP server or rules) | Governs how the agent works: adaptive phases, human checkpoints, audit trail | AI-DLC MCP server or awslabs/aidlc-workflows |
AWS MCP servers | Give the agent grounded knowledge and tools: AWS docs, API/CLI, IaC, cost guidance | awslabs/mcp |
In short: AI-DLC is the discipline, the AWS MCP servers are the reach. Run AI-DLC to keep the process honest, and attach AWS MCP servers so that when the workflow reaches a design or operations decision, the agent reasons from current AWS facts instead of stale training data.
What the AI-DLC MCP server looks like
The server implements the methodology as a small set of tools and a persistent state directory. An MCP client (Kiro CLI, Amazon Q CLI, Claude Desktop, Cursor, or Cline) talks to it over stdio:
┌─────────────────┐│ MCP Client │ (Kiro CLI, Q CLI, Claude Desktop, Cursor, Cline)│ (AI Assistant) │└────────┬────────┘ │ MCP Protocol (stdio) ▼┌─────────────────┐ ┌──────────────────┐│ AI-DLC MCP │────▶│ prompts.py ││ Server │ │ (customizable) │└────────┬────────┘ └──────────────────┘ │ ▼┌─────────────────┐│ .aidlc/ │ Project state, plans, artifacts, backups│ (persistent) │└─────────────────┘
It exposes seven tools that map directly onto the workflow:
Tool | Description |
|---|---|
aidlc_start_project | Initialize the project, detect Greenfield vs Brownfield, select the flow |
aidlc_get_phase_prompt | Get phase-specific instructions with the use case interpolated |
aidlc_get_next_phase | Recommend the next phase based on current state |
aidlc_set_phase_status | Advance a phase, with the transition validated by the server |
aidlc_update_project_plan | Update the plan with answers to clarifying questions |
aidlc_request_phase_approval | Request mandatory human approval before executing a plan |
aidlc_integrate_code | Copy generated code into the project, with destination validation, backup, and logging |
Two flows are available. The full flow runs all phases from inception through deployment and is the default for both Greenfield and Brownfield projects. The abbreviated (lite) flow streamlines the phases for bug fixes and minor enhancements, skipping unit decomposition and domain modeling — and it only runs when you ask for it explicitly. The server also hardens the file operations it performs: it rejects
.. path traversal and symlink destinations, sanitizes inputs and errors, caps filesystem scans, and pins its mcp dependency.
Adding the AI-DLC MCP server to Kiro (or any MCP client)
Setup is two steps: install the server, then register it with your client.
1. Install the server. Clone the patterns repository and install the package (Python 3.10+ required):
git clone https://github.com/aws-samples/sample-ai-powered-sdlc-patterns-with-awscd sample-ai-powered-sdlc-patterns-with-aws/all-phases/all-phases-aidlc-mcppip install -e .
2. Register it with your client. Add the server to your MCP configuration. For Kiro, use
.kiro/settings/mcp.json in the workspace, or ~/.kiro/settings/mcp.json for all projects:{ "mcpServers": { "aidlc": { "command": "python", "args": ["-m", "aidlc_mcp.server"], "disabled": false, "autoApprove": [] } }}
The same
aidlc block works for Claude Desktop ( claude_desktop_config.json ) and Cursor ( .cursor/mcp.json ). After saving, reconnect the server from Kiro's MCP Server view and confirm the seven aidlc_* tools appear. A quick check: ask the agent "What AI-DLC tools do you have?" — it should list all seven.Attaching AWS MCP servers for grounding
To let the workflow reason from current AWS facts, add one or more AWS MCP servers alongside
aidlc . A high-value starting point is the AWS Documentation server:{ "mcpServers": { "aidlc": { "command": "python", "args": ["-m", "aidlc_mcp.server"], "disabled": false, "autoApprove": [] }, "aws-docs": { "command": "uvx", "args": ["awslabs.aws-documentation-mcp-server@latest"], "env": { "FASTMCP_LOG_LEVEL": "ERROR" }, "disabled": false, "autoApprove": [] } }}
uvx ships with uv ; install that first if you don't have it. Browse the full catalog — including IaC, cost analysis, and service-specific servers — at the AWS MCP servers site .
Triggering the workflow: a worked example
You don't configure a pipeline or pick phases from a menu. You state your intent, and the agent drives the tools.
Let's build a small Loan Eligibility API — a service that takes a few inputs (income, existing monthly debt, requested amount, term) and returns an eligibility decision with a clear, rule-based explanation. It is simple enough to finish in one sitting, but real enough to exercise requirements clarification, a domain model, and tests.
In a Kiro chat, with the
aidlc server connected, you type:I want to start an AI-DLC project to build a loan eligibility API thatdecides eligibility from income, existing monthly debt, requested amount,and term, and explains the decision to the applicant.
What follows is the adaptive loop. Your exact questions and artifacts will differ — that variability is expected with LLMs — but the shape is consistent.
What the steps look like
Start the project. The agent calls
aidlc_start_project . The server detects this is a Greenfield project, creates the .aidlc/ state directory, and selects the full flow. Because it's greenfield, the Brownfield discovery stage is skipped.Get the phase prompt. The agent calls
aidlc_get_phase_prompt to retrieve phase-specific instructions with your use case interpolated, so it knows exactly what Inception expects.Plan and clarify (Inception → user stories and units). The agent drafts a plan with checkboxes, then asks clarifying questions before assuming anything: what the eligibility rule set is, what debt-to-income threshold to apply, whether decisions need to be persisted, and whether a decision history is required. You answer, and it records your input with
aidlc_update_project_plan . It then writes the user stories and groups them into units of work.Approve the gate. Before executing, the agent calls
aidlc_request_phase_approval . Nothing proceeds until you approve. When you're satisfied, it advances with aidlc_set_phase_status , which the server validates as a legal transition.Design and build (Construction). The agent proposes a domain model for the eligibility rules, then implements the service and its tests against the approved design, working step by step and ticking checkboxes as it goes. Generated code lives under
.aidlc/ until you choose to bring it into the project, at which point aidlc_integrate_code copies it in — creating a backup and logging the change first.Deploy (Operations). With the accumulated context, the workflow drives deployment. This is where attached AWS MCP servers earn their keep: when the agent reasons about hosting the API, the AWS Documentation server lets it ground service choices, limits, and infrastructure-as-code in current AWS guidance rather than training-cutoff memory.
Throughout, you stay in control. At every gate the server requires your approval, the agent asks before assuming, and
current_phase.json keeps your place so you can resume in a later session exactly where you left off.
The rules-based alternative
If you'd rather not install anything, the rules-based distribution delivers the same workflow as steering files. The setup is a file copy.
1. Download and extract the rules. Grab the latest
ai-dlc-rules-v<version>.zip from the releases page and extract it. You get an aidlc-rules/ folder containing aws-aidlc-rules/ (the core workflow) and aws-aidlc-rule-details/ (detailed rules loaded on demand).2. Copy the rules into your project (macOS/Linux).
mkdir -p .kiro/steeringcp -R ~/Downloads/aidlc-rules/aws-aidlc-rules .kiro/steering/cp -R ~/Downloads/aidlc-rules/aws-aidlc-rule-details .kiro/
The repository README carries equivalent commands for Amazon Q Developer, Cursor, Cline, Claude Code, GitHub Copilot, and OpenAI Codex.
3. Verify the rules are loaded. Open the Steering panel in Kiro and confirm a
core-workflow entry under Workspace. In Kiro CLI, run /context show and look for .kiro/steering/aws-aidlc-rules .
With the rules-based path, run AI-DLC in Kiro's Vibe mode, not Spec mode. If Kiro nudges you to switch to Spec mode, choose No so the AI-DLC workflow stays in the driver's seat. To start, type your intent prefixed with
Using AI-DLC, ... and answer the structured questions the workflow writes to files.The rules-based distribution is also adaptive: it analyzes your request and proposes which stages to run and how deep to go. A one-line fix skips requirements analysis; a new service gets the full treatment. The mandatory stages are deliberately few, and everything else is conditional.

AI-DLC workflow phases and stages. Green boxes are mandatory, yellow boxes are conditional. Source: AWS DevOps Blog .
Customizing the workflow for your organization
One advantage of the MCP server is that customization is centralized. Every phase prompt lives in a single
prompts.py module, so you can encode your organization's standards once and have every tool call reflect the change deterministically — instead of editing scattered markdown and hoping the agent interprets it consistently. Common customizations include requiring a specific testing framework, injecting a security review step into Construction, or adding a mandatory acceptance-criteria format to Inception. Keep the approval gates and deliverable file locations intact, since later phases depend on them, and test changes against a sample project before rolling them out.
Tenets worth keeping in mind
AI-DLC states a few tenets that explain its design and set expectations:
- Methodology first. It is a methodology, not a tool. The rules-based path needs no install at all.
- Agnostic. It works with any IDE, agent, or model that supports rules or MCP.
- Reproducible. Rules and prompts are explicit enough that different models produce broadly similar outcomes.
- Human in the loop. Critical decisions require explicit confirmation. The agent proposes; the human approves.
As with any generative AI workflow, review the output and the costs your chosen model and agent generate. See the AWS Responsible AI Policy . The AI-DLC MCP server is sample code intended for learning and prototyping rather than production-grade workloads.
Getting started
- Read the AI-DLC methodology blog and, for depth, the Method Definition Paper .
- Install the AI-DLC MCP server and register it with Kiro — or copy the rules from
awslabs/aidlc-workflowsif you prefer the zero-install path.
- Attach one or two AWS MCP servers from
awslabs/mcpso the workflow can reason from current AWS facts.
- Open a chat, state your intent, and let the workflow guide you from intent to working software.
AI-DLC reframes the developer's job from typing code to steering it. Pair that discipline with the grounded reach of AWS MCP servers, and you get a workflow that moves fast, stays accurate, and keeps you in charge of the decisions that count.
References
- AI-Driven Development Life Cycle: Reimagining Software Engineering — AWS DevOps Blog
- Open-Sourcing Adaptive Workflows for AI-DLC — AWS DevOps Blog
- Building with AI-DLC using Amazon Q Developer — AWS DevOps Blog
- AI-Driven Development Lifecycle for Financial Services — AWS Industries Blog
- AI-DLC MCP server —
aws-samplespatterns repository
-
awslabs/aidlc-workflows— rules and steering files
-
awslabs/mcpand the AWS MCP servers catalog
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article