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

Example: How Prompts Guide AI Workflows

You say: "Let's start a new task manager project"

AI thinks: This matches the start_project prompt. Let me follow its workflow...

AI does:

1. Calls specify_start tool with projectName="task-manager"
2. Explains the .dincoder/ structure created
3. Asks what you want to build
4. Calls specify_describe with your requirements
5. Validates spec with spec_validate
6. Suggests next steps

You don't see: The prompt invocation—just the AI following the workflow naturally!

1. Call `specify_start` with projectName and agent type
2. Explain .dincoder/ directory structure to user
3. Explain spec-driven workflow: Specify → Plan → Execute
4. Ask what they want to build
5. Guide through specification creation

1. Check if .dincoder/ exists (run specify_start if not)
2. Gather requirements by asking:
   - What problem does this solve?
   - Who are the users?
   - What are success criteria?
   - What's out of scope?
3. Call `specify_describe` with complete specification
4. Call `spec_validate` to check quality
5. Address validation issues with `spec_refine`
6. Confirm spec is complete

1. Verify spec exists (guide user to create if missing)
2. Run `spec_validate` if not already validated
3. Call `plan_create` with technical constraints
4. Call `artifacts_analyze` to verify spec-plan alignment
5. Present plan structure to user
6. Ask if ready for task generation

1. Verify plan exists (guide to create if missing)
2. Call `tasks_generate` with granular scope
3. Call `tasks_visualize` to show dependency graph
4. Call `tasks_stats` to show effort estimates
5. Call `tasks_filter` with preset:"next" for actionable items
6. Guide user to start first task

1. Call `tasks_stats` with charts and blockers
2. Call `tasks_filter` preset:"next" for actionable items
3. Call `tasks_search` for in-progress tasks
4. Summarize in structured format:
   - Overall completion %
   - Recent accomplishments
   - Current work
   - Next actions (unblocked)
   - Blockers
   - Recommendations
5. Include visual progress charts

1. Call `spec_validate` with all checks enabled
2. Check for:
   - Completeness (all required sections)
   - Acceptance criteria (testable when/then)
   - Clarifications (no unresolved markers)
   - Implementation leakage (no HOW in WHAT)
3. Call `clarify_list` for pending questions
4. If validation fails:
   - List specific issues
   - Call `spec_refine` to fix
   - Re-validate
5. If passes: suggest `plan_create` next

1. Call `tasks_filter` with preset:"next" and priority sorting
2. For each task display:
   - Task ID and description
   - Metadata (phase, type, priority, effort)
   - Why it's actionable
3. Recommend which task to start based on:
   - Priority level
   - Dependencies completed
   - Effort estimate
4. Offer task details on request

Platform Compatibility

MCP prompts work across all MCP-compatible clients:

The Key Difference: MCP Prompts vs Slash Commands

Important distinction:

• MCP Prompts (DinCoder workflows): AI agents use these programmatically. You don't type them.
• Slash Commands (Native): User-typed commands like /help, /clear in Claude Code
• Custom Commands (.claude/commands/): Project-specific slash commands you create

In practice: You describe what you want in natural language ("Let's start a new project"), and your AI agent automatically uses the appropriate MCP prompt workflow!

🔌 Claude Code Plugin (Recommended for Claude Code)

New in v0.5.0: For the best Claude Code experience, install the DinCoder Plugin which bundles slash commands, specialized agents, and automatically installs the MCP server.

⚠️ Important: The plugin includes the MCP server - you don't need to install both! Choose one installation method:

• Plugin (Claude Code only) → Slash commands + agents + MCP server (all-in-one)
• MCP Server only (VS Code, Codex, etc.) → Just the tools (manual setup required)

Prerequisites

Before installing the plugin:

• ✅ Claude Code version 2.0.13 or higher
• ✅ Node.js >= 18
• ✅ npm installed

Installation

Step 1: Add the DinCoder marketplace

# In Claude Code
/plugin marketplace add flight505/dincoder-plugin

Step 2: Install the plugin

/plugin install dincoder

Step 3: Restart Claude Code

• Press Cmd+Q (Mac) or Alt+F4 (Windows) to quit, then reopen
• Or use Cmd/Ctrl+Shift+P → "Developer: Reload Window"

Verify Installation

After restart, check that:

• Slash commands appear: /spec, /plan, /tasks, /progress, /validate, /next
• Agents appear: @spec-writer, @plan-architect, @task-manager
• MCP server is active in Settings → Extensions → MCP Servers

What's Included

✨ Slash Commands - Quick access without memorizing tool names

• /spec - Create or refine specification
• /plan - Generate implementation plan
• /tasks - Break down into actionable tasks
• /progress - View progress report
• /validate - Check spec quality
• /next - Show next actionable tasks

🤖 Specialized Agents - Expert assistance for each phase

• @spec-writer - Expert at creating validated specifications
• @plan-architect - Expert at designing technical plans
• @task-manager - Expert at managing tasks and progress

🔧 Automatic MCP Server - Installs and configures mcp-dincoder@latest from npm automatically

