Supermatt

The best of Matt Pocock's Skills, Superpowers, and Compound Engineering.
One complete, simple, supercharged SDLC system for your coding agent.

Install · Where to start · Skills · How it differs · Changelog

• Claude Code, Codex, Cursor, and OMP. Each host loads the same canonical 41-skill tree through a package adapter or documented compatibility fallback.
• 41 skills. 32 for engineering and 9 for productivity, listed below.
• Peer review is repository-controlled. docs/agents/cross-model.json can keep code-review and jury entirely on current-host readers, automatically select a hardened Claude or Codex peer, or explicitly select Claude, Codex, Cursor Agent, or OMP with supported model and effort values.
• One flow from idea to closed issue. Forked from mattpocock/skills at c55ee46, each skill checks its own work and hands the result to the next.

Install

In Claude Code, type:

/plugin marketplace add svyatov/supermatt
/plugin install supermatt@supermatt

In Codex, run:

codex plugin marketplace add svyatov/supermatt
codex plugin add supermatt@supermatt

In Cursor, install SuperMatt from Customize > Marketplace once the listing is available. To load a local checkout during development, run:

agent --plugin-dir .

In OMP, run:

omp plugin marketplace add svyatov/supermatt
omp plugin install supermatt@supermatt

Run /reload-plugins in an existing OMP TUI after installation.

Then invoke setup once in each repository:

It asks where you track issues (GitHub, GitLab, or local Markdown files), which triage labels to use, and whether reviews and juries may call an external peer. It then writes:

CLAUDE.md or AGENTS.md          "## Agent skills" section
docs/agents/issue-tracker.md    where issues live
docs/agents/triage-labels.md    label names for the triage roles
docs/agents/domain.md           where GLOSSARY.md and ADRs live
docs/agents/cross-model.json    external peer mode, model, and effort settings

host-only prevents every supported external peer subprocess while preserving current-host readers. auto keeps the hardened Claude or Codex family selection. Cursor and OMP require explicit selection and runtime confirmation because their inherited configuration cannot provide the same isolation boundary. You can edit docs/agents/cross-model.json directly after setup.

{ "skillOverrides": { "code-review": "off" } }

Where to start

Run the setup command for your host once per repository, as above. After that, invoke ask-supermatt and describe your situation when you are not sure which skill fits. Claude Code plugin commands use /supermatt:name, linked Claude Code and Cursor commands use /name, Codex uses $name, and OMP uses /skill:name.

Most work follows the main flow:

flowchart LR
  grill["grill-with-docs<br>sharpen the idea"] --> spec["to-spec<br>publish the spec"]
  spec --> tickets["to-tickets<br>split into tickets"]
  spec -. fits one session .-> implement
  tickets -->|per ticket| implement["implement<br>tdd, qa, then code-review"]
  tickets -->|whole spec| implementSpec["implement-spec<br>parallel worktrees, one branch<br>tdd, qa, then code-review"]
  implement --> ship["refactor, ship-pr<br>clean up, merge"]
  implementSpec --> ship
  implement --> babysit["babysit-pr<br>handle feedback and CI"]
  implementSpec --> babysit
  babysit --> ready(["ready for human merge"])
  ship --> done(["merged, closed issue"])
  done --> retro["retro<br>review the session"]

1. grill-with-docs sharpens the idea by interview.
2. to-spec turns the conversation into a spec on your issue tracker.
3. to-tickets splits the spec into independently green tickets. Skip it when the work fits in one session.
4. Use implement for each ticket, or implement-spec for the whole spec on one integration branch. Both build through tdd, check the running program with qa, and finish with code-review; implement-spec checks the combined result across tickets.
5. refactor cleans up the branch without changing behavior, and ship-pr repairs CI within bounded attempts through recover-ci, merges only on green checks, and verifies post-merge workflows. Failed post-merge workflows use follow-up repair PRs. To stop short of the merge, babysit-pr opens the PR when needed, handles review feedback and CI, and leaves a ready PR for you to merge.

babysit-pr accepts a PR number or full URL and an optional duration, such as $babysit-pr 96 90m in Codex. It needs an authenticated gh CLI and Bun or Node.js 18.17 or later. The default watch lasts eight hours; resuming the same PR keeps its original deadline and recovery budget. A run reports ready, blocked, budget-exhausted, or closed. See its instructions for extending a watch and handling blockers.

Run retro before clearing the session, or provide a verified session ID or path later. It reads local Claude Code, Codex, Cursor, and OMP transcript evidence and reports gaps instead of guessing from the newest file. After a bug fix, use it to identify what would have prevented the bug; use improve-architecture when the finding is a missing test seam.

With triaged GitHub issues or local Markdown tickets, orchestrate runs steps 4 and 5 unattended for each issue, several issues in parallel if you ask, in worker sessions inside Herdr. Workers use the harness that started it: Claude Code, Codex, Cursor, or OMP. Cursor and OMP workers receive the authoritative active model ID when available, otherwise they keep the harness default. Local tracker files stay in the main checkout; code changes ship through GitHub PRs.

An explicit orchestrate invocation delegates only its listed worker commands within that run. Other user-invoked skills still require a human command; existing safety and approval gates remain in force.

