Version: 1.35.0 · CHANGELOG · Marketplace
The disciplined dev lifecycle — implement issues, review PRs, sync releases, test E2E, and manage sessions. One plugin to make no mistakes.
A Claude Code plugin by Luis Andres Pena Castillo.
# Add the marketplace (one-time)
claude plugin marketplace add DojoCodingLabs/make-no-mistakes-toolkit
# Install the plugin
claude plugin install make-no-mistakesOr clone and install locally:
git clone https://github.com/DojoCodingLabs/make-no-mistakes-toolkit.git
claude plugin marketplace add ./make-no-mistakes-toolkit
claude plugin install make-no-mistakesnpx @lapc506/make-no-mistakes install| Command | Description |
|---|---|
make-no-mistakes install |
Install to ~/.config/opencode/ |
make-no-mistakes update |
Refresh managed assets |
make-no-mistakes uninstall |
Remove managed files only |
make-no-mistakes doctor |
Health check |
make-no-mistakes install --dry-run |
Preview changes |
make-no-mistakes install --force |
Overwrite unmanaged conflicts |
If you only run one command from this plugin, run this one.
/make-no-mistakes:domain-driven-advisor
The advisor is the canonical entry point for repo-health work. From its SKILL.md:
Guided entry point for repo health when you don't know which audit you need. Use when the user asks "which audit", "where do I start", wants to check "repo health", or mentions "domain driven" design. Inspects the repo, asks a few plain-language questions, recommends which audit(s) to run (or the full ordered sweep), runs them via the audit-engine, and finishes with a premortem on the remediation plan. Best first command for a new repo.
It routes you across the six audit families (all live as of 1.29.0):
| Family | Command | Detects |
|---|---|---|
SCH |
/audit-schema-drift |
1NF violations + same column duplicated across tables |
CDC |
/audit-contract-drift |
Producer↔consumer validation schemas that silently diverged |
DDD |
/audit-ddd |
Cross-context imports, domain purity, ubiquitous-language drift |
ARC |
/audit-explicit-architecture |
Hexagonal/Onion/Clean dependency-rule violations, CQRS separation |
STR |
/audit-strangler |
Strangler-Fig migration health (façade, cutover, legacy retirement) |
ENF |
/audit-enforcement-hooks |
Cure-4 PreToolUse/PostToolUse coverage gaps that allow the other audits' drift |
After the audit(s), it runs a premortem on the aggregated remediation plan, so the plan you ship has already survived "it's 6 months later and this failed — why?". Full teaching section below.
Deliberate actions you invoke explicitly.
| Command | Description |
|---|---|
/make-no-mistakes:implement <ISSUE-ID> |
Disciplined execution of Linear issues — worktree isolation, all-reviewer loops, CI verification, clean merges |
/make-no-mistakes:prioritize <pillar-slug> |
MoSCoW + RICE-adapted applied to a pillar's Linear issues, traceable to its PIBER+IDCF sub-spike and the latest vision audit. Outputs priority report + description-footer per issue + snapshot comment on the sub-spike. Chain: product-vision-audit → prioritize → spike-recommend → implement |
/make-no-mistakes:rebase <repo> |
Team release sync — rebase all branches, auto-merge ready PRs, health report |
/make-no-mistakes:linear-projects-setup |
Bootstrap Linear workspace with full label taxonomy, projects, and integrations |
/make-no-mistakes:e2e-test-builder <source> |
Generate a TestSprite-compatible test-suite.json from docs or PRDs |
/make-no-mistakes:e2e-test-runner [filter] |
Execute E2E tests from test-suite.json with runner selection and reporting |
/make-no-mistakes:pentest-runner <phase> |
Automated pentesting following Cyber Kill Chain + OWASP methodology |
/make-no-mistakes:goodmorning |
Bootstrap your session from previous day's handoff files |
/make-no-mistakes:goodnight [label] |
Save full session context as a handoff file for tomorrow |
/make-no-mistakes:pending-left |
Track what's left unfinished across git, Linear, and session context |
/make-no-mistakes:summarize |
Structured recap of everything done in the current session |
/make-no-mistakes:explain <topic> |
Explain something in two layers — plain prose first, then technical detail — closing with a non-obvious insight, ranked actionables, and AskUserQuestion. The prose layer answers what is going on and why it matters; the technical layer answers where exactly and how. If the prose is only the technical layer in smaller words, it is redundant and gets skipped |
/make-no-mistakes:daily-standup-add-completed [text] |
Append completed work items to today's standup file (auto-detects from PRs/issues) |
/make-no-mistakes:daily-standup-post-slack [draft] |
Compose and post today's standup to the configured Slack channel |
/make-no-mistakes:handover <@person> [#channel] [draft] |
Hand a body of work (PRs, issues, an incident + root cause, a Draft someone must finish) to a specific teammate for review/decision — house Slack style, verify-don't-remember |
/make-no-mistakes:remind <topic> |
Recall past decisions, instructions, or feedback from memory and project context |
/make-no-mistakes:resolve-open-questions [scope] |
Sweep the session for open decisions and questions buried in prose, then resolve them in batches via AskUserQuestion with options + a recommendation. Executes immediately on the answers — one approval, one action |
/make-no-mistakes:postmortem <incident> |
Compose a blameless post-incident report in the house style — evidence verified against logs/DB before writing — with the mandatory Causa Raíz / La Buena Noticia / Plan de Mitigación sections, adapted to a technical or a stakeholder audience |
/make-no-mistakes:handover-pr <repo> [pr#] <@person> |
Package your open PR(s) / branch work into a structured handover and post it to a Slack thread for a teammate to pick up. The mirror of /takeover-pr |
/make-no-mistakes:takeover-pr <repo> [pr#] |
Pick a random open PR from a teammate, check it out, review it, and take over the work |
/make-no-mistakes:secret-input |
Stage a secret/password via OS-native GUI dialog (Linux zenity/kdialog/pinentry, macOS osascript, Windows Get-Credential). The value never appears in the conversation log or terminal history. Cross-platform via .sh (Linux/macOS/WSL/Git Bash) + .ps1 (native Windows) |
/make-no-mistakes:secret-use ENVVAR -- <cmd> |
Run one command with the staged secret loaded as an environment variable. Env var lives only inside the consuming process and is unset on completion |
/make-no-mistakes:secret-clear |
Wipe the staged secret (shred/rm-P/random-overwrite per OS). Idempotent — safe to call when no secret is staged. Always run when done with credentials |
/make-no-mistakes:audit [path] |
Meta-dispatcher — runs the full repo-health sweep (all six families SCH→CDC→DDD→ARC→STR→ENF via audit-engine) and delegates the component layer to atomic-design-toolkit when installed; aggregates one report + emits cure-scaffold proposals per schemas/repo-health-rules.schema.json |
/make-no-mistakes:domain-driven-advisor |
Guided entry point — inspects the repo, recommends which audit(s) to run (or the full sequence), runs them, and finishes with a premortem. Start here for repo health. |
/make-no-mistakes:audit-schema-drift |
Audit for schema drift — 1NF violations + the same logical column duplicated across tables without a single source of truth |
/make-no-mistakes:audit-contract-drift |
Audit consumer-driven contract drift — producer↔consumer validation schemas that have silently diverged |
/make-no-mistakes:audit-ddd |
Audit DDD bounded-context boundaries — cross-context imports, domain purity, ubiquitous-language drift |
/make-no-mistakes:audit-explicit-architecture |
Audit Explicit Architecture (Graça) — Hexagonal/Onion/Clean dependency rule, ports & adapters, CQRS separation |
/make-no-mistakes:audit-strangler |
Audit Strangler-Fig migration health — façade, incremental cutover vs big-bang, coexistence, legacy retirement |
/make-no-mistakes:audit-enforcement-hooks |
Audit Cure-4 enforcement-hook coverage — are the PreToolUse/PostToolUse hooks that prevent the other audits' drift actually installed? |
/make-no-mistakes:premortem <plan> |
Stress-test a plan/launch/decision by imagining it already failed 6 months out, then work backward to expose blind spots; outputs an HTML report + Markdown transcript |
/make-no-mistakes:atomic-rules-init |
Scaffold a .atomic-design-rules.json at the repo root so the atomic-design hooks (PreToolUse ownership enforcement + PostToolUse drift telemetry) start enforcing. No-op if the file already exists |
/make-no-mistakes:e2e-test-preview [path] |
Launch a Qt-based visual previewer for test-suite.json — interactive table with filtering, detail pane, and CSV export (auto-installs PySide6) |
/make-no-mistakes:gemini-code-review [target] |
Cheap first-pass code review (one-shot via liteLLM) on a parametrizable model — Gemini 3.5 Flash by default; supports --model and --adversarial, curated against the repo's CLAUDE.md |
/make-no-mistakes:observability-audit [target] |
Runtime audit of whether observability actually works rather than exists — measures events received per emitting surface, matches the configured credential to a live destination, finds init paths that silently disable monitoring, checks alert-channel liveness/ownership, and flags every alert never demonstrated capable of firing |
/make-no-mistakes:parallelize <work> |
Decompose a body of work and fan it out across named, worktree-isolated agents. Opens with a mandatory capability gate that reads the agent-teams flag and the live tool surface (a retired TeamCreate is the healthy case, never an abort), splits streams by who can execute them as well as by topic, and converges the results into one report |
Auto-activate by context — you don't need to remember the command name.
| Skill | Triggers when you... |
|---|---|
implement-advisor |
Want to work on a Linear issue, implement a feature, or fix a bug (suggests /make-no-mistakes:implement) |
spec-recommend |
Discuss specs, SRDs, implementation briefs, or say "what should I build" |
spike-recommend |
Paste a Linear issue URL or ask to analyze an issue |
review-open-prs |
Ask about open PRs, merge readiness, or Greptile scores |
review-active-issues |
Ask about your Linear issues, backlog, or issue status |
rebase-advisor |
Mention needing to sync branches after a release (suggests /make-no-mistakes:rebase) |
audit-engine |
Run any of the six repo-health audits (schema-drift, contract-drift, ddd, explicit-architecture, strangler, enforcement-hooks). Hybrid LLM-first detection + deterministic verification + cure-mapping |
domain-driven-advisor |
Ask "which audit do I need?" / "where do I start with repo health?" — routes you to the right audit(s) and runs a premortem |
premortem |
Say "premortem this", "what could kill this", "stress test this plan", "what am I missing", or "find the blind spots" on a plan/launch/decision |
prioritize |
Ask to "prioritize issues", "rank the backlog", "apply MoSCoW", or "RICE scoring" for a product pillar (suggests /make-no-mistakes:prioritize) |
Skills can also be invoked explicitly: /make-no-mistakes:spec-recommend T0-4
Specialized subagents dispatched by commands/skills for heavy work.
| Agent | Model | Dispatched by |
|---|---|---|
execution-lead |
Opus | /make-no-mistakes:implement — runs the full protocol in its own context |
pr-reviewer |
Sonnet | review-open-prs skill — cross-references PRs with Linear and Greptile |
New to the audit family, or not sure where to start? Run one command and let it guide you. The advisor is the front door to the whole audit-engine family.
- You inherited a repo and want to know what's structurally wrong.
- You suspect drift (duplicated columns, FE/BE validation mismatches, tangled modules, a stalled monolith migration) but don't know which audit applies.
- You want a remediation plan that's already been stress-tested.
- Inspects the repo — detects signals (a shared database, FE+backend validation, a monolith mid-migration, layered architecture, cross-module imports).
- Asks a few plain-language questions — no jargon required. Each answer maps to one of the audits.
- Recommends and runs the audit(s) — just the ones you need, or the full
ordered sweep
schema → contract → DDD → architecture → strangler → enforcementif you're unsure. - Runs a premortem — on the aggregated remediation plan, so you ship a plan that already survived "it's 6 months later and this failed — why?".
/make-no-mistakes:domain-driven-advisor
Point it at a subdirectory if you only want part of the repo:
/make-no-mistakes:domain-driven-advisor src/payments
You: /make-no-mistakes:domain-driven-advisor
Tool: Scanning… found supabase/migrations and FE+edge validation.
Q1: ¿Varios equipos escriben en la misma base de datos? > yes
Q2: ¿El frontend y el backend validan los mismos datos por separado? > yes
→ Recommended: /audit-schema-drift + /audit-contract-drift, then enforcement.
Tip: fan-out is on by default; for mid-run coordination between
verifiers, add "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
to ~/.claude/settings.json
Run them now? > yes
… findings written to docs/repo-health/… + premortem report on ~/Escritorio.
For each audit it runs: a findings doc in docs/repo-health/, an OpenSpec
remediation change, Bilingual-Layer Linear issues, and 4-cure scaffold
proposals — plus a single premortem report (HTML + transcript) over the combined
plan.
The audits fan out one verifier per finding, so they're much faster in parallel.
The parallelism itself comes from the Agent tool (name +
isolation: "worktree", coordinated by SendMessage) and needs no flag —
there is no TeamCreate tool in current harnesses, and its absence is expected
rather than a problem.
What "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1" adds is the coordination
layer on top: the teammate mailbox, shared team context, and assigning a task to
a teammate. The advisor recommends enabling it in ~/.claude/settings.json
(it shows the exact one-line change; it never edits your settings without
consent). Decline and you still get the fan-out — you lose mid-run coordination,
so each verifier is briefed self-contained and reports once at the end. Note the
flag is ANDed with a server-side gate, so setting it locally doesn't guarantee
the layer is live; the tool surface is what to believe.
See /make-no-mistakes:parallelize for the full
capability gate.
If you already know what you need, skip the advisor:
/make-no-mistakes:audit-schema-drift
The plugin reads linear-setup.json at your repo root for project-specific settings:
{
"team": {
"key": "ALT",
"url": "https://linear.app/your-team"
},
"git": {
"baseBranch": "main",
"branchPattern": "{type}/{issueId}-{description}"
},
"github": {
"org": "your-org"
},
"defaults": {
"greptileReview": true,
"squashMerge": true,
"slackNotify": true
},
"slack": {
"statusChannel": "C09BD6W95GC"
}
}If no linear-setup.json exists, the plugin auto-detects settings from your environment (GitHub org from current repo, Linear team from MCP, etc.).
Claude Code:
claude plugin list
# should show "make-no-mistakes"Or run /plugin inside Claude Code to see it in the plugin manager. Then invoke any command to confirm: /make-no-mistakes:summarize
OpenCode:
make-no-mistakes doctor- Claude Code — the CLI or IDE extension
- GitHub CLI (
gh) — authenticated (gh auth login) - Linear MCP — configured in Claude Code for issue tracking (add via Claude Code settings > MCP servers)
- Slack MCP — optional, for standup posting and Slack reporting. See
slack-config.example.jsonat the repo root for channel configuration
make-no-mistakes is expanding from a developer lifecycle toolkit into a full product ownership layer, grounded in the Scrum Product Owner Professional Certificate (SPOPC) methodology by CertiProf.
The author holds three CertiProf certifications that inform this extension:
- Scrum Product Owner Professional (SPOPC) — backlog management, stakeholder communication, value maximization
- User Stories Foundation (USFC) — story writing, acceptance criteria, splitting strategies
- Scrum Foundation Professional (SFPC) — Scrum framework, ceremonies, roles, artifacts
gstack proved that a single toolkit can serve multiple roles — CEO, designer, engineer, QA — all through slash commands. Product ownership is part of the development lifecycle, not separate from it. make-no-mistakes already has the plumbing: Linear issue tracking, Slack messaging, daily standups, spike recommendations, and session management. The PO skills are natural extensions.
| Component | Type | Description |
|---|---|---|
backlog-groom |
Skill | Read SOPs + Linear project state, suggest prioritization, flag stale issues |
sprint-review |
Command | Generate sprint metrics report — velocity, completion %, carryover items |
vertical-health |
Command | Cross-reference product analytics + Linear velocity + GitHub activity for a product area |
po-standup |
Command | PO-perspective standup: blockers, decisions needed, stakeholder updates |
vertical-report |
Command | Weekly summary posted to the product area's Slack channel for stakeholders |
product-discovery |
Command | GTM Discovery Roadmapping — ingest Linear issues, cluster into opportunities, prioritize with GTM Score matrix, output a Now/Next/Later roadmap. Uses Double Diamond framework (Discover, Define, Develop, Deliver) and a composite GTM Score (Market Fit 30% + Business Impact 25% + GTM Readiness 20% + Effort 15% + Risk 10%). Integrates with Linear MCP for issue ingestion and optionally with Productboard MCP for opportunity/feature export |
SOPs (Standard Operating Procedures) define the what and why per product area — these live in your own documentation repo, not here. make-no-mistakes reads them at runtime to apply context-specific policies.
your-docs-repo/sops/{product-area}/
├── README.md # Vision, KPIs, success metrics
├── backlog-policy.md # Prioritization criteria, Definition of Done
├── release-checklist.md # Pre-release gates specific to this area
└── escalation-flow.md # When and how to escalate to stakeholders
The plugin consumes these SOPs to give context-aware recommendations. Each Product Owner creates SOPs for their area using a shared template.
| SPOPC Concept | make-no-mistakes Implementation |
|---|---|
| Product Backlog management | backlog-groom — reads Linear + SOP prioritization rules |
| Sprint Review | sprint-review — auto-generated metrics from Linear + GitHub |
| Stakeholder communication | vertical-report — weekly Slack summary to stakeholders |
| Definition of Done | SOP at sops/{product-area}/backlog-policy.md |
| ROI / Value maximization | vertical-health — PostHog analytics + Linear velocity |
| User Stories | spike-recommend + spec-recommend (existing, USFC-informed) |
| Sprint Planning | review-active-issues (existing) + backlog-groom (planned) |
| Product Discovery | product-discovery — Double Diamond + GTM Score matrix via Linear + Productboard MCP |
Status: The PO extension is in design phase. The existing developer lifecycle commands are stable and production-ready. PO skills will be added incrementally without breaking existing functionality.
"Make no mistakes" started as an inside joke — a mantra for disciplined execution. Like the Ralph loop, it's a reminder that process isn't optional when shipping matters.
make-no-mistakes-toolkit/
├── .claude-plugin/ # Claude Code plugin metadata
│ ├── plugin.json
│ └── marketplace.json
├── src/ # OpenCode npm distribution (TypeScript CLI)
│ ├── cli.ts
│ ├── index.ts
│ └── lib/
├── commands/ # 30 explicit commands
├── agents/ # 2 specialized subagents
├── skills/ # 10 auto-activating skills
│ └── */SKILL.md
├── hooks/ # Manifest-driven PreToolUse + PostToolUse hooks (v1.5.0+)
│ ├── hooks.json # Claude Code wiring (thin)
│ ├── pre-bash.sh # Bash dispatcher
│ ├── pre-edit.sh # Edit/Write/MultiEdit dispatcher
│ ├── post-slack.sh # Slack message dispatcher (warn-only)
│ ├── test-hooks.sh # Parametrized test runner
│ ├── lib/ # Generic helpers (parse-input, eval-rule)
│ └── rules/
│ ├── rules.yaml # Rules SSoT — humans edit
│ ├── rules.json # Build artifact — runtime reads
│ └── README.md # Contributor guide
├── scripts/ # Shared bash + node utilities
│ └── build-rules.mjs # rules.yaml -> rules.json compiler
├── package.json
└── README.md
Design principle: Commands for destructive/token-intensive actions (you decide when). Skills for read-only analysis (context-aware, auto-activate). Agents for heavy orchestration (own context window). Hooks for deterministic guardrails on every tool call (no human in the loop).
When this plugin is enabled, every tool call you make in any repo runs through
the manifest-driven hooks in hooks/rules/rules.yaml. The Tier 1 ruleset
ships 10 rules:
PreToolUse on Bash (block by default):
ssh-db-mutation— blocksgcloud compute ssh ... --command="...php -r/mysql/set_config..."(Moodle-flavoured SSH payloads)inline-db-mutation-mysql/-psql/-sqlite/-mongo/-redis/-gcloud-sql— blocks inline DB mutations across any CLI (mysql -e "UPDATE...",psql -c "INSERT...",sqlite3 path "DROP...",mongo --eval "db.x.update(...)",redis-cli SET/DEL/FLUSHALL,gcloud sql import/export). Forces use of a versioned script underscripts/orbin/. SELECT-only reads are never blocked. Per-rule bypass via# hook-bypass: db-mutation-rule; per-repo opt-out viatouch .no-make-no-mistakes-db-mutationat the root (memory:feedback_scripts_not_db.md).prod-ops-no-approval— blocks--project=*-prodoperations without explicit acknowledgementdestructive-db-ops— blockssupabase db reset|push|repairand inlineDROP/TRUNCATE/DELETE FROMmanual-edge-fn-deploy— blockssupabase functions deploy(forces CI-only deploys)gcloud-missing-project— warns when agcloudsubcommand is missing--project=
PreToolUse on Edit | Write | MultiEdit (block):
minified-build-output— blocks writing minified content toamd/build/*.min.jsordist/*.min.{js,css}secrets-hardcoded— blocks hardcodedpassword|secret|token|api_key|...patterns in source files (env.example/test/spec/README/fixtures/mocks paths exempted)
PostToolUse on Slack messages (warn-only):
slack-unicode-bullets— warns when•◦▪▫bullets are used (use-instead)slack-tables-no-codeblock— warns when markdown tables ship outside```fences (Slack mrkdwn doesn't render bare tables)slack-spanish-tildes— warns on common Spanish words missing tildes (migracion→migración, etc.)
Each blocking rule has a bypass_marker. Add the literal string
// hook-bypass: <marker> (or # hook-bypass: <marker>) anywhere in the
command or content to acknowledge the rule and proceed:
# Bypass markers shipped in Tier 1:
# // hook-bypass: ssh-db-rule
# // hook-bypass: prod-ops
# // hook-bypass: db-destructive
# // hook-bypass: edge-fn-manual
# // hook-bypass: minified-build
# // hook-bypass: secret-leak
# Bypass marker shipped in v1.17.0 inline-db-mutation family:
# // hook-bypass: db-mutation-ruleSome rules (e.g., the v1.17.0 inline-DB-mutation family) also support a per-repo escape hatch: drop a sentinel file at the repo root and the rule becomes a no-op in that repo. The current sentinel filenames are:
.no-make-no-mistakes-db-mutation— disables all sixinline-db-mutation-*rules in the repo
Bypasses are explicit acknowledgements — they sit inside the command/content itself, not as silent flags.
Edit hooks/rules/rules.yaml, run npm run build-rules, run
npm run test-hooks to verify, and commit. See hooks/rules/README.md for
the schema and Tier 2 decomposition techniques.
Remove the plugin from ~/.claude/settings.json enabledPlugins, or set
CLAUDE_DISABLE_PLUGIN_HOOKS=1 in your shell.
Implementation briefs produced by spec-recommend and spike-recommend follow the Bilingual Format — a two-layer structure:
- Human Layer — User story, background, analogy, pitfalls (readable by non-engineers)
- Agent Layer — Objective, context files, acceptance criteria, verification commands (executable by AI)
See skills/spec-recommend/references/bilingual-format.md for the full template.
Business Source License 1.1 — you may use, modify, and redistribute for non-competitive purposes. Converts to Non-Profit OSL 3.0 after 5 years.