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
93/100
last commit 26 days ago
last release none
releases 0
open issues 0
// star history

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

Get your FREE $2.50 API credits to access TickAtlas financial data ↗

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.

8 views
★ 18 stars
unclaimed
updated about 2 months 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/⟨HTML⟩★ 172,096◷ NOASSERTION[ 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/⟨Rust⟩★ 140,512◷ MIT[ claude ]
🔓

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

// mcp-serversJuliusBrussee/⟨JavaScript⟩★ 107,719◷ MIT[ claude ]
🔓

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

// mcp-serversgoogle-gemini/⟨TypeScript⟩★ 107,167◷ Apache-2.0[ claude ]
→ see how doctrine connects across the ecosystem