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 projectcreate_spec- Create feature specificationgenerate_plan- Generate implementation plancreate_tasks- Break down into actionable tasksreview_progress- Generate progress reportvalidate_spec- Check specification qualitynext_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
workspacePathmanually 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
See how SDD transforms traditional development (click to expand)
Traditional Approach (12+ hours of documentation)
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)
# 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.
🎯 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_starttool with projectName="task-manager" - Explains the .dincoder/ structure created
- Asks what you want to build
- Calls
specify_describewith your requirements - Validates spec with
spec_validate - Suggests next steps
You don't see: The prompt invocation—just the AI following the workflow naturally!
See detailed prompt workflows (click to expand)
1. start_project - Initialize New Spec-Driven Project
AI receives this workflow when you want to start a project:
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:
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:
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:
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:
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:
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:
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?"
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,/clearin 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) orAlt+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@lateston 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:
cp -r templates/vscode/.vscode your-project/ cp -r templates/vscode/.github your-project/ -
Open project in VS Code:
cd your-project code . -
Reload window:
- Press
Cmd+Shift+P(Mac) orCtrl+Shift+P(Windows/Linux) - Run:
Developer: Reload Window
- Press
-
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)
-
Copy global config:
cp templates/codex/config.toml ~/.codex/config.toml -
Copy workspace instructions:
cp templates/codex/.codex your-project/ -
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
- 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
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 serverspec-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