Rapid Dev Guide MCP

Rapid Dev Guide MCP is a private Model Context Protocol server for applying development standards consistently across AI-assisted software projects.

It combines:

• an MCP server in this repository
• a rules/ Git submodule that contains the rule documents
• task-oriented tools, prompts, and resources that guide planning, coding, review, and final verification

The goal is simple: make AI coding workflows ask the right setup questions, apply the right engineering rules, and verify the right checklist before finishing.

Overview

Rapid Dev Guide MCP helps an AI client do three things well:

1. Select the relevant rules for a task.
2. Run a structured intake before implementation.
3. Verify completion against the appropriate checklist.

This repository contains the MCP package and runtime code.

The rule markdown files come from the existing GitHub repository mounted as a submodule:

• rules/ -> https://github.com/Rajkumar-Sony/Development-Rules

Why This Exists

Most AI coding sessions fail for predictable reasons:

• implementation starts before framework, runtime, testing, or deployment decisions are confirmed
• coding principles are implied instead of selected explicitly
• security, quality, and architecture checks are applied too late
• final responses do not verify whether project standards were followed

Rapid Dev Guide MCP addresses that by exposing a reusable workflow through MCP.

Core Capabilities

• Selects relevant rule files for a given software task
• Generates a mandatory pre-coding intake questionnaire
• Returns optional concept and coding-principle checklists
• Exposes every rule file as a read-only MCP resource
• Supports rule lookup, search, learning projects, and completion checklists
• Works with MCP-capable IDEs, editors, and agent CLIs

Repository Structure

Rapid-Dev-Guide-MCP/
├── rules/                 # Git submodule with rule markdown files
├── src/                   # MCP server source
├── dist/                  # Build output
├── package.json
├── tsconfig.json
└── README.md

How It Works

At runtime:

1. Your IDE or agent starts rapid-dev-guide-mcp, typically through npx.
2. The server loads rule documents from rules/.
3. The client discovers MCP tools, prompts, and resources.
4. During a task, the client calls tools such as get_rules_for_task, get_project_intake, and get_checklist.
5. The AI uses the returned guidance while planning, implementing, and finishing the task.

Important: installing the MCP server only makes the workflow available. It does not force every client to use it unless your client honors MCP instructions or you add a mandatory project/global instruction.

Recommended Workflow

For the strongest results, configure your AI client to follow this sequence for every development task:

1. Call get_rules_for_task before planning.
2. Call get_project_intake before coding.
3. Ask the user the returned setup questions.
4. Present the returned concepts and coding principles for selection.
5. Read and apply the relevant rule files.
6. Call get_checklist before finishing.

Recommended agent instruction:

For every software development task, you must use the Rapid Dev Guide MCP before
planning, coding, reviewing, or finishing.

Required workflow:
1. Call get_rules_for_task with the user's task context before making a plan.
2. Call get_project_intake with the user's task context and any explicit rule areas.
3. Before coding implementation, ask the user the returned framework, language,
   CSS/UI library, tooling, runtime, testing, deployment, and project convention questions.
4. Show the returned concepts and coding principles as optional checkboxes so the
   user can manually select what applies to the project.
5. Do not start coding until the user answers the intake questions or explicitly
   approves reasonable defaults.
6. Apply the returned rule files during implementation.
7. If the user names specific rule areas, call get_rule_set for each named area.
8. Use search_rules when a concept or coding principle needs clarification.
9. Before the final response, call get_checklist for the most relevant rule area.
10. In the final response, state which Rapid Dev Guide areas were applied and whether
    the checklist passed.

Recommended Install

Best option depends on what you want, but in most cases:

👉 Use npx / npm package

Best Overall: npx / npm package

Why it is best:

• No setup for users
• Works on any PC instantly
• No path issues
• Same behavior as popular MCP servers

Use this snippet for clients that use the servers key:

{
  "servers": {
    "rapid-dev-guide": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "rapid-dev-guide-mcp@latest"]
    }
  }
}

Use this snippet for clients that use the mcpServers key:

{
  "mcpServers": {
    "rapid-dev-guide": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "rapid-dev-guide-mcp@latest"]
    }
  }
}

This is how most "plug and play" MCP servers work. The -y flag prevents npx from stopping the MCP client with an install confirmation prompt.

If you distribute this package through a private npm registry, internal npm scope, or other package source, this should be the default setup you document for end users.

Quick Start

Option 1. Use the package directly

For most users, configure your MCP client to launch the package:

{
  "mcpServers": {
    "rapid-dev-guide": {
      "command": "npx",
      "args": ["-y", "rapid-dev-guide-mcp@latest"]
    }
  }
}

Option 2. Clone the repository for development

Use this path if you are actively developing the MCP server itself.

1. Clone the repository

git clone --recurse-submodules https://github.com/Rajkumar-Sony/Rapid-Dev-Guide-MCP.git
cd Rapid-Dev-Guide-MCP

