ai.smithery/flight505-mcp_dincoder

Official

by flight505 · TypeScript

Driven Intent Negotiation — Contract-Oriented Deterministic Executable Runtime DinCoder brings the…

Execute contract-oriented deterministic code through intent negotiation and runtime execution.

Driven Intent Negotiation — Contract-Oriented Deterministic Executable Runtime

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

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:

bash

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

Claude Code / VS Code Users

bash

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:

bash

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

bash

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

bash

/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

bash

/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

bash

/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

<details> <summary><strong>See how SDD transforms traditional development (click to expand)</strong></summary>

Traditional Approach (12+ hours of documentation)

text

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)

SDD with DinCoder (15 minutes total)

bash

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

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

</details>

🎯 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:

AI Discovery: When DinCoder is connected, your AI agent automatically discovers available prompts via the MCP protocol
AI Invocation: The AI agent invokes prompts programmatically when they're relevant to your task
Workflow Guidance: Each prompt includes comprehensive instructions for multi-step workflows
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

Prompt Name	When AI Uses It	What It Does
`start_project`	You ask to "start a new project"	Initializes .dincoder/, creates spec template
`create_spec`	You describe a feature to build	Generates comprehensive specification
`generate_plan`	You ask for implementation plan	Creates technical architecture from spec
`create_tasks`	You ask to break down work	Generates executable task list from plan
`review_progress`	You ask "how's it going?"	Shows statistics, charts, next actions
`validate_spec`	You ask to check spec quality	Runs quality gates before implementation
`next_tasks`	You ask "what's next?"	Shows unblocked, actionable tasks

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:

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

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

<details> <summary><strong>See detailed prompt workflows (click to expand)</strong></summary>

1. `start_project` - Initialize New Spec-Driven Project

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

code

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

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:

code

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

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:

code

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

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:

code

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

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:

code

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

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:

code

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

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:

code

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

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?"

</details>

Platform Compatibility

MCP prompts work across all MCP-compatible clients:

Client	How It Works
Claude Code	Prompts auto-discovered; AI uses them automatically when relevant
VS Code Copilot	Prompts available in agent mode; AI invokes based on context
OpenAI Codex	Prompts accessible via MCP protocol; AI uses for complex workflows
Cursor	MCP prompts integrated into agent workflows

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

bash

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

Step 2: Install the plugin

bash

/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

Feature	Plugin (Claude Code)	MCP Server Only (VS Code/Codex)
Platform	Claude Code 2.0.13+	VS Code, Codex, Cursor, etc.
Slash Commands	✅ `/spec`, `/plan`, etc.	❌ Not supported (plugins only)
Specialized Agents	✅ `@spec-writer`, etc.	❌ Not supported (plugins only)
MCP Tools	✅ 30+ tools (auto-installed)	✅ 30+ tools (manual install)
Installation	✅ Two commands (`marketplace add` + `install`)	⚠️ Manual `.mcp.json` config
MCP Server Updates	✅ Auto (uses `@latest`)	⚠️ Manual version bump

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

Copy template files to your project:

bash

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

Open project in VS Code:
bash
```
cd your-project
code .
```
Reload window:
- Press Cmd+Shift+P (Mac) or Ctrl+Shift+P (Windows/Linux)
- Run: Developer: Reload Window
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:

code

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

bash

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

# Verify
codex mcp list

Quick Setup (Manual Configuration)

Copy global config:

bash

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

Copy workspace instructions:

bash

cp templates/codex/.codex your-project/

Restart Codex:

bash

# CLI: Restart terminal
# IDE: Reload window

Using DinCoder with Codex

CLI Commands:

bash

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

IDE Extension:

code

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

typescript

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

typescript

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

typescript

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

typescript

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

typescript

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

typescript

"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

typescript

// 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

Start Small: Begin with MVP scope, add features iteratively
Follow the Order: Specify → Plan → Tasks → Implement
Review Specs: Always read the generated spec.md and refine it
Track Progress: Use tasks_tick consistently
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

Tool	Purpose	Usage Example
`specify_start`	Initialize project	`{"projectName": "taskify", "agent": "claude"}`
`specify_describe`	Generate PRD	`{"description": "Build a photo organizer with albums"}`
`constitution_create`	Define project DNA	`{"principles": [...], "constraints": [...]}`
`clarify_add`	Track ambiguities	`{"question": "Auth method?", "context": "Security"}`
`clarify_resolve`	Resolve uncertainties	`{"clarificationId": "CLARIFY-001", "resolution": "..."}`
`spec_validate`	Check spec quality	`{"checks": {"completeness": true, "acceptanceCriteria": true}}`
`research_append`	Document findings	`{"content": "WebSocket benchmarks show..."}`

Phase 2: PLAN — Map Specifications to Architecture

