MCP Agentic SDLC

A comprehensive framework for managing software development lifecycle with AI agents, combining structured development processes with intelligent workflow management.

Overview

MCP Agentic SDLC consists of two main components:

1. Agentic Software Development Lifecycle (ASDLC) - ASDLC.md

   • AI-Human collaborative development process
   • Structured development phases with agentic integration
   • Continuous feedback loops
   • Balanced responsibility distribution

2. Agentic Workflow Protocol (AWP) - AWP.md

   • Human-AI collaboration workflow
   • Context management
   • Progress tracking
   • Standardized procedures

New to MCP Agentic SDLC? Start with workflow.md for a comprehensive explanation of the server architecture, workflow, and how all components work together.

Live Kanban quickstart

After running the init tool, the Kanban board starts automatically at http://localhost:4173 (Cursor Simple Browser when available, otherwise your system browser). Markdown under backlog-<name>/ stays the source of truth; the board is a live read-only compile.

To start manually:

cd agentic-sdlc/kanban && npm run watch

• backlog_sync MCP tool — recompile kanban/backlog.json from task markdown (pass startTaskId / completeTaskId when starting or finishing tasks)
• backlog://<name>/snapshot — agent-readable compiled state
• Kanban toolbar — copy-paste AWP commands (awp refine, awp start, awp test, awp fix, awp next, awp auto, …)

See workflow.md — Section 11 for column rules, agent commits panel, time tracking, and backlog-complete flow.

Architecture

graph TB
    subgraph MCP["MCP Agentic SDLC"]
        direction TB
        
        subgraph ASDLC["Agentic Software Development Lifecycle"]
            direction LR
            ProblemDef["Problem Definition"]
            Design["Design Phase"]
            Development["Development Phase"]
            Testing["Testing Phase"]
            Deployment["Deployment Phase"]
            Maintenance["Maintenance Phase"]
            
            ProblemDef --> Design
            Design --> Development
            Development --> Testing
            Testing --> Deployment
            Deployment --> Maintenance
            Maintenance -.-> ProblemDef
            
            subgraph Core["Collaboration Core"]
                AIAgent["AI Agent"]
                Human["Human"]
                AIAgent -.-> Human
                Human -.-> AIAgent
            end
            
            Core -.-> ProblemDef
            Core -.-> Design
            Core -.-> Development
            Core -.-> Testing
            Core -.-> Deployment
            Core -.-> Maintenance
        end
        
        subgraph AWP["Agentic Workflow Protocol"]
            direction LR
            Context["Context Management"]
            Workflow["Workflow Tracking"]
            Collab["Human-AI Collaboration"]
            Procedures["Standard Procedures"]
            
            Context --> Workflow
            Workflow --> Collab
            Collab --> Procedures
            Procedures --> Context
        end
        
        subgraph Integration["Integration Layer"]
            direction LR
            Docs["Documentation Sync"]
            Progress["Progress Tracking"]
            Handoff["Task Handoff"]
            Quality["Quality Gates"]
        end
        
        ASDLC <--> Integration
        AWP <--> Integration
    end
    
    HumanUser((Human)) <--> MCP
    AISystem((AI Agent)) <--> MCP

Getting Started

Quick Start with MCP Tools

1. Call the base tool to start project setup:

   • Provide backlog name (e.g., "ecommerce", "crm")
   • Choose project type: MVP, POC, or Full/Pro
   • Answer type-specific questions (or say "I don't know" / "AI" for recommendations)

2. Review AI recommendations (if any):

   • AI generates recommendations for missing elements
   • Review and confirm or modify recommendations

