A Claude Code plugin for the AI-DLC (AI-Driven Development Life Cycle) methodology — bringing structured, adaptive software development to Claude Code through the marketplace.
/plugin marketplace add letsur-laboratory/aidlc-claude
/plugin install aidlc-claude@letsur-aidlc
git clone git@github.com:letsur-laboratory/aidlc-claude.git
claude --plugin-dir ./aidlc-claudeStart a workflow:
/aidlc-claude:aidlc build a REST API for task management
Or start interactively:
/aidlc-claude:aidlc
The plugin automatically detects existing AIDLC sessions — if aidlc-docs/aidlc-state.md exists in your project, it will offer to resume where you left off.
AI-DLC is an AI-driven software development methodology created by AWS. It provides a structured yet adaptive workflow that guides AI assistants through the full software development lifecycle — from requirements gathering to code generation and testing.
- Adaptive Execution: 13 stages across 3 phases, with only 5 mandatory — the rest are conditionally executed based on project complexity, scope, and risk
- Human-in-the-Loop: Every stage (except Workspace Detection) requires explicit user approval before proceeding. The AI cannot skip ahead
- Overconfidence Prevention: Built-in rules force the AI to ask clarifying questions when requirements are ambiguous, rather than making assumptions
- Artifact-Based Communication: Stages communicate through structured Markdown files in
aidlc-docs/, not through in-memory state — enabling multi-session workflows - Abstraction Level Descent: The workflow progressively moves from "what and why" (Inception) to "how" (Construction), from technology-agnostic design down to concrete code generation
- Extension System: Optional rule sets (e.g., Security Baseline, Property-Based Testing) can be opted into per project, with blocking enforcement on violations
User Request
|
v
+---------------------------------------+
| INCEPTION PHASE |
| Planning & Architecture |
+---------------------------------------+
| * Workspace Detection (ALWAYS) |
| * Reverse Engineering (BROWNFIELD) |
| * Requirements Analysis (ALWAYS) |
| * User Stories (CONDITIONAL) |
| * Workflow Planning (ALWAYS) |
| * Application Design (CONDITIONAL) |
| * Units Generation (CONDITIONAL) |
+---------------------------------------+
|
v
+---------------------------------------+
| CONSTRUCTION PHASE |
| Design, Code & Test |
+---------------------------------------+
| * Per-Unit Loop: |
| - Functional Design (CONDITIONAL) |
| - NFR Requirements (CONDITIONAL) |
| - NFR Design (CONDITIONAL) |
| - Infra Design (CONDITIONAL) |
| - Code Generation (ALWAYS) |
| * Build and Test (ALWAYS) |
+---------------------------------------+
|
v
+---------------------------------------+
| OPERATIONS PHASE |
| (Placeholder for future) |
+---------------------------------------+
AI-DLC is defined through 30 Markdown rule files organized into:
| Category | Files | Purpose |
|---|---|---|
| Core Workflow | 1 | Master orchestrator — defines phase order, stage conditions, mandatory rules |
| Common | 11 | Cross-cutting concerns — question format, content validation, error handling, overconfidence prevention, session continuity |
| Inception | 7 | Planning stage rules — workspace detection, requirements, user stories, workflow planning, application design, units generation |
| Construction | 6 | Implementation stage rules — functional design, NFR, infrastructure, code generation, build & test |
| Extensions | 4 | Optional rule sets — security baseline (opt-in + rules), property-based testing (opt-in + rules) |
| Pattern | Where Used | Description |
|---|---|---|
| Q&A Gate | 8 stages | Questions → wait for answers → analyze for ambiguity → follow-up if needed |
| 2-Part (Plan → Generate) | User Stories, Units Generation, Code Generation | Get plan approved first, then execute |
| Adaptive Depth | All stages | Stage selection is binary (run/skip), but detail level adapts continuously to complexity |
| Per-Unit Loop | Construction | Design-through-code cycle repeats per unit of work |
| Lazy Loading | Extensions, Rule Files | Load only when needed to conserve context window |
| Blocking Finding | Extension-enabled stages | Rule violations remove the "Continue" option entirely |
| Triple State Tracking | All stages | aidlc-state.md (workflow) + plan checkboxes (stage) + audit.md (audit trail) |
The original AI-DLC rules are designed for Kiro's "steering" model where rules are auto-loaded. Claude Code uses a different model — plugins provide skills that are invoked explicitly. This plugin bridges that gap with minimal adaptation:
| Aspect | Kiro (Original) | Claude Code (This Plugin) |
|---|---|---|
| Entry point | Rules auto-loaded on start | /aidlc-claude:aidlc skill invocation |
| Q&A | File-based only ("never ask in chat") | Chat for simple, file for complex question sets |
| Session resume | Auto-detected by IDE | settings.json system prompt detects aidlc-state.md |
| Rule files | Unchanged | Unchanged (used as-is) |
| Artifacts | aidlc-docs/ |
aidlc-docs/ (identical) |
| State tracking | aidlc-state.md |
aidlc-state.md (identical) |
| Extensions | opt-in mechanism | opt-in mechanism (identical) |
The original rule files are included without any modification. The adaptation layer lives entirely in skills/aidlc/SKILL.md.
.
├── .claude-plugin/
│ ├── plugin.json # Plugin manifest
│ └── marketplace.json # Marketplace registry
│
├── .aidlc-rules/ # Original core workflow (from upstream)
│ └── core-workflow.md
│
├── .aidlc-rule-details/ # Original rule details (from upstream)
│ ├── common/ # 11 cross-cutting rule files
│ ├── inception/ # 7 inception stage rules
│ ├── construction/ # 6 construction stage rules
│ ├── operations/ # 1 placeholder
│ └── extensions/ # 4 extension files (opt-in + rules)
│
├── skills/
│ └── aidlc/
│ └── SKILL.md # Workflow engine — the adaptation layer
│
├── settings.json # Session detection system prompt
└── README.md
During execution, AIDLC produces artifacts in aidlc-docs/ within the user's project. Application code goes to the workspace root.
aidlc-docs/
├── aidlc-state.md # Workflow state (enables session resume)
├── audit.md # Full audit trail of all interactions
├── inception/
│ ├── reverse-engineering/ # Brownfield analysis (if applicable)
│ ├── requirements/ # Requirements + verification questions
│ ├── user-stories/ # Stories + personas
│ ├── application-design/ # Components, services, units
│ └── plans/ # Execution plans
└── construction/
├── plans/ # Per-unit design/code plans
├── {unit-name}/ # Per-unit design artifacts
│ ├── functional-design/
│ ├── nfr-requirements/
│ ├── nfr-design/
│ ├── infrastructure-design/
│ └── code/ # Markdown summaries (not app code)
└── build-and-test/ # Build + test instructions
Rule files are sourced from awslabs/aidlc-workflows aidlc-rules/ directory.
# From a clone of awslabs/aidlc-workflows
cp -r aidlc-rules/aws-aidlc-rules/* .aidlc-rules/
cp -r aidlc-rules/aws-aidlc-rule-details/* .aidlc-rule-details/The plugin wrapper (skills/aidlc/SKILL.md, settings.json) does not need updating unless the upstream rule structure changes.
- AI-DLC methodology and rules: awslabs/aidlc-workflows (Apache 2.0)
- This plugin is an independent adaptation for Claude Code by Letsur Laboratory
Apache-2.0