claudeers.
// MCP Servers

doctrine

Software engineering discipline grounded in named primary standards (OWASP, ITIL, IETF RFCs, ISO, BABOK, SBAR, and more), shipped as a Claude Code plugin and…

Actively maintained
97/100
last commit 12 days ago
last release none
releases 0
open issues 0

Install with your AI

Paste into Claude Code, Cursor, or any agent — it reads the repo and wires the tool into your project.

Install and set up doctrine (claude-plugin project) into my current project.
Found on https://claudeers.com/doctrine
Repo: https://github.com/aethrox/doctrine
Homepage/docs: https://aethrox.github.io/doctrine/
Detected install method: claude-plugin → /plugin install doctrine@aethrox/doctrine
Category: mcp-servers. Platforms: cli, api, desktop.
Read the repo's README for exact setup and env vars, then install it and wire it into my project.

Claudeers Health Verdict:
active; community-verified: false. Confirm the source before running anything.
// or install directly (claude-plugin)
/plugin marketplace add aethrox/doctrine
/plugin install doctrine@aethrox/doctrine
// or clone
git clone https://github.com/aethrox/doctrine

// compatibility

Platformscli, api, desktop
Operating systems
AI compatibilityclaude
LicenseMIT
Pricingopen-source
LanguageAstro

doctrine

Software engineering discipline grounded in named primary standards (OWASP, ITIL, IETF RFCs, ISO, BABOK, SBAR, and more) instead of invented convention. 33 skills covering the software development lifecycle: TDD, code review, incident response, domain modeling, deployment, dependency management, and more.

New to Doctrine? Start with the bilingual Doctrine Wiki.

Three ways to use it, depending on your tool:

Option 1: Claude Code plugin

Native install for Claude Code: the right skill is auto-invoked from its description, no manual copying.

/plugin marketplace add aethrox/doctrine
/plugin install doctrine

Toggle it off later from enabledPlugins in ~/.claude/settings.json, same as any other plugin.

Option 2: MCP server (Claude Desktop, Cursor, Windsurf, Cline, and anything else that speaks MCP)

Requires Node.js >= 18.

Every skill is exposed as an MCP prompt: the same content, reachable from any MCP-capable client, not just Claude Code. Add it as a local MCP server:

{
  "mcpServers": {
    "doctrine": {
      "command": "npx",
      "args": ["-y", "github:aethrox/doctrine"]
    }
  }
}

(Exact config location and format differ per client; Claude Desktop's claude_desktop_config.json, Cursor's .cursor/mcp.json, etc., but the command/args above are the same everywhere.)

Run it directly to confirm it works:

npx github:aethrox/doctrine

Option 3: manual copy (no plugin system, no MCP client)