How it differs from mattpocock/skills

SuperMatt starts from mattpocock/skills at commit c55ee46, with selected v1.3.1 updates, and keeps its idea: small, composable skills that stay under your control. The main change is that each skill checks its own work and hands the result to the next skill, so the set runs as one flow from an idea to a reviewed, closed issue.

Skills check their own work

• code-review adds a third axis, Adversarial: how does the change fail in production? Its brief also runs security, public contract, migration, reliability, and concurrency checks where they apply. docs/agents/cross-model.json selects current-host readers only, automatic hardened Claude or Codex peers, or an explicit adapter. Cursor and OMP disclose their weaker isolation and require runtime confirmation. Findings carry P0-P3 severities and quoted evidence, and the reader that did not raise a P0, P1, or P2 finding validates it before the verdict. Upstream reviews on two axes, Standards and Spec.
• to-spec checks the draft spec in a fresh subagent or session when available; otherwise it reviews in the current context and discloses the missing independent review before publishing.
• tdd checks that each test goes red for the reason it names, runs affected-seam checks during cycles and the full required gate for completed work, ends with a mutation check, and flags change-detector tests.
• diagnosing-bugs asks what you already tried, rules out the environment and uncommitted work, and fixes nothing until the causal chain has no gaps. It escalates to you after 2-3 dead hypotheses or 3 failed fixes.
• improve-architecture assesses the codebase first and stops when it is healthy. It finds hot spots by change count over the last year, maps the structure before it looks for friction, visits every module in the map, and skips modules that are shallow by design. refactor and improve-tests gate on an assessment the same way.
• qa, new in SuperMatt, runs the changed program the way its user would (a terminal program in tmux, a web app in a browser) and checks every requested behavior before code-review reads the code.
• ideate, new in SuperMatt, has a fresh subagent or session try to refute each idea before it ranks the survivors. When neither is available, it performs the check itself and reports the lack of an independent verifier; if no idea passes, it reports no survivors.

Skills hand off to each other

• implement completes the full required gate before committing each finished behavior, reuses checks whose inputs are unchanged, runs qa in a fresh subagent or session when available and fixes every fail test-first, then passes the spec to code-review. When fresh context is unavailable, QA reports the independence gap. Follow-ups check the fix diff and affected behavior. Every verified finding is fixed or raised as a question; the issue stays open until merge.
• implement-spec, adapted from upstream v1.3.1, builds a whole spec through native subagents in ticket worktrees and integrates it into one branch for a single PR. It runs QA and review on the combined spec, serializes merges, and keeps issues open until shipping. Use it for one feature reviewed together; use orchestrate to ship a queue of issues separately through Herdr.
• diagnosing-bugs writes the regression test through tdd and reviews the fix with code-review, using the bug report as the spec.
• Test seams agreed in to-spec or triage travel through to-tickets into implement and tdd, so no skill asks about them twice.
• Each planning skill ends by pointing to the next step: ideate to grill-with-docs, improve-architecture to to-spec or implement, and wayfinder to to-spec, using the current host's invocation syntax.
• orchestrate, new in SuperMatt, chains triage, implement, fix-findings, refactor, ship-pr, and a report-only retro across fresh Claude Code, Codex, Cursor, or OMP worker sessions, and verifies each spec with qa and code-review once its tickets close. It reports retrospective candidates without applying or shipping them.
• ship-pr and babysit-pr share one CI recovery, recover-ci, with the same budget of two repair cycles and one transient rerun. babysit-pr keeps that budget, its monitoring window, and the feedback it handled across resumes.
• ask-supermatt routes across all of these flows and is kept in sync with every skill change.

Refactors keep behavior

• implement pins current behavior with characterization tests, written through tdd in their own test: commit.
• refactor: commits never touch test files, and code-review runs a refactor check on them.
• A review fix that changes behavior goes test-first.

Smallest version first

• grilling includes the smallest option and asks at most four questions a round, within the live host question capability's limits, only ones that change what gets built. It uses native dialogs when available and chat as the fallback.

Four first-class hosts

• SuperMatt ships native package adapters for Claude Code, Codex, and Cursor. OMP loads the Claude plugin metadata through its documented compatibility fallback.
• All hosts use the flat canonical skills/ directory. Package discovery is model-independent, but instruction adherence and tool capabilities still require representative model testing.
• Human invocation, model-side composition, and repository peer selection follow the harness contract. auto uses only hardened Claude or Codex adapters. Cursor and OMP are explicit choices with runtime confirmation and disclosed capability gaps.

Scope and names

Borrowed ideas

Some of the checks above are adapted from other skill sets:

The full record of changes is in CHANGELOG.md.

Engineering

User-invoked

Model-invoked

Productivity

User-invoked

Model-invoked

Help and status

Ask questions and report bugs in GitHub issues. Report a security vulnerability privately, as SECURITY.md describes. PRIVACY.md lists where each skill sends your data. To send a change, read CONTRIBUTING.md.

SuperMatt is maintained by Leonid Svyatov. Fixes go to the latest release only.

Authors

• Leonid Svyatov
• Matt Pocock, author of the original skills in mattpocock/skills

License

MIT. See LICENSE.