How do I use engineering-standards?

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@engineering-standards Show me the git conventions standard" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

engineering-standards

by rajgurung

Overview Schema Source Related Servers Discussions Admin

TypeScript

                ███████╗███╗   ██╗ ██████╗    ███████╗████████╗██████╗ ███████╗
                ██╔════╝████╗  ██║██╔════╝    ██╔════╝╚══██╔══╝██╔══██╗██╔════╝
                █████╗  ██╔██╗ ██║██║  ███╗   ███████╗   ██║   ██║  ██║███████╗
                ██╔══╝  ██║╚██╗██║██║   ██║   ╚════██║   ██║   ██║  ██║╚════██║
                ███████╗██║ ╚████║╚██████╔╝██╗███████║   ██║   ██████╔╝███████║
                ╚══════╝╚═╝  ╚═══╝ ╚═════╝ ╚═╝╚══════╝   ╚═╝   ╚═════╝ ╚══════╝

                          ⚡ Engineering Standards MCP Server ⚡

                          Your engineering brain, exported as a protocol.

Good engineering habits shouldn't live in your head — they should be encoded, shareable, and enforceable.

     ┌──────────────┐          ┌──────────────────┐          ┌──────────────┐
     │              │  query   │                  │  read    │  ◆ git       │
     │  Claude Code ├─────────►│  MCP Server      ├─────────►│  ◆ reviews   │
     │  / Desktop   │          │  (this thing)    │          │  ◆ PRs       │
     │              │◄─────────┤                  │◄─────────┤  ◆ testing   │
     │              │ response │                  │ standard │  ◆ rails     │
     │              │          │                  │          │  ◆ frontend  │
     │              │          │                  │          │  ◆ deploy    │
     │              │          │                  │          │  ◆ incidents │
     │              │          │                  │          │  ◆ observe   │
     │              │          │                  │          │  ◆ api       │
     │              │          │                  │          │  ◆ database  │
     │              │          │                  │          │  ◆ ADRs      │
     │              │          │                  │          │  ◆ debt      │
     │              │          │                  │          │  ◆ staff     │
     └──────────────┘          └──────────────────┘          └──────────────┘
      YOU + AI                  Protocol Layer                 Standards DB

🛠️ Tools

Tool	Description
`get_standard`	Retrieve a specific engineering standard (14 available — see Standards Included below)
`review_branch_name`	Check if a branch name follows conventions
`review_commit_message`	Check if a commit message follows conventions
`staff_engineer_review`	Get the staff engineer thinking checklist for a given phase of work

Related MCP server: ForgeCraft

📚 Standards Included

General

Standard	Key	Covers
Git Conventions	`git`	Branch naming, commits, rebase workflow, commit hygiene
Code Review	`code_review`	Tone, structure, what to look for, giving and receiving feedback
PR Standards	`pr`	Size, description, pre-merge checklist, hotfix protocol
Staff Engineer Checklist	`staff_engineer`	Thinking prompts for each phase of work

Rails

Standard	Key	Covers
Rails Standards	`rails`	Architecture, security, performance, migrations, Hotwire, deployment
Testing Philosophy	`testing`	Rails/RSpec strategy, FactoryBot, system specs, N+1 detection, CI integration

Frontend

Standard	Key	Covers
Frontend Standards	`frontend`	TypeScript, components, accessibility, state management, performance, testing, security

Operations

Standard	Key	Covers
Deployment Standards	`deployment`	Three-phase migration strategy, strong_migrations, zero-downtime deploys, rollback strategy
Incident Response	`incident_response`	Severity levels, incident commander, postmortems, on-call, game days
Observability	`observability`	Structured logging, metrics (RED/USE), alerting, SLIs/SLOs, dashboards, tracing

Architecture