git clone https://github.com/aethrox/doctrine.git
for s in doctrine/skills/*/; do
  name=$(basename "$s")
  cp -r "$s" ~/.claude/skills/"$name"/
done

Re-run after pulling updates to resync.

How it works

Every skill follows the same shape: a one-sentence defining constraint (the fact that makes it behave differently from the obvious default), a numbered set of phases with concrete, checkable rules, and a closing checklist. The skills combine named external standards and established practices with clearly labeled Doctrine policy defaults.

See WORKFLOW.md for how the 33 skills relate to each other: the lifecycle they map to, which ones cross-reference which, and a worked example.

Skills

SkillStandard(s) it encodesCovers
release-versioningConventional Commits, Semantic Versioning, Keep a Changelog, trunk-based developmentCommit classification, version bump, changelog entry, branching model
secure-codingOWASP Top 10, SCA and secret-scanning practiceInjection classes, access control, secrets, dependency and supply-chain risk, safe error handling
observabilityGoogle SRE golden signals, SLI/SLO/error budget, the RED methodStructured logging, the four golden signals, SLO definition, alert and runbook discipline
safe-deploymentProgressive delivery, canary/blue-green/rolling, expand-contract migrationsDecoupling deploy from release, rollout strategy choice, rollback triggers defined up front
api-design-standardsMicrosoft/Google REST guidelines, consumer-driven contract testingResource/URL conventions, versioning strategy, backward-compatible vs breaking changes, contract testing
dependency-upgrade-managementSBOM (CycloneDX/SPDX), RFC 8594/9745 deprecation headers, Dependabot/Renovate cadence practiceDependency inventory, security vs routine vs major-upgrade lanes, deprecation windows, safe major-version migration
incident-responseGoogle SRE incident management guide, blameless postmortem cultureSeverity/declaration, IC/comms/ops roles, mitigate-before-root-cause, blameless postmortem structure
test-strategyTest data management practice, flaky-test quarantine practiceSynthetic vs anonymized production test data, flaky-test quarantine policy, integration/e2e boundary decisions
code-style-lintEstablished per-language formatters (gofmt, rustfmt, black, prettier), pre-commit/CI enforcement practiceAdopting the ecosystem standard, opinionated over configurable, pre-commit + CI enforcement layers, linting vs formatting
tddKent Beck's red-green-refactor, the testing pyramid, Fowler's test-double taxonomy, FIRST propertiesThe TDD cycle, what makes a test worth keeping, choosing the right test double, shaping a suite
code-reviewGoogle's Engineering Practices code review guide, Fowler's code-smell catalogImprove-over-perfect approval bar, naming smells instead of vague complaints, small-PR discipline, review etiquette
diagnosing-bugsDavid Agans' Debugging: The 9 Indispensable RulesReproduce reliably, bisect the search space, change one variable at a time, audit trail, verify the fix against the original failure
domain-modelingEric Evans' Domain-Driven Design, Michael Nygard's ADR formatUbiquitous language, bounded contexts and translation at boundaries, one-page ADRs, keeping the model current
codebase-designJohn Ousterhout's A Philosophy of Software DesignDepth as the design metric, information hiding vs. leakage, concrete shallow-module red flags, designing it twice
resolving-merge-conflictsGit's three-way merge modelResolving hunks by tracing both sides' intent, avoiding whole-file --ours/--theirs, verifying before finishing, merge vs. rebase
spec-to-ticketsINVEST criteria, tracer-bullet development, Definition of Ready/DoneSynthesizing a spec, slicing tracer-bullet tickets with blocking edges, INVEST checks, Ready/Done gates, handoff to tdd/code-review
prototypeKent Beck/Ward Cunningham's spike solution (Extreme Programming)Naming the one question a spike answers, timeboxing it, building disposable code, recording the verdict and discarding the code
researchPrimary-source citation practice, the CRAAP source-evaluation testScoping a checkable question, tracing claims to primary sources, weighing source credibility, citing findings in a saved file
triageITIL incident priority matrix (Impact x Urgency)Classifying bug vs. enhancement, scoring impact and urgency independently, verifying before prioritizing, routing to needs-info/ready-to-spec/scheduled/wontfix
improve-codebase-architectureFowler's Technical Debt Quadrant, layered on codebase-design's Ousterhout groundingScoping a scan, finding shallow-module red flags, classifying findings by how debt was incurred, prioritizing by leave-cost, recording declined findings as ADRs
wayfinderThe RFC process (IETF/Rust-style engineering decision records)Naming the destination, charting open decisions breadth-first, resolving one at a time with recorded reasoning, tracking decided/open/unspecified/out-of-scope, handoff to spec-to-tickets
grillingBABOK elicitation techniques (structured interviews, confirm elicitation results)Mapping the known/needed gap before asking, frontier-round questioning, resolving facts by lookup not by asking, confirming answers before treating them as settled
handoffSBAR (Situation-Background-Assessment-Recommendation) handoff communication standardStructuring a handoff into Situation/Background/Assessment/Recommendation, naming what's already ruled out, confirming receipt via read-back
teachBloom's Taxonomy, the worked-example effect and fading (cognitive load theory)Placing the target and learner's cognitive level, opening with a fully worked example, fading scaffolding in stages, matching method to level, checking retention over fluency
to-questionnaireSurvey-design practice: leading/loaded question avoidance, closed vs. open question choice, balanced Likert-scale constructionScoping the send (recipient, gap), choosing closed vs. open per question, avoiding leading/loaded/compound questions, balancing rating scales, assembling the document
wait-whatISO 24495-1:2023 Plain Language standard (Relevant/Findable/Understandable/Actionable)Recognizing a missed-explanation signal, re-pitching instead of repeating, applying all four RFUA principles, keeping vocabulary consistent, confirming it landed
writing-for-agentsThe Diátaxis documentation framework, adapted to agent-consumed documentsClassifying content as how-to/reference/explanation/tutorial, writing the how-to as the spine, structuring reference for lookup, relocating explanation to human-read artifacts, skipping tutorial voice
wizardStandard operating procedure (SOP) / runbook documentation practiceScoping to human-authority-only steps, one verifiable action per step, persisting captured values immediately, confirming before advancing, resumability after interruption
repo-secureGitHub's maintainer security best-practices guidanceInventorying current settings, judging which layers apply to this repo, confirming every setting before enabling it, with branch protection receiving the most scrutiny, recording deliberate skips
architecture-diagramThe C4 model (Simon Brown)Picking the right zoom level for the audience, consistent box and arrow notation, choosing to show, save, or commit a diagram as code based on what is authorized, updating on structural change
explain-plainlyISO 24495-1:2023 Plain Language standard, applied as a default postureNo unexplained jargon by default, framing from the reader's stake, maintaining a running glossary, verifying the explanation is actionable
repo-shipConventional Commits, applied at authoring time, plus repo-creation-as-first-class-step practiceSplitting commits by intent, naming a new repo for what it is, deciding visibility deliberately, filling description and topics at creation
project-groundworkISO/IEC/IEEE 29148:2018 requirements quality characteristicsScanning a draft for ambiguity, inconsistency, incompleteness, and unverifiable claims, batching only the blocking gaps, writing decisions into the document and the repository's existing decision record together

MCP server internals

mcp-server.js is a plain Node.js (ESM, no build step) script: at startup it reads every skills/<name>/SKILL.md, parses the name/description out of the frontmatter, and registers each one as an MCP prompt whose content is the full skill text. Run npm test to smoke-test it. The test validates every skill's frontmatter as real YAML, spawns the server and performs a real MCP handshake, asserts an exact prompts/list name match against the discovered skill set, and diffs each prompts/get response against its corresponding SKILL.md file byte-for-byte.

Limitations

None of the 33 skills have been battle-tested against a real release, incident, or security review yet; they're authored from standards but not yet validated in use. The MCP server has a smoke test (npm test) but hasn't been exercised against a real third-party MCP client (Cursor, Windsurf, etc.) yet, only a scripted handshake. This repo has no SECURITY.md or vulnerability reporting channel yet.

ChainAddress
Ethereum0x090f4d8d313bb12c13c63c8b6a7acba19af94490
Solana9PduqxAVxPp78heUG7KKAVpSbPAYa3HjwN3r3JnzcE2X
Bitcoinbc1q4vzs920q3x7d76eq2fu3agq4gxywu5z05aqf86

Contributing

Adding a new skill or fixing an existing one? See CONTRIBUTING.md.

License

MIT, see LICENSE.

// faq

What is doctrine?

Software engineering discipline grounded in named primary standards (OWASP, ITIL, IETF RFCs, ISO, BABOK, SBAR, and more), shipped as a Claude Code plugin and an MCP server.. It is open-source on GitHub.

Is doctrine free to use?

doctrine is open-source under the MIT license, so it is free to use.

What category does doctrine belong to?

doctrine is listed under mcp-servers in the Claudeers registry of Claude-compatible tools.

5 views
18 stars
unclaimed
updated 11 days ago

// embed badge

doctrine on Claudeers
[![Claudeers](https://claudeers.com/api/badge/doctrine.svg)](https://claudeers.com/doctrine)

// retro hit counter

doctrine hit counter
[![Hits](https://claudeers.com/api/counter/doctrine.svg)](https://claudeers.com/doctrine)

// reviews

// guestbook

0/500

// related in MCP Servers

🔓

f.k.a. Awesome ChatGPT Prompts. Share, discover, and collect prompts from the community. Free and open source — self-host for your organization with complete…

// mcp-serversf/HTML167,135NOASSERTION[ claude ]
🔓

A cross-platform desktop All-in-One assistant for Claude Code, Codex, OpenCode, OpenClaw, Gemini CLI & Hermes Agent. Only official website: ccswitch.io

// mcp-serversfarion1231/Rust127,274MIT[ claude ]
🔓

An open-source AI agent that brings the power of Gemini directly into your terminal.

// mcp-serversgoogle-gemini/TypeScript106,524Apache-2.0[ claude ]
🔓

🪨 why use many token when few token do trick — Claude Code skill that cuts 65% of tokens by talking like caveman

// mcp-serversJuliusBrussee/JavaScript100,343MIT[ claude ]
→ see how doctrine connects across the ecosystem