If you already cloned without submodules:

git submodule update --init --recursive

2. Install dependencies

npm install

3. Build the server

npm run build

4. Point your MCP client to the built server

{
  "mcpServers": {
    "rapid-dev-guide": {
      "command": "node",
      "args": ["/absolute/path/to/Rapid-Dev-Guide-MCP/dist/server.js"]
    }
  }
}

For local development without a build step:

{
  "mcpServers": {
    "rapid-dev-guide": {
      "command": "npx",
      "args": ["tsx", "/absolute/path/to/Rapid-Dev-Guide-MCP/src/server.ts"]
    }
  }
}

Example Task Flow

User request:

Build a React dashboard with login, forms, API calls, and dark mode.

Expected MCP flow:

1. get_rules_for_task
2. get_project_intake
3. user answers framework/language/tooling questions
4. user selects concepts and coding principles
5. implementation starts
6. get_checklist runs before final completion

Example direct prompt:

Use Rapid Dev Guide MCP. Apply frontend-development, security-and-privacy,
configuration-and-environments, and testing-and-quality-gates while building
this feature.

Mandatory Intake Before Coding

The get_project_intake tool returns:

• framework and platform selection
• programming language selection
• package manager and build tool selection
• CSS or UI library selection
• runtime and version constraints
• testing and quality gate selection
• deployment environment selection
• project convention requirements
• area-specific follow-up questions for frontend, API, microservices, database, cloud, security, and documentation
• concept and coding-principle checklists

Example input:

{
  "task": "Build a React dashboard with login, forms, API calls, and dark mode.",
  "areas": "frontend-development, security-and-privacy, configuration-and-environments, testing-and-quality-gates"
}

Tools

• list_rules: List all available rule, learning, and index files.
• get_rule_set: Read one rule file by id, alias, title, or filename.
• search_rules: Search across rule documents and return compact matches.
• get_rules_for_task: Select the most relevant rule files for a task.
• get_project_intake: Generate pre-coding intake questions and concept selection.
• get_learning_projects: Return guided learning projects by area.
• get_checklist: Return the Before Moving On checklist for one rule area.
• rules_mcp_status: Return server health and loaded rule-file counts.

Prompts

• apply-rapid-dev-guide: Full workflow prompt for using the MCP server during a development task.
• project-intake-before-coding: Prompt focused on mandatory setup and concept intake before implementation.

Resources

Each markdown rule file is exposed as a read-only MCP resource, for example:

rules://frontend-development
rules://rest-api-development
rules://backend-microservices
rules://index

Supported Client Configuration

Package-based npx setup is the recommended default for most users.

Most MCP-capable clients can use the standard mcpServers JSON shape:

{
  "mcpServers": {
    "rapid-dev-guide": {
      "command": "npx",
      "args": ["-y", "rapid-dev-guide-mcp@latest"]
    }
  }
}

VS Code (GitHub Copilot MCP)

{
  "servers": {
    "rapid-dev-guide": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "rapid-dev-guide-mcp@latest"]
    }
  }
}

Windsurf

{
  "mcpServers": {
    "rapid-dev-guide": {
      "command": "npx",
      "args": ["-y", "rapid-dev-guide-mcp@latest"]
    }
  }
}

JetBrains AI Assistant

{
  "mcpServers": {
    "rapid-dev-guide": {
      "command": "npx",
      "args": ["-y", "rapid-dev-guide-mcp@latest"]
    }
  }
}

Junie

{
  "mcpServers": {
    "rapid-dev-guide": {
      "command": "npx",
      "args": ["-y", "rapid-dev-guide-mcp@latest"]
    }
  }
}

Cline

{
  "mcpServers": {
    "rapid-dev-guide": {
      "command": "npx",
      "args": ["-y", "rapid-dev-guide-mcp@latest"],
      "disabled": false
    }
  }
}

Zed

{
  "context_servers": {
    "rapid-dev-guide": {
      "command": "npx",
      "args": ["-y", "rapid-dev-guide-mcp@latest"],
      "env": {}
    }
  }
}

Claude Code

{
  "mcpServers": {
    "rapid-dev-guide": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "rapid-dev-guide-mcp@latest"]
    }
  }
}

Codex (JSON Equivalent)

{
  "mcpServers": {
    "rapid-dev-guide": {
      "command": "npx",
      "args": ["-y", "rapid-dev-guide-mcp@latest"]
    }
  }
}

Development

Useful commands:

npm install
npm run build
npm run typecheck
npm run dev

Packaging Notes

• The MCP runtime lives in the root repository.
• The rule content is loaded from the rules/ submodule.
• The package is publishable so npx rapid-dev-guide-mcp can work from a registry.
• For private distribution, publish it to a private npm registry or internal npm scope and keep the same MCP client snippet.

License

This project is proprietary. See LICENSE. Do not copy, publish, redistribute, or use these files without explicit written permission.