• Runs npx -y mcp-dincoder@latest on installation
• Always pulls the latest version for bug fixes and features
• No manual MCP server setup needed!

📝 Built-in Documentation - CLAUDE.md loads automatically with methodology guide

Plugin vs MCP Server Only

Choose Your Installation Method:

• Claude Code users: Use the plugin (recommended) - get slash commands, agents, and MCP server in one package
• VS Code/Codex users: Use the MCP server only (plugins not supported on these platforms)

⚠️ Avoid Dual Installation: If you're using the plugin, do NOT also manually configure the MCP server in your MCP settings. The plugin handles this automatically and doing both may cause conflicts.

Plugin Repository: flight505/dincoder-plugin

🔌 VS Code + GitHub Copilot Integration

New in v0.6.0: Full support for VS Code with GitHub Copilot integration through MCP.

Quick Setup

1. Copy template files to your project:

   cp -r templates/vscode/.vscode your-project/
   cp -r templates/vscode/.github your-project/
   

2. Open project in VS Code:

   cd your-project
   code .
   

3. Reload window:

   • Press Cmd+Shift+P (Mac) or Ctrl+Shift+P (Windows/Linux)
   • Run: Developer: Reload Window

4. Verify setup:

   • Open Copilot Chat
   • Click tools icon
   • Verify "dincoder" appears in tools list

Using DinCoder with Copilot

In Copilot Chat, use MCP prompts or reference tools directly:

/mcp.dincoder.start_project my-app
/mcp.dincoder.create_spec "Build a task management API"
#dincoder.tasks_stats

What's Included

✨ Template Files:

• .vscode/mcp.json - MCP server configuration
• .vscode/settings.json - VS Code MCP settings
• .github/copilot-instructions.md - Context for GitHub Copilot

📖 Comprehensive Guide: docs/integration/vscode.md

🎯 Ready-to-Use Templates: templates/vscode/

🔌 OpenAI Codex Integration

New in v0.6.0: Full support for OpenAI Codex (CLI and IDE extension) through MCP.

Quick Setup (CLI - Recommended)

# Add DinCoder MCP server
codex mcp add dincoder -- npx -y mcp-dincoder@latest

# Verify
codex mcp list

Quick Setup (Manual Configuration)

1. Copy global config:

   cp templates/codex/config.toml ~/.codex/config.toml
   

2. Copy workspace instructions:

   cp templates/codex/.codex your-project/
   

3. Restart Codex:

   # CLI: Restart terminal
   # IDE: Reload window
   

Using DinCoder with Codex

CLI Commands:

codex "use /mcp.dincoder.start_project my-app"
codex "use /mcp.dincoder.create_spec 'Build a REST API'"

IDE Extension:

@dincoder.specify_start
@dincoder.tasks_filter preset="next"

What's Included

✨ Template Files:

• config.toml - Codex MCP server configuration (for ~/.codex/config.toml)
• .codex/instructions.md - Workspace-specific instructions

📖 Comprehensive Guide: docs/integration/codex.md

🎯 Ready-to-Use Templates: templates/codex/

🚦 Complete Workflow Guide

This is your end-to-end guide for using DinCoder with any AI agent (Claude, Copilot, Gemini, Cursor).

Step-by-Step: From Idea to Implementation

0️⃣ Define Project Constitution (Optional but Recommended, 2-3 minutes)

// In your AI agent's chat:
"Use constitution_create to define principles for 'task-manager' with these details:

Principles:
- Prefer functional programming over OOP
- Write tests before implementation (TDD)
- Keep bundle size under 500KB

Constraints:
- Node.js >= 20.0.0 required
- Maximum 3 external dependencies for core functionality

Preferences:
- Libraries: React Query over Redux, Zod for validation
- Patterns: Repository pattern for data access"

// What happens:
// ✓ Creates specs/001-task-manager/ directory
// ✓ Generates constitution.md with structured principles
// ✓ All future specs/plans will respect these constraints

Why use this: Constitution ensures consistency across your entire project. AI agents will reference these principles when generating specs and plans.

1️⃣ Start a New Project (1 minute)

"Use specify_start to initialize a new project called 'task-manager' with claude agent"

// What happens:
// ✓ Creates specs/001-task-manager/ directory
// ✓ Generates spec.md template
// ✓ Creates contracts/ folder
// ✓ Initializes research.md

2️⃣ Describe What You Want (2-5 minutes)

"Use specify_describe with this description:
Build a task management system where users can:
- Create tasks with titles, descriptions, and due dates
- Organize tasks into projects
- Mark tasks as complete
- Filter by status and project
- Get daily summary emails"

// What happens:
// ✓ Updates spec.md with user stories
// ✓ Adds acceptance criteria
// ✓ Marks uncertainties with [NEEDS CLARIFICATION]
// ✓ Separates WHAT from HOW

Pro tip: Be specific about user needs, not implementation. Focus on what users want and why they need it.

3️⃣ Track Clarifications (Optional)

// If you notice ambiguities while writing specs:
"Use clarify_add with this question:
'Should task due dates support time zones or just dates?'
with context 'Task scheduling requirements'"

// Later, when you have an answer:
"Use clarify_resolve for CLARIFY-001 with resolution:
'Use UTC timestamps with user timezone preference.'"

// Check all clarifications:
"Use clarify_list to see all pending clarifications"

4️⃣ Generate Technical Plan (2-5 minutes)

"Use plan_create with these constraints:
- Next.js 14 with App Router
- PostgreSQL with Prisma ORM
- tRPC for type-safe APIs
- Tailwind CSS for styling"

// What happens:
// ✓ Creates plan.md with phased approach
// ✓ Generates data-model.md (Task, Project, User schemas)
// ✓ Updates research.md with architecture decisions
// ✓ Enforces constitutional compliance

5️⃣ Create Implementation Tasks (2-5 minutes)

"Use tasks_generate with scope 'MVP - core task management'"

// What happens:
// ✓ Creates tasks.md with numbered, ordered tasks
// ✓ Marks parallelizable tasks with [P]
// ✓ Orders by dependency (contracts → tests → implementation)

6️⃣ Implement Systematically

// Start with first task
"Let's implement T001 - Create Prisma schema for Task model"

// After completing a task
"Use tasks_tick with taskId 'T001'"

// See what's next
"Use artifacts_read with artifactType 'tasks'"

🎯 Best Practices

1. Start Small: Begin with MVP scope, add features iteratively
2. Follow the Order: Specify → Plan → Tasks → Implement
3. Review Specs: Always read the generated spec.md and refine it
4. Track Progress: Use tasks_tick consistently
5. Document Decisions: Use research_append for architecture choices

🛠 Available Tools

🎯 Core Spec-Driven Development Tools

DinCoder implements the complete Spec Kit workflow through these MCP tools:

Phase 1: SPECIFY — Create Living Specifications

Phase 2: PLAN — Map Specifications to Architecture

Phase 3: TASKS — Generate Executable Work Items

Phase 4: IMPLEMENT — Build With Validation

📚 Examples

Connect with TypeScript Client

import { Client } from '@modelcontextprotocol/sdk/client/index.js';
import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/transport/streamable-http.js';

const transport = new StreamableHTTPClientTransport({
  url: new URL('http://localhost:3000/mcp'),
});

const client = new Client({
  name: 'my-client',
  version: '1.0.0',
});

await client.connect(transport);

// Use tools
const result = await client.callTool('specify_describe', {
  description: 'A task management API',
});

See examples/ for complete examples:

• local-client.ts - Connect to local server
• spec-workflow.md - Complete spec-driven workflow

💡 Why Spec-Driven Development?

TL;DR: Specifications are executable contracts that generate consistent, maintainable code. Change the spec → regenerate the implementation. No more "vibe coding."

For decades, code has been king. Specifications were scaffolding—built, used, then discarded. Spec-Driven Development inverts this power structure:

• Specifications Generate Code: The PRD isn't a guide—it's the source that produces implementation
• Executable Specifications: Precise, complete specs that eliminate the gap between intent and implementation
• Code as Expression: Code becomes the specification's expression in a particular language/framework
• Living Documentation: Maintain software by evolving specifications, not manually updating code

This transformation is possible because AI can understand complex specifications and implement them systematically. But raw AI generation without structure produces chaos. DinCoder provides that structure through GitHub's proven Spec Kit methodology.

Why This Matters Now

Three converging trends make SDD essential:

1. AI Threshold: LLMs can reliably translate natural language specifications to working code
2. Complexity Growth: Modern systems integrate dozens of services—manual alignment becomes impossible
3. Change Velocity: Requirements change rapidly—pivots are expected, not exceptional

Traditional development treats changes as disruptions. SDD transforms them into systematic regenerations. Change a requirement → update affected plans → regenerate implementation.

Read the full philosophy: Why Spec-Driven Development?

🗺 Roadmap

DinCoder is actively evolving! We're at v0.4.0 with 28/36 stories complete (78%).

Current Phase: Phase 3 - Advanced Task Management (In Progress)

Upcoming Features:

• Advanced task management (filtering, search, statistics)
• Multi-feature project support
• Enhanced collaboration features
• External integrations (Jira, Linear, GitHub Issues)

Vote on features and view the complete roadmap: docs/ROADMAP.md

🤝 Contributing

We welcome contributions from the community! Whether you have:

• Feature ideas or requests - Share your vision for new Spec Kit tools
• Bug reports - Help us identify and fix issues
• Template improvements - Enhance the Spec Kit templates
• Tool enhancements - Extend the MCP server capabilities
• Documentation updates - Improve guides and examples

Get Started:

1. Open an issue to discuss your idea
2. Fork the repository and create a feature branch
3. For development: git clone, npm install, npm run build, npm test
4. Submit a pull request with your improvements

We appreciate all contributions, big or small!

📄 License

MIT License - see LICENSE file for details.

📚 References

• Model Context Protocol Specification
• Spec Kit Documentation
• MCP TypeScript SDK

🙏 Acknowledgments

• Model Context Protocol by Anthropic
• Spec Kit for spec-driven development methodology