3. Call the base tool again with all confirmed parameters:

   • Pass userSource (user's first message) and/or userSourceFile (e.g. idea1.md)
   • Creates user.md (raw user input) and base.md (AWP Project Foundation Agreement) in backlog-<name>/<type>/

4. Call the init tool to create project structure:

   • Reads existing base.md (does not overwrite it)
   • Generates populated requirements.md, backlog.md, tech-specs.md, and root AWP.md
   • Creates initial tasks from base.md phases (enriched from user.md when comprehensive)
   • Scaffolds agentic-sdlc/kanban/ and opens the live board

Project Structure

After initialization, your project will have:

agentic-sdlc/
├── backlog-<name>/
│   └── <type>/          # mvp, poc, or pro
│       ├── user.md              # Raw user input (before base.md)
│       ├── base.md              # AWP Project Foundation Agreement
│       ├── requirements.md      # Project requirements
│       ├── backlog.md           # Project backlog
│       ├── tech-specs.md        # Technical specifications
│       └── tasks/
│           ├── planned/         # Active tasks
│           ├── unplanned/       # Unplanned tasks (U- prefix)
│           └── completed/       # Completed tasks
├── kanban/                      # Live board (generated by init)
│   ├── index.html
│   ├── backlog.json             # Compiled from markdown
│   ├── activity.json
│   ├── time-tracking.json
│   ├── .kanban-config.json
│   └── KANBAN.md
├── README.md
├── ASDLC.md
├── AWP.md
└── commitStandard.md

Documentation

1. Read ASDLC.md for the agentic development lifecycle framework
2. Read AWP.md for the workflow protocol
3. Check the src/recipes/ directory for methodology recipes

Features

MCP Tools

• base - Collects project requirements with intelligent question flow

  • Supports MVP, POC, and Full/Pro project types
  • Type-specific questions tailored to project approach
  • "I don't know" / "AI" support for missing elements

• recommend - Generates AI recommendations for missing project elements

  • Based on foundational information and best practices
  • Presents recommendations for user review before proceeding

• init - Creates complete project structure

  • Reads base.md (created by base tool in MODE 2)
  • Generates populated requirements, backlog, tech specs, and root AWP.md
  • Sets up task structure following recipe methodologies
  • Scaffolds Kanban viewer and opens the live board

• backlog_sync - Recompiles Kanban JSON from markdown task files

  • Optional startTaskId / completeTaskId for status moves
  • Writes activity.json and time-tracking.json alongside backlog.json

• get_*_recipe - Returns recipe content (backlog, requirements, tech specs, AWP)

  • Also available as MCP resources: recipe://mvp-backlog-recipe, recipe://awp-recipe, etc.

Project Types

• MVP (Minimum Viable Product) - Production-ready, MVP-scoped features
• POC (Proof of Concept) - Proof-focused, concept validation
• Full/Pro - Complete project with all features

Recipe System

Comprehensive recipes for each project type:

• *-backlog-recipe.md - Backlog creation methodology
• *-requirements-recipe.md - Requirements documentation
• *-tech-specs-recipe.md - Technical specifications

Core Features

• Structured development process
• Clear human-AI collaboration guidelines
• Context preservation mechanisms
• Standardized commit messages (feat, fix, test, … — see commitStandard.md)
• Live Kanban board with board progress, time tracking, and agent commits panel
• AWP command bar for awp refine, awp start, awp test, awp fix, awp next, awp auto
• Documentation synchronization
• Framework-agnostic (works with Scrum, Kanban, Waterfall, etc.)
• Topic-agnostic (applies to any project type)

Documentation

• docs/workflow.md - Start here! Comprehensive guide to understanding the MCP server architecture, workflow, and how all components work together
• ASDLC.md - Agentic Software Development Lifecycle documentation
• AWP.md - Agentic Workflow Protocol documentation
• docs/mcp-config.md - Example MCP server configuration for Cursor and Claude Desktop
• src/recipes/ - Methodology recipes for backlog, requirements, and tech specs
  • MVP recipes: mvp-backlog-recipe.md, mvp-requirements-recipe.md, mvp-tech-specs-recipe.md
  • POC recipes: poc-backlog-recipe.md, poc-requirements-recipe.md, poc-tech-specs-recipe.md
  • Pro recipes: pro-backlog-recipe.md, pro-requirements-recipe.md, pro-tech-specs-recipe.md
  • AWP recipe: awp-recipe.md

Workflow

Step 1: Project Setup (base tool)

1. Provide backlog name
2. Choose project type (MVP/POC/Pro)
3. Answer type-specific questions:
   • Foundational questions (required)
   • Derivable questions (can say "I don't know" or "AI")

Step 2: Review Recommendations (if needed)

If you said "I don't know" or "AI" for any questions:

1. AI generates recommendations using recommend tool
2. Review recommendations
3. Accept, modify, or reject recommendations

Step 3: Create Foundation (base tool, MODE 2)

1. AI calls base with all confirmed parameters
2. Creates base.md - AWP Project Foundation Agreement (reference document)

Step 4: Project Creation (init tool)

1. AI calls init with backlog name and project type
2. init reads base.md (created earlier by base tool) and generates:
   • requirements.md - Complete requirements
   • backlog.md - Project backlog
   • tech-specs.md - Technical specifications
   • AWP.md - Workflow protocol (at agentic-sdlc/ root)
   • tasks/ - Task structure

Step 5: Development

After init, pick an AWP command (agent should ask):

Follow the recipes and AWP.md for ongoing development. Use backlog_sync so Kanban stays in sync with task markdown.

Contributing

Contributions are welcome! Please read our contributing guidelines and code of conduct.

License

This project is licensed under the MIT License - see the LICENSE file for details.

Author

Michael Wybraniec