Flight505 MCP Dincoder

Driven Intent Negotiation — Contract-Oriented Deterministic Executable Runtime

The MCP implementation of GitHub's Spec Kit methodology — transforming specifications into executable artifacts

Table of Contents

• What is DinCoder?
• Installation
• Quickstart
• MCP Prompts (AI Workflow Orchestration)
• Complete Workflow
• Available Tools
• Examples
• Why Spec-Driven Development?
• Roadmap
• Contributing

🎯 What is DinCoder?

An official Model Context Protocol server implementing GitHub's Spec-Driven Development (SDD) methodology

DinCoder brings the power of GitHub Spec Kit to any AI coding agent through the Model Context Protocol. It transforms the traditional "prompt-then-code-dump" workflow into a systematic, specification-driven process where specifications don't serve code—code serves specifications.

What's New in v0.4.0 (Integration & Discovery Update)

🎯 MCP Prompts - AI Workflow Orchestration ✨

• 7 workflow prompts that guide AI agents through complex tasks
• Automatic discovery: AI agents find and use prompts programmatically
• Built-in guidance: Each prompt includes comprehensive workflow instructions
• Works everywhere: Claude Code, VS Code Copilot, OpenAI Codex, Cursor
• Natural language: Just describe what you want - AI uses appropriate prompts automatically

Available Prompts:

• start_project - Initialize new spec-driven project
• create_spec - Create feature specification
• generate_plan - Generate implementation plan
• create_tasks - Break down into actionable tasks
• review_progress - Generate progress report
• validate_spec - Check specification quality
• next_tasks - Show actionable tasks

Note: These are NOT slash commands you type. They're workflow templates that your AI agent uses automatically when you describe your goals!

🧬 Constitution Tool - Define Your Project's DNA

• New command: constitution_create
• Set project-wide principles, constraints, and preferences
• Ensures consistency across all AI-generated code

❓ Clarification Tracking - Systematic Q&A Management

• New commands: clarify_add, clarify_resolve, clarify_list
• Track ambiguities with unique IDs (CLARIFY-001, CLARIFY-002, etc.)
• Resolve uncertainties with rationale and audit trail

📦 Installation

🎯 Quick Decision Guide:

• Using Claude Code? → Install the Plugin (easier, includes slash commands & agents)
• Using VS Code/Codex/Cursor? → Install MCP Server Only (plugins not supported)

⚠️ Don't install both! The plugin automatically installs the MCP server - installing both may cause conflicts.

Prerequisites

• Node.js >= 20.0.0
• npm or pnpm
• An MCP-compatible coding assistant with automatic workspace binding (Cursor, Claude Code, Codex, etc.)

Installing via Smithery

To install DinCoder automatically via Smithery:

npx -y @smithery/cli install @flight505/mcp_dincoder

Claude Code / VS Code Users

claude mcp add dincoder -- npx -y mcp-dincoder@latest

Cursor

Configure the MCP server inside Cursor's MCP settings; once you select a project, Cursor injects the workspace path automatically.

Other MCP Clients

Install globally:

npm install -g mcp-dincoder@latest

Recommended clients: DinCoder expects the MCP client to bind the active project directory automatically so generated specs, plans, and tasks land in the repo you are working on. Cursor, Claude Code, and Codex do this for every request. Claude Desktop's chat UI does not, so commands default to the server's own install directory; only use Claude Desktop if you plan to pass workspacePath manually on each call.

📁 Where Files Are Created

Important: DinCoder creates all files in your current working directory (where you run your AI agent from).

your-project/
├── specs/                    # Created automatically
│   ├── 001-feature-name/    # Feature directory (auto-numbered)
│   │   ├── constitution.md  # Project principles (optional, recommended first step)
│   │   ├── spec.md          # Requirements & user stories
│   │   ├── plan.md          # Technical implementation plan
│   │   ├── tasks.md         # Executable task list
│   │   ├── research.md      # Technical decisions & research
│   │   ├── clarifications.json  # Q&A tracking
│   │   └── contracts/       # API contracts, data models
│   └── 002-next-feature/
└── .dincoder/               # Backward compatibility (legacy)

Tip: Launch your MCP client from the project root so every tool writes into the correct repo.

🚀 Quickstart

The Spec Kit Workflow

Transform ideas into production-ready code through three powerful commands:

1️⃣ /specify — Transform Ideas into Specifications

/specify Build a team productivity platform with Kanban boards and real-time collaboration

What happens:

• Automatic feature numbering (001, 002, 003...)
• Branch creation with semantic names
• Template-based specification generation
• Structured requirements with user stories
• Explicit uncertainty markers [NEEDS CLARIFICATION]

Output: A comprehensive PRD focusing on WHAT users need and WHY—never HOW to implement.

2️⃣ /plan — Map Specifications to Technical Decisions

/plan Use Next.js with Prisma and PostgreSQL, WebSockets for real-time updates

What happens:

• Analyzes feature specification
• Ensures constitutional compliance (architectural principles)
• Translates requirements to technical architecture
• Generates data models, API contracts, test scenarios
• Documents technology rationale

Output: Complete implementation plan with every decision traced to requirements.

3️⃣ /tasks — Generate Executable Task Lists

/tasks

What happens:

• Analyzes plan and contracts
• Converts specifications into granular tasks
• Marks parallelizable work [P]
• Orders tasks by dependencies
• Creates test-first implementation sequence

Output: Numbered task list ready for systematic implementation.

Real-World Example: Building a Chat System

1. Write PRD in document (2-3 hours)
2. Create design documents (2-3 hours)
3. Set up project structure (30 minutes)
4. Write technical specs (3-4 hours)
5. Create test plans (2 hours)

# Step 1: Create specification (5 minutes)
/specify Real-time chat with message history, user presence, and typing indicators

# Automatically creates:
# - Branch "003-real-time-chat"
# - specs/003-real-time-chat/spec.md with:
#   • User stories and personas
#   • Acceptance criteria
#   • [NEEDS CLARIFICATION] markers for ambiguities

# Step 2: Generate implementation plan (5 minutes)
/plan WebSocket for real-time, PostgreSQL for history, Redis for presence

# Generates:
# - plan.md with phased implementation
# - data-model.md (Message, User, Channel schemas)
# - contracts/websocket-events.json
# - contracts/rest-api.yaml
# - research.md with library comparisons

# Step 3: Create task list (5 minutes)
/tasks

# Produces executable tasks:
# 1. [P] Create WebSocket contract tests
# 2. [P] Create REST API contract tests
# 3. Set up PostgreSQL schema
# 4. Implement message persistence
# 5. Add Redis presence tracking
# ... (numbered, ordered, parallelizable)

🎯 MCP Prompts (AI Workflow Orchestration)

New in v0.4.0: DinCoder includes 7 MCP prompts that provide guided workflows for AI agents. These are NOT slash commands you type—they're workflow templates that your AI agent (Claude, Copilot, etc.) automatically discovers and uses to help you.

How MCP Prompts Work

MCP prompts are invisible to users but powerful for AI agents:

1. AI Discovery: When DinCoder is connected, your AI agent automatically discovers available prompts via the MCP protocol
2. AI Invocation: The AI agent invokes prompts programmatically when they're relevant to your task
3. Workflow Guidance: Each prompt includes comprehensive instructions for multi-step workflows
4. Tool Orchestration: Prompts guide the AI to call multiple DinCoder tools in the correct sequence

You don't "run" these prompts directly. Just describe what you want in natural language, and your AI agent will use the appropriate prompt workflow automatically!

Available Workflow Prompts