AWS Builder Center
From Intent to Software: Running the AI-DLC MCP Server in Kiro

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.

The AI-DLC mental model. Source:  AWS DevOps Blog .
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.

The three phases of AI-DLC. Source:  AWS DevOps Blog .
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-aws
cd sample-ai-powered-sdlc-patterns-with-aws/all-phases/all-phases-aidlc-mcp
pip 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 that
decides 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/steering
cp -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 .

AI-DLC rules loaded in Kiro. Source:   awslabs/aidlc-workflows  .
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

  1. Read the  AI-DLC methodology blog  and, for depth, the  Method Definition Paper .
  1. Install the  AI-DLC MCP server  and register it with Kiro — or copy the rules from   awslabs/aidlc-workflows   if you prefer the zero-install path.
  1. Attach one or two AWS MCP servers from   awslabs/mcp   so the workflow can reason from current AWS facts.
  1. 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

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