Standard	Key	Covers
API Design	`api_design`	REST conventions, versioning, error format, pagination, idempotency
Database Design	`database_design`	PostgreSQL/Rails, indexing, constraints, partitioning, connection management
Architecture Decision Records	`architecture_decisions`	ADR template, when to write them, lifecycle, ADR vs RFC
Technical Debt	`technical_debt`	Classification, severity, when to pay it down, prevention, metrics

🤖 Companion Agents

The MCP provides the what (your team's standards). These agents provide the how (code generation and implementation).

From awesome-claude-code-subagents:

Agent	Role
rails-expert	Rails 7.x/8.x implementation, version-aware patterns, Hotwire, deployment
frontend-developer	React, Vue, Angular — TypeScript, accessibility, component architecture

When the MCP returns a standard, it includes a reference to the relevant agent. Claude Code can then delegate implementation to that agent automatically.

⚙️ Setup

1. Install

git clone https://github.com/rajgurung/claude-engineering-standards.git
cd claude-engineering-standards
npm install
npm run build

2. Register

Add to your MCP settings file:

Client	Config file
Claude Code	`~/.claude/.mcp.json` (or project-level)
Claude Desktop	`~/Library/Application Support/Claude/claude_desktop_config.json`

{
  "mcpServers": {
    "engineering-standards": {
      "command": "node",
      "args": ["/absolute/path/to/engineering-standards-mcp/build/index.js"]
    }
  }
}

📋 Wiring It Into Your Projects

Once the MCP is registered, add a CLAUDE.md to your project root so Claude Code knows to consult it:

## Engineering Standards

This project follows team engineering standards via the engineering-standards MCP server.

### Before writing code
- Call `get_standard("rails")` for architecture and conventions
- Call `get_standard("testing")` for test strategy
- Call `get_standard("api_design")` before building or modifying API endpoints
- Call `get_standard("database_design")` before schema changes
- Call `get_standard("deployment")` before any migration or deploy work

### Before committing
- Call `review_branch_name` to validate your branch name
- Call `review_commit_message` to validate your commit message

### Before opening a PR
- Call `staff_engineer_review` with phase `before_pr`
- Call `get_standard("code_review")` for review expectations

### During incidents
- Call `get_standard("incident_response")` for severity levels and response protocol
- Call `get_standard("observability")` for debugging and monitoring guidance

### Implementation
- Use the rails-expert agent for Rails code generation
- Use the frontend-developer agent for frontend work

Adapt this to your stack — remove what doesn't apply, add project-specific rules. The CLAUDE.md stays small because the standards live in the MCP, not in every repo.

🎨 Customising

The standards are plain markdown files in src/standards/. Edit them to match your team's conventions, then rebuild:

src/standards/
├── git-conventions.md           ← branch naming, commits
├── code-review.md               ← review tone & structure
├── pr-standards.md              ← PR size, checklists
├── staff-engineer-checklist.md  ← thinking prompts
├── testing-philosophy.md        ← test strategy (Rails/RSpec)
├── rails-standards.md           ← Rails conventions + rails-expert agent
├── frontend-standards.md        ← Frontend conventions + frontend-developer agent
├── deployment-standards.md      ← Safe deploys, migrations, rollback strategy
├── incident-response.md         ← Severity levels, postmortems, on-call
├── observability.md             ← Logging, metrics, alerting, SLIs/SLOs
├── api-design.md                ← REST conventions, versioning, error format
├── database-design.md           ← PostgreSQL/Rails, indexing, partitioning
├── architecture-decisions.md    ← ADR template and lifecycle
└── technical-debt.md            ← Classification, prioritisation, prevention

npm run build

🧑‍💻 Development

npm run dev    # Watch mode — recompiles on change
npm run build  # One-off build
npm start      # Run the server

📄 License

MIT

Available Tools

4 tools

get_standardGet Engineering StandardA

Retrieve a specific engineering standard. Available standards: git, code_review, pr, staff_engineer, testing, rails, frontend, deployment, incident_response, observability, api_design, database_design, architecture_decisions, technical_debt, standup

Inputs: standard (required).

review_branch_nameReview Branch NameA

Check if a git branch name follows conventions (issue ID prefix, kebab-case)

Inputs: branch_name (required).

review_commit_messageReview Commit MessageA

Check if a commit message follows conventions (imperative mood, subject length, structure)

Inputs: message (required).

staff_engineer_reviewStaff Engineer ReviewB

Run through the staff engineer thinking checklist for a given context (pre-code, pre-pr, post-merge, incident)

Inputs: phase (required), context.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

Deploy Server

One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

TDQS

A3.7/5.0

Scored 2026-09-15 02:50 across 4 tools

Disambiguation5/5

Each tool has a clearly distinct purpose: get_standard retrieves documentation, review_branch_name and review_commit_message validate specific artifacts, and staff_engineer_review runs a workflow checklist. No two tools overlap or could cause misselection.

Naming Consistency4/5

Three tools follow a verb_noun pattern (get_standard, review_branch_name, review_commit_message), but staff_engineer_review breaks the pattern by leading with a noun and using 'review' as a noun rather than a verb. This is a minor inconsistency in an otherwise predictable convention.

Tool Count5/5

Four tools is well within the ideal 3-15 range and appropriately scoped for a standards server. Each tool earns its place for retrieval, validation, and checklist support without redundancy.

Completeness4/5

The server covers the core needs of retrieving standards and validating branch names and commit messages, plus a staff engineer review checklist. Minor gaps exist like PR title validation or code style checks, but agents can retrieve standards and apply them manually, so no severe dead ends.

Maintenance

ActivityInactive

ResponsivenessOutdated data

Resources

Related MCP Connectors

QuassLabs APIA
com.quasslabs
30+ deterministic dev and delivery tools: linting, metrics, diagrams, model advice, AI-text checks.
Code Analysis Developer Tools Software Architecture
371
https://api.quasslabs.com/mcp
CoderbudsA
com.coderbuds
Your team's shipping standards, org map and delivery metrics, inside your coding agent.
Developer Tools Observability Project Management
441
https://coderbuds.com/mcp/insights
code-auditor-mcpA
io.github.BenAHammond
Enforces architectural invariants and code quality rules inside your AI agent's edit loop.
Code Analysis Developer Tools Testing & QA Tools
418
https://www.codeauditormcp.com/api/mcp
mcp-server
ai.packmind
Packmind captures, scales, and enforces your organization's technical decisions.
Developer Tools Project Management Knowledge & Memory
2178
https://app.packmind.ai/mcp

Related MCP Servers

corbatofficial
Developer Tools Code Analysis
corbat-tech
A
license
A
quality
D
maintenance
Policy and quality engine for AI coding agents that enforces team coding standards and provides validation gates for agent-assisted software delivery.
Updated a month ago (2026-09-28 07:07 UTC)
7
54 npm
5
MIT
ForgeCraft
Developer Tools Code Analysis
jghiringhelli
F
license
Not graded
quality
B
maintenance
Provides a quality framework and enforceable conventions for AI coding assistants, ensuring code quality, environment hygiene, and project standards across multiple AI tools.
Updated 2 months ago (2026-09-14 20:09 UTC)
83 npm
3
-
montology
Developer Tools Code Analysis
shinyobjectz
A
license
C
quality
B
maintenance
Enforces design systems and vocabulary via ontology checks, candidate scanning, linting, and structural search across repositories.
Updated a month ago (2026-10-11 16:19 UTC)
7
59
Apache 2.0
sdlc-mcp
Developer Tools Testing & QA Tools CI/CD & DevOps
Osucha
A
license
A
quality
C
maintenance
Enables AI agents to enforce a software delivery standard by validating artifacts against declarative rules, providing templates, glossary terms, and pass/fail verdicts with actionable blockers.
Updated 2 months ago (2026-09-01 07:09 UTC)
8
MIT