A Claude Code plugin that takes a change from idea to merged PR on autopilot, scaling the rigor to the risk.
A one-line bug gets a failing test, the fix and a reviewed pull request. A new data model gets a brainstorm, a spec and a plan, each reviewed by a second model before any code is written. A migration also gets a rehearsal on a copy first. Either way it runs without stopping to ask, except where a mistake would be public or irreversible.
Requires Claude Code, git and Python 3.10+. The Codex CLI is optional; with it, a GPT model reviews alongside Claude.
/plugin marketplace add easelyte/goodfellow
/plugin install goodfellow@goodfellow
Other ways to install
From your shell: claude plugin marketplace add easelyte/goodfellow, then
claude plugin install goodfellow@goodfellow. For one session from a checkout:
claude --plugin-dir /path/to/goodfellow. The marketplace tracks main;
/plugin marketplace update goodfellow pulls the latest.
Fix a bug. goodfellow classifies it, writes a failing test, fixes it and ships:
> /goodfellow:brainstorm "export --json drops quotes in names"
Tier T0 (fix): export --json writes invalid JSON when a name contains a quote.
Floor T0: nothing in the diff is on a high-stakes or live-state path.
Build something with a design decision in it. The same command goes the long way:
> /goodfellow:brainstorm "Add per-workspace API keys"
Tier T2 (design): a new data model (API keys per workspace) with two reasonable designs.
Floor T1: src/auth/keys.py matches a high-stakes path.
It asks the questions that change the design, writes a spec, and hands off through review, plan,
execute and ship. Already have a diff? Run /goodfellow:ship. Ending a session, run
/goodfellow:close to keep what was learned.
| Tier | When | What runs |
|---|---|---|
| T0 fix | Existing behaviour is wrong and reproducible | A failing test, the fix, ship |
| T1 feature | A new, bounded, reversible behaviour | A short plan in the PR, test-first build, ship |
| T2 design | A new concept or contract, unclear intent, or rival designs | Brainstorm, spec and plan, each reviewed, then build and ship |
| T3 live | Migrations, deploys, credentials, deleting data, money, outside sends | Everything in T2, plus a rehearsal on a sandbox before the live step |
The tier changes the documents and how many review rounds are allowed. It never removes a check: every tier gets a test that must fail first, a second-model review of the diff until no blocker or major remains, a review of the final commit, and the stop list.
Override with --tier T0..T3 (ship --quick is --tier T0). Paths you list as high-stakes force at
least T1, and live-state paths such as migrations force T3. Asking for less is refused, not ignored:
> /goodfellow:ship --quick
Refused: --tier T0 is below the T1 floor. Floor T1: src/auth/session.py matches a high-stakes path.
- Depth that fits the change. A classify step picks the tier from a four-row rubric, announces it, and only ever raises it. Hard floors come from your own path lists.
- Autopilot that asks, never blocks. No approvals between steps. Before a force-push, a push
to the default branch, a tag or release, or a package publish, a
PreToolUsehook asks you through Claude Code's normal confirmation. Your yes goes straight through. - Tests that must fail first.
red_check.pyreplays each new test against the base branch: it must fail there on an assertion, then pass. On high-stakes paths, a mutation check shows which changed lines no test would catch. - A second model reviews every diff. With Codex installed, a GPT model reviews what Claude wrote, and a judge drops findings the code does not support. Reviews stop when findings drop to polish, not at a fixed count.
- Knowledge that compounds. Each run adds what it learned to
.goodfellow/knowledge.md, and about 80 seeded design principles ship with the plugin. Deferred findings become tracked loops.
- You want to approve every step. Set
GOODFELLOW_AUTOPILOT=0, or use Claude Code on its own. - You don't use git or pull requests. The chain ends in a PR.
- One-off scripts and exploration. Even T0 writes a test and runs a review. That is the point, and it is overhead you may not want.
Inspired by obra/superpowers; goodfellow adds tiered depth, cross-model review and hook-enforced stops.
Invoke any skill as /goodfellow:<name>. The chain skills hand off to the next one on their own.
| Skill | What it does |
|---|---|
brainstorm [--tier Tn] [--from-loop N] |
Classifies the change and does the design work its tier needs. Use grill for a one-question-at-a-time interview. |
| grill | Interviews a fuzzy idea one question at a time, then writes a spec and sends it to review. |
review --spec | --plan <path> |
Research, then rounds of two-reviewer adversarial review of a spec or plan. |
plan <spec> |
Task-by-task plan with dependencies and each test's expected red. |
execute <plan> |
Implements the plan test-first, verifying after each task. |
ship [--tier Tn | --quick] |
Tier check, verification, red check, review to convergence, PR, merge. |
| codex | Direct review of the current diff, a file or a commit. |
| triage | Two independent reviewers per open loop, confirmed by you in one batch. |
| publish | Pre-open gate for PRs to public or upstream repos: internal-reference scrub and cross-fork mechanics. |
| snapshot, close | Save learnings before compaction, and at the end of a session. |
| branch, prune | Create a feature worktree; remove merged branches and old logs. |
You rarely need to type these. Say what you want ("review my spec", "grill me on the auth flow", "ship this") and Claude picks the skill.
Settings
Everything works without configuration. Invalid values fail loudly rather than falling back.
| Variable | Default | Purpose |
|---|---|---|
GOODFELLOW_AUTOPILOT |
on | 0 pauses for your approval at each step (the stop list stays on); dry-run logs decisions without changing files. |
GOODFELLOW_STOP_LIST |
on | 0 turns off the stop list's confirmations, in every mode. |
GOODFELLOW_CODEX |
1 |
0 disables Codex even when it is installed. |
GOODFELLOW_CODEX_MODEL |
Codex default | GPT model for the Codex reviewer. |
GOODFELLOW_REVIEW_MODEL |
sonnet / opus |
Claude reviewer model (opus when it is the only reviewer). |
GOODFELLOW_HIGH_STAKES_PATHS |
.goodfellow/high_stakes_paths.txt |
Globs that set a T1 floor and enable the mutation check. |
GOODFELLOW_LIVE_STATE_PATHS |
.goodfellow/live_state_paths.txt |
Globs added to the built-in T3 list (migrations, service and timer units, crontabs, Terraform); !glob drops one. |
GOODFELLOW_SANDBOX |
auto |
Where bubblewrap is installed, the red and mutation checks run your tests sandboxed (private PID namespace, filesystem allowlist). Without it, the red check runs with a one-line warning; the mutation check asks for --fakes. bwrap requires the sandbox; off skips it. |
GOODFELLOW_SANDBOX_RO |
unset | Extra read-only paths for the sandbox, separated by : (a toolchain outside /usr, say). |
GOODFELLOW_MEMORY |
flat |
Knowledge backend: flat (one file) or rich (one file per fact, indexed). |
GOODFELLOW_PRINCIPLES_WEB |
auto | 1 loads the JS, React, Next.js and Postgres principles; automatic with a package.json. |
The stop list asks, it never blocks. It asks before a force-push, a push to the default
branch, a tag push or gh release write, a package publish, and --dangerously-skip-permissions.
Opening or merging a PR asks nothing. Turn one off with its id in disable_builtins in
.goodfellow/guards.json (see the example), where you can also add
your project's own block rules; those deny, and they win over a stop that would ask. The
confirmation is Claude Code's own: a mode that auto-approves prompts may skip it.
python3 scripts/guard_engine.py --selfcheck prints what is active. The full reference, including reviewers, memory backends and loops, is in
docs/configuration.md.
For container-based fail-first tests, configure .goodfellow/config.json with
"red_check": {"command": "docker compose run --rm -v {workdir}:/app -w /app test pytest {tests} --junitxml={junit}"}.
An optional reset runs before every head/base test run; --command / --reset override config.
Custom runners skip bubblewrap and report that choice. Mount only the disposable workdir.
See Custom test runner for reset, isolation and report details.
Do I need Codex? No. Without it a Claude reviewer takes its place and the review says so. You lose the cross-family view that makes review most useful.
What does it cost? The plugin is free. Reviews are extra model calls on your Claude Code plan and, if installed, your Codex plan. Lower tiers write fewer documents, so they cost less.
Will it merge on its own? Into your own private repo, yes, once review converges and CI is green. Pushing a tag or publishing a release asks you first.
Where is its state? In .goodfellow/ at your project root: knowledge, loops, run logs and
guard rules. Commit what you want to share.
Why the name? A good fellow is a trusted companion: one who does the work and knows when to stop and ask.
Pre-1.0: skill behaviour and file formats may still change between minor versions. The CHANGELOG lists every change.
Issues and pull requests are welcome; start with CONTRIBUTING.md. Tests run with
cd scripts && python -m pytest -q. Report security problems privately as described in
SECURITY.md.
MIT © 2026 easelyte.ai