Tool	Purpose	Usage Example
`plan_create`	Technical planning	`{"constraintsText": "Next.js, Prisma, PostgreSQL"}`
`spec_refine`	Update specs	`{"section": "requirements", "changes": "..."}`
`artifacts_analyze`	Verify alignment	`{"artifacts": ["spec", "plan"]}`

Phase 3: TASKS — Generate Executable Work Items

Tool	Purpose	Usage Example
`tasks_generate`	Create task list	`{"scope": "MVP"}`
`tasks_tick`	Track completion	`{"taskId": "T001"}`
`tasks_tick_range`	Bulk completion	`{"taskIds": ["T001-T005"]}`
`tasks_filter`	Show actionable items	`{"preset": "next", "limit": 5}`
`tasks_search`	Find tasks	`{"query": "authentication", "fuzzy": true}`
`tasks_visualize`	Dependency graphs	`{"format": "mermaid"}`
`tasks_stats`	Progress analytics	`{"groupBy": "phase", "includeCharts": true}`

Phase 4: IMPLEMENT — Build With Validation

Tool	Purpose	Usage Example
`git_create_branch`	Feature isolation	`{"branchName": "feature/chat-system"}`
`quality_format`	Code formatting	`{"fix": true}`
`quality_lint`	Static analysis	`{"fix": true}`
`quality_test`	Execute tests	`{"coverage": true}`
`quality_security_audit`	Check vulnerabilities	`{"fix": false}`

📚 Examples

Connect with TypeScript Client

typescript

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:

AI Threshold: LLMs can reliably translate natural language specifications to working code
Complexity Growth: Modern systems integrate dozens of services—manual alignment becomes impossible
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:

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

We appreciate all contributions, big or small!

📄 License

MIT License - see LICENSE file for details.

📚 References

🙏 Acknowledgments

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

Install

claude_desktop_config.json

{
  "mcpServers": {
    "flight505-mcp_dincoder": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://server.smithery.ai/@flight505/mcp_dincoder/mcp"
      ]
    }
  }
}

Desktop config is stdio-only; this bridges via mcp-remote. Native remote: Settings > Connectors.

Table of Contents

🎯 What is DinCoder?

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

🎯 MCP Prompts - AI Workflow Orchestration ✨

🧬 Constitution Tool - Define Your Project's DNA

❓ Clarification Tracking - Systematic Q&A Management

📦 Installation

Prerequisites

Installing via Smithery

Claude Code / VS Code Users

Cursor

Other MCP Clients

📁 Where Files Are Created

🚀 Quickstart

The Spec Kit Workflow

1️⃣ /specify — Transform Ideas into Specifications

2️⃣ /plan — Map Specifications to Technical Decisions

3️⃣ /tasks — Generate Executable Task Lists

Real-World Example: Building a Chat System

Traditional Approach (12+ hours of documentation)

SDD with DinCoder (15 minutes total)

🎯 MCP Prompts (AI Workflow Orchestration)

How MCP Prompts Work

Available Workflow Prompts

Example: How Prompts Guide AI Workflows

1. start_project - Initialize New Spec-Driven Project

2. create_spec - Create Feature Specification

3. generate_plan - Generate Implementation Plan

4. create_tasks - Break Down into Actionable Tasks

5. review_progress - Generate Progress Report

6. validate_spec - Check Specification Quality

7. next_tasks - Show Next Actionable Tasks

Platform Compatibility

The Key Difference: MCP Prompts vs Slash Commands

🔌 Claude Code Plugin (Recommended for Claude Code)

Prerequisites

Installation

Verify Installation

What's Included

Plugin vs MCP Server Only

🔌 VS Code + GitHub Copilot Integration

Quick Setup

Using DinCoder with Copilot

What's Included

🔌 OpenAI Codex Integration

Quick Setup (CLI - Recommended)

Quick Setup (Manual Configuration)

Using DinCoder with Codex

What's Included

🚦 Complete Workflow Guide

Step-by-Step: From Idea to Implementation

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

1️⃣ Start a New Project (1 minute)

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

3️⃣ Track Clarifications (Optional)

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

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

6️⃣ Implement Systematically

🎯 Best Practices

🛠 Available Tools

🎯 Core Spec-Driven Development 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

💡 Why Spec-Driven Development?

Why This Matters Now

🗺 Roadmap

🤝 Contributing

📄 License

📚 References

🙏 Acknowledgments

Install

1️⃣ `/specify` — Transform Ideas into Specifications

2️⃣ `/plan` — Map Specifications to Technical Decisions

3️⃣ `/tasks` — Generate Executable Task Lists

1. `start_project` - Initialize New Spec-Driven Project

2. `create_spec` - Create Feature Specification

3. `generate_plan` - Generate Implementation Plan

4. `create_tasks` - Break Down into Actionable Tasks

5. `review_progress` - Generate Progress Report

6. `validate_spec` - Check Specification Quality

7. `next_tasks` - Show Next Actionable Tasks