Pragmatic Bear

Make your coding agent prove the risky changes.

A one-line change to how passwords get checked can do more damage than a 500-line restyle. Bearpaws is fifteen skills that sort each change by what could break, not by how big it is. Routine work stays quick. Risky work has to come back with pinned tests, an independent review, and a risk receipt.

Install Bearpaws thepragmaticbear/bearpaws
  1. Bootstrap bp:using-bearpaws Loads at session start. Points the agent at the right skill and sets the risk rule.
  2. Onboard bp:onboarding-to-a-project Reads your stack, project guidance, and test command before it touches code.
  3. Design bp:brainstorming Agrees a design with you before anything gets built.
  4. Build bp:test-driven-development Routine work gets TDD. Elevated work also gets pinned tests and a review.
  5. Prove bp:verification-before-completion Shows fresh evidence and ends with a risk receipt.

What each
step does.

Each skill is a Markdown file you can open and read. Start with the bootstrap, since it's the one your agent loads every time.

  1. Bootstrap

    bp:using-bearpaws is the only skill that loads every session, and it's about 4.9 KB. It tells the agent to look for a matching skill before it answers, and it carries the elevated-risk rule: if a change touches authentication, authorization, a data migration, or money, the heavier process applies. Arguable calls count as elevated.

  2. Onboard

    Before the first edit, bp:onboarding-to-a-project reads your stack, the README, CLAUDE.md or AGENTS.md, a few similar files, and the test command, so the agent works from your conventions instead of whatever its training data guessed. It skips this only for abstract design talk with no codebase behind it.

  3. Design

    bp:brainstorming pins down what you actually want. Then you agree on a design. It builds on the conventions onboarding just found, and no code gets written until you've signed off on it.

  4. Build

    Risk sets the amount of process, not size. A big refactor that can't hurt anyone is still routine, and gets TDD plus a plan if it's non-trivial. An elevated change gets pinned behavior, a failing test first, a narrow diff, stated assumptions, and an independent review. That costs more. On the risky benchmark tasks Bearpaws ran about 2.4 times the cost of Superpowers per task, and on routine tasks the two were about level.

    bp:writing-plans
    Writes a plan from the spec for non-trivial work. In Claude Code it uses native Plan Mode.
    bp:executing-plans
    Works through a written plan and stops at each checkpoint.
    bp:subagent-driven-development
    Gives each task a fresh subagent, with review scaled to the risk.
    bp:dispatching-parallel-agents
    Runs independent tasks side by side in parallel subagents.
    bp:using-git-worktrees
    Keeps feature work in its own git worktree.
    bp:test-driven-development
    Red, green, refactor. The failing test comes first.
    bp:systematic-debugging
    Finds the root cause before anyone writes a fix.

  5. Prove

    Every reply that changed files ends with a risk receipt. Routine work needs three lines, Risk, Verified, and Status, and elevated work adds the pinned tests, the failing-first test, the review, and its assumptions. In Claude Code a Stop hook won't let elevated work end COMPLETE unless a review was dispatched after the last edit. It checks that the receipt and the review exist. It can't check that every line of the receipt is true.

    bp:verification-before-completion
    Runs the real checks and writes the risk receipt before it claims done.
    bp:requesting-code-review
    Sends finished work to an independent reviewer.
    bp:receiving-code-review
    Checks review feedback before acting on it, instead of agreeing on reflex.
    bp:finishing-a-development-branch
    Merges, opens a PR, keeps, or discards the branch once the work is done.

    The fifteenth skill, bp:writing-skills, is for writing your own and testing them with red/green evals.

Where it runs.

I treat Claude Code and Antigravity as primary. Everything else is experimental. Outside Claude Code the rules are only instructions, unless you also add the optional git hook that refuses commits with no Risk: line.

Claude Code
PrimaryPlugin install. Working, and the only host where a hook enforces the receipt.
Google Antigravity IDE
PrimaryNative plugin, skills, subagents, and a capability adapter.
OpenCode
ExperimentalWiring checked in CI. Bootstrap smoke-tested in a live session.
Grok Build
ExperimentalLists the bootstrap and every skill. No live session run yet.
Codex, Devin, Cursor, Copilot
ExperimentalCodex and the Copilot CLI install are checked in CI. Devin and Cursor hooks follow their docs but haven't been verified live.

Install.

Two commands in Claude Code. Antigravity takes a clone and an install script.

Claude Code

claude plugin marketplace add thepragmaticbear/bearpaws
claude plugin install bp@bearpaws

From a local checkout, run claude --plugin-dir /path/to/bearpaws. The hook needs jq and Claude Code 2.1.163 or later. Without either, it does nothing.

Google Antigravity

git clone https://github.com/thepragmaticbear/bearpaws.git
cd bearpaws
./install.sh --antigravity --global

Restart Antigravity. Type /brain and you should see brainstorming in the list.

Read every skill on GitHub

v2.7, MIT licensed. Install steps for Codex, OpenCode, Grok Build, Copilot CLI, Cursor, and Devin are in the repo docs. Bearpaws began as a fork of superpowers v5.0.7 by Jesse Vincent and contributors. It now develops on its own line and isn't affiliated with or endorsed by the superpowers project.