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:

Claude Code / VS Code Users

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:

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).

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

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

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

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

Traditional Approach (12+ hours of documentation)

SDD with DinCoder (15 minutes total)

Result: Complete, executable specifications ready for any AI agent to implement.

🎯 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

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. start_project - Initialize New Spec-Driven Project

AI receives this workflow when you want to start a project:

Example conversation:

• You: "I want to start a new e-commerce project"

• AI: Invokes start_project prompt, follows workflow

• AI: "I'll initialize a new spec-driven project. What features should the e-commerce platform have?"

2. create_spec - Create Feature Specification

AI receives this workflow when you describe a feature:

Example conversation:

• You: "Build a real-time chat feature with typing indicators"

• AI: Invokes create_spec prompt, asks clarifying questions

• AI: "Let me create a specification. Should the chat support file attachments?"

3. generate_plan - Generate Implementation Plan

AI receives this workflow when planning is needed:

Example conversation:

• You: "How should we implement this?"

• AI: Invokes generate_plan prompt

• AI: "I'll create a technical plan. What's your preferred tech stack? (Next.js, Python/FastAPI, etc.)"

4. create_tasks - Break Down into Actionable Tasks

AI receives this workflow for task generation:

Example conversation:

• You: "Let's break this down into tasks"

• AI: Invokes create_tasks prompt

• AI: "I've generated 23 tasks. Here's the dependency graph... Ready to start with T001?"

5. review_progress - Generate Progress Report

AI receives this workflow for progress checks:

Example conversation:

• You: "How's the project coming along?"

• AI: Invokes review_progress prompt

• AI: "We're 67% complete (15/23 tasks). 3 tasks in progress, 2 blocked. Next up: authentication tests."

6. validate_spec - Check Specification Quality

AI receives this workflow for validation:

Example conversation:

• You: "Is the spec ready for implementation?"

• AI: Invokes validate_spec prompt

• AI: "Validation found 2 issues: missing edge cases section, 1 unresolved clarification. Let me fix these..."

7. next_tasks - Show Next Actionable Tasks

AI receives this workflow when you ask what's next:

Example conversation:

• You: "What should I work on next?"

• AI: Invokes next_tasks prompt

• AI: "Top priority: T007 (Implement user authentication, effort: 5). It's unblocked and high priority. Want to start?"

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

Step 2: Install the plugin

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:

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)

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:

IDE Extension:

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)

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)

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

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

3️⃣ Track Clarifications (Optional)

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

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

6️⃣ Implement Systematically

🎯 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

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