phuryn/product-engineering / ai-shipping/skills/test-harness
test-harness
VerifiedWriting or running tests, proving a fix, a red or flaky run, a fix that didn't land, 'is it verified', 'run the gate': tests where green means something.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 18.6 KB |
| receipts.md | markdown | 7.1 KB |
| references/captures.md | markdown | 7.2 KB |
| references/coverage-map.md | markdown | 5.4 KB |
| references/external-creates.md | markdown | 1.6 KB |
| references/harnesses.md | markdown | 15.6 KB |
| references/rules-from-bugs.md | markdown | 29.3 KB |
| references/vendor-surfaces.md | markdown | 6.8 KB |
references/rules-from-bugs.md
View on GitHub# Rules that came from bugs — the gate and the harness
Each rule is here because a green run lied once. Grouped by the moment you meet it. The receipts name products by kind: most come from web apps on Next.js (App Router), Supabase, Clerk, Vitest and Playwright; those marked *the remote-control product* come from a relay service with a web client and an editor extension with desktop installers that drives a CLI agent. Several are Windows-specific — said where they are. Two delivery rules sit in `SKILL.md § Reporting a run` because no trigger would send anyone looking for them: read every exit code from the log, and an inherited report is a claim.
## Reading a red run
- **The gate is the exit code, never the printed counts.** A run can print nothing but green and still be red. (`2026-09-23`, measured on the remote-control product's extension, three runs: failing tests exit 1 with counts that agree; every test passing plus one **unhandled rejection** prints `285 passed` / `6890 passed` and exits 1.) Reading the summary block is not a gate; `echo "EXIT=$?"` is, and a report that quotes the counts without the exit code has established nothing. The rejection there was real: a fire-and-forget `void` call with no `.catch()` — anything that rejects inside a `void`-ed promise escapes, and the suite is the only place it surfaces, so the `.catch` on a new `void`-ed call is not defensive noise.
- **A green run that flakes is not a pass.** Judge a suite on a series. A suite that has never been green reports nothing and hides the next real red. (The remote-control product's cross-process suite was green two runs in three while a real bug was live.) **Log a flake in the backlog the first time it appears, naming the step; the second time, its fix is due** — not at the release that finally refuses it. Load from parallel work (a review round, another gate) is what exposes a timing race, so a flake that appears only under load is still a race. (`2026-10-23`, a monitoring product: a journey flaked once and was logged, flaked again on another step, and the fix then due found two races in one menu.)
- **A check nobody runs rots, and a check left red teaches everyone to stop reading.** Defining the gate is the cheap half; running it is the other. When a check in it is obsolete, delete it in its own commit with the reason recorded — never leave it red. (`2026-08-01` to `2026-08-11`, the remote-control product: a browser suite in a gate that nothing ran automatically sat red for ten days unnoticed, and was deleted rather than repaired.)
- **A failure whose duration equals the budget is a hang until shown otherwise.** Read the trace, the network and the whole log body before the failure list: a vendor's error page reaches the code under test as data, so the summary line never names it. Search a red log for `<html` and the vendor's hostname (a hosted database's intermittent failures have a signature of their own: `supabase-production`). **Record a cause only when a mechanism explains both the hits and the misses; one correlation is not a receipt.** (`2026-09-22`, a hosted development database failed a different integration file on each run, and a cause written down after two runs had to be deleted after the third.)
- **When many unrelated specs fail together, read one failure fully before the rest.** The count says how many journeys share a helper, not how much is broken (§ Browsers and layout, finding a container by structure).
- **A change that deliberately repaints owns every assertion that named the old paint**: read the red run and update each on purpose; when a control wears its surface's own colour, pin what still separates it (its edge's contrast). (`2026-09-20`, a live Q&A product: a repaint left old-colour assertions red, and no assertion pinned the edge that alone distinguished a control from its surface.)
- **A failure byte-identical after a fix usually means a second copy of what you fixed.** Grep the assertion's own words and the fixed value before re-examining the fix. (`2026-09-20`, a live Q&A product: another spec kept its own copy of the geometry map that had just been fixed.)
## Writing assertions
- **A fallback in a test is a bug in disguise.** "Try the new way, else the old way" passes exactly when the thing under test is absent. Assert the one true path. (`2026-08-16` and `2026-08-17`, the remote-control product's compatibility suite: one fallback papered over a held state that never cleared; another clicked through a menu that could only appear if an injection had broken — it looked like version tolerance and would have passed on the breakage.)
- **Don't assert a control that only exists in some states.** Move the coverage to a harness that has the state; don't guard it with a conditional, which reintroduces the fallback above. (The remote-control product: an overflow control renders only when a record exists, and an assertion that opened it passed only while the action under test was itself what rendered it.)
- **A suite that skips must skip loudly** — print why, exit 0 locally; where a required flag is set, the skip becomes a failure. (The remote-control product's cross-repository suite skips loudly when the sibling checkout is absent; the gate passes a require flag, so there a missing sibling fails.)
- **A pin must not pass against a dead branch.** A source assertion that looks for a substring is satisfied by code that can never run: `toContain('msg.type === "routines"')` passes against `if (false && msg.type === "routines")`, which is exactly the mutation the pin exists to catch. Assert the whole conditional, then apply the dead-branch mutation and watch the pin fail. (`2026-08-25`.)
- **When a product implements the same surface twice on purpose, nothing asserts the two agree unless a test holds a table of them.** Write one table of hosts and extend it when another appears; do not give each host an assertion of its own. (`2026-09-17`, the remote-control product: one feature cost three commits because a style or fix landed in one of two renderers of the same rail, and each was found by a person or a review, never by a suite.)
- **Drive the control a person sees, and wait for the navigation before inspecting where it lands.** A hidden native input behind a styled control, or a selector that still matches the page you are leaving, waits out the whole timeout and then blames the locator. (Date not recorded, a live Q&A product: specs did both.)
- **A test that renders a stand-in for a component cannot see the container the real one sits in**; when the claim is about layout or nesting, render the real one. A component moved under a new parent inherits that parent's imports in its tests. (`2026-09-21`, a live Q&A product: a bare `<h1>` stood in for a heading component and hid its container's defect.)
## Fixtures
- **Record a vendor API fixture from the vendor's development instance, never hand-write it in the code's expected shape.** A handmade fixture agrees by construction and passes the defect; the real-capture rule in `harnesses.md` applies here too. (`2026-11-06`, a live Q&A product: every unit test passed while sessionless billing read embedded visible features and dropped canceled items still in their paid period, because the fixtures matched the code. The real response, read from the development instance, lacked the AI-allowance feature, so every API-token and MCP call from a paid workspace had been getting the free plan's allowance.)
- **A count pinned to what a fixture happens to produce tests the fixture, not the screen.** Assert the rows the test made, by name. (`2026-09-20`, a live Q&A product: adding a shared-fixture item broke `toHaveCount(3)`, which would have passed if another row replaced the one under test.)
- **A fixture is a set of branch selections, not a label.** Sharpening one so an assertion can tell the bug from the fix also moves every other call in the test onto the branch the new value selects. Re-read each call for what that branch requires, or the test fails earlier, on a refusal that has nothing to do with the assertion it was written for. (`2026-09-21`, a fixture's mode was changed so a test could fail, and an earlier call took a branch that required a quota the test did not pass.)
- **A test must not need two clocks to agree.** A window computed on the machine and checked against timestamps the database wrote passes or fails by the skew between them. Take both ends from one clock — the database's `now()`, or a time the test passes in. (`2026-10-22`, a monitoring product's budget-window test needed the machine's clock to agree with the database's to the second.)
- **A regenerated fixture does not regenerate the facts derived from the columns it leaves alone.** A reset, reseed or demo refresh can be right in every row it writes and still leave a screen wrong, because the screen computes from a timestamp or counter the reset never touched. List the columns a regeneration does **not** write, ask which of them a screen does arithmetic on — elapsed time, age, *since* — and re-stamp those in the same reset. Every assertion passes on this; only the running screen shows it. (`2026-09-21`, a freshly reset demo said *open for 6 days* above content the same transaction had just written.)
## Irreversible identifiers
- **Take an irreversible identifier only after every fallible step has passed once.** Run those steps on the same input. When the identifier cannot be returned, preflight with a placeholder and change only the identifier for the final run. A crash during that run still spends one. (`2026-11-18`, a live Q&A product consumed an identifier before generating its output. Generation failed and left no output. The sequence recurred in the next stage.)
## The database
- **A gateway rejection is not proof of database denial.** A missing publishable key skips loudly; a configured key rejected with HTTP 401 fails. Admit the key before asserting the permission-denied SQLSTATE (`42501`), and run the secret-key catalog assertions independently. (`2026-09-16`, a stale key let the deny-all suite pass without reaching PostgreSQL.)
- **A refusal through an RPC is asserted by HTTP status, SQLSTATE and message together.** PostgREST answers a call that matches no function signature with `PGRST202` and a 404, before Postgres checks any privilege. So a test that expects only a 404 for a missing or foreign target passes against a schema without the function, and a denial probe sent with the wrong argument names proves nothing about grants. Call with the real argument names and assert all three (the codes are in `supabase-production`). (`2026-09-16`, written into a product's deny-all proof so a missing function could not pass for an ownership check that worked.)
- **The catalog suite names its target and proves it arrived.** The project comes from the database URL the app connects with, never from a CLI link or a config file — the target is stated, never inherited (`environments`) — and the suite skips loudly when it names none. **Its first assertion is that the product's own tables are there**: every other catalog assertion expects an empty list, so against the wrong or an empty project they all pass. That is the absence rule (`vendor-surfaces.md`) applied to the schema.
- **A CLI flag pair is not a stated target.** (`2026-10-23`, a review round on a monitoring product found that `supabase db push --linked` applies to the linked project whatever `--project-ref` says.) On CLI 2.122.0, read 2026-10-25, `db query`, `db push` and `migration list` all list `--project-ref`, the help does not say which of the two wins, and a probe with dummy refs saw the typed ref used for the first request. Precedence that differs by version, or by who read it, is not a target. So the suite connects by `--db-url`, and the CLI is never linked (`supabase-production`).
- **On Windows, hand a CLI multi-line SQL through a temp file, never as an argument.** `npx` needs `shell: true` there, and the shell mangles a multi-line argument. (`2026-10-11`, a product's first catalog run.)
## Servers, builds and worktrees
- **The shared `webServer` sets `reuseExistingServer: false`, because a reused server can be a build from before your change.** A busy port then fails the run loudly instead of letting a green suite test an old bundle; never turn it back on to save a build. When an assertion disagrees with source you just edited, check what answers the port before changing code.
- **Stopping the shell does not stop the server.** On Windows a stopped shell can leave Next's child process holding the port and serving the old build. Find the PID that owns it (`Get-NetTCPConnection -LocalPort <port> -State Listen`) and stop that one — never a process you did not start.
- **A server started by hand is not the server the harness would have started.** Copy its `webServer.env` as well as its command, build-time values included, or let Playwright start it. Static metadata can bake the wrong URL into the bundle before any test runs.
(`2026-09-17`, a stale server survived into the sweep and a hand-started one omitted the app URL and the build directory; `2026-09-21`, a killed shell's child went on serving the old build and answering its health check.)
- **Stopping a gate mid-run leaves orphans that break the next run.** A stopped gate can leave its check scripts, a server and a headless-browser tree running, and the next run fails on something that has nothing to do with the change. After stopping any gate, find and stop the processes it started before re-running. (`2026-09-25`, the remote-control product: a stopped gate's orphans failed the next run on a device-registration check.)
- **After merging a dependency update, reinstall locally.** CI's clean install stays green while the local `node_modules` still holds the old tree, until packaging refuses hours later. (`2026-09-25`.)
- **Run the browser suites one at a time.** The authenticated suite and the visual suite share one `webServer` (port, build directory) and one set of test accounts, and each resets what those accounts own — run together, one wipes the other's fixtures mid-run.
- **A builder sandboxed to a linked worktree may be unable to commit.** A linked worktree's index lives in the main checkout's `.git/worktrees/<name>/`, outside a sandbox that may write only the worktree, so `git add` fails creating `index.lock` there. Let the sandbox write that directory, or say in the brief that the session agent commits (`delegation`). (`2026-10-31`, an evals product: a builder could edit its stage's source but not commit it.)
- **Never `git worktree remove` a worktree whose `node_modules` is a junction to another checkout.** `--force` deletes *through* the link and empties the other checkout's `node_modules`, killing any gate or server running from it. Delete the link first (on Windows, `cmd /c rmdir <worktree>\node_modules` removes a junction and leaves its target; elsewhere, `rm` the symlink with no `-r`), then the worktree — or give the worktree its own `npm ci`, which `next build` needs anyway, because Turbopack refuses a symlinked `node_modules` (start `next dev --webpack` there instead). While a shared tree is linked, run unit tests without Vite writing into it (`node node_modules/vitest/vitest.mjs run --configLoader runner tests/unit`): unit evidence only, never browser or service evidence. (`2026-10-02`, a worktree removal emptied the main checkout's `node_modules`.)
- **`tsconfig.json` includes `**/*.ts`, so the typecheck covers `tests/` too — keep it that way.** Vitest transpiles without typechecking; narrowing the include to `src/` lets test type errors pass the gate indefinitely. It runs with `--incremental false`: a `tsconfig.tsbuildinfo` left by an earlier run reported 0 errors while 22 existed. (`2026-10-24`, a product moving its agents to the Claude API.) The same include typechecks a scratch config left in the tree: keep one-off configs outside it, or delete them before the gate. (`2026-10-24`, a monitoring product's release candidate went red on typecheck from a run's own local browser configs, not product code.)
- **A fixture that listens on IPv4 only fails where `localhost` resolves to `::1`.** Bind both families, or connect to the explicit address the fixture binds. (`2026-10-22`, a monitoring product: twelve TLS tests failed on one machine because their fixtures listened on IPv4 only and its `localhost` resolved only to `::1`.)
- **`next build` edits `tsconfig.json`.** Each build into a dist dir it has not seen (`NEXT_DIST_DIR`) adds that directory's `types/**/*.ts` and `dev/types/**/*.ts` to `include`, without a word. `.gitignore` ignores the directory, not the edit, so the next `git add -A` commits it. Commit the globs once for the harness's own dist dirs; for a one-off build into a directory of its own, revert that hunk before committing. (`2026-10-01`, a local screen check's build directory was committed into `tsconfig.json`.)
- **`next build` stops once when the installed Next.js has a known advisory.** It exits 1 with `SecurityFatalError` before compiling, so a browser suite reports only that its web server could not start, which looks like a broken build. A retry continues with a warning; **the fix is upgrading Next — at once when the advisory is critical — never retrying past it.** (`2026-10-24`, a product on Next.js 16.4.0, with remote-code-execution advisories.)
## Browsers and layout
- **A DOM assertion cannot see a layout.** A dead responsive rule leaves `toBeVisible()` green, and a control with no size or pushed off-screen passes every DOM assertion; a simulated DOM (happy-dom, jsdom) has no layout engine at all, so its rects are zero and its stylesheets never apply. Claims about layout need geometry — same left edge, stacked order, `scrollWidth === clientWidth` — and a person looks at the visual captures. (`2026-09-04`, only a screenshot found the landing page's dead narrow block.)
- **A modal `<dialog>` is centred only by the browser's `margin: auto`, which Tailwind's preflight zeroes, and it inherits text styles from wherever its button sits.** The kit's dialog primitive restores both, and a unit test over the kit pins the declarations (the `ui-design` skill, `references/method.md`). **An `.sr-only` element is absolutely positioned, so inside a table's scroll box it escapes the box and widens the page unless the box is `position: relative`.** Check a new dialog or table at phone width by measuring `document.documentElement.scrollWidth` and the dialog's bounding box, not by eye. (`2026-10-21`, every dialog in a product opened at the top left, one opened from a table's actions cell came out right-aligned and unwrapped, and five pages with `.sr-only` table headers scrolled sideways on a phone.)
- **Geometry must be read in one layout.** Several `boundingBox()` calls are several round trips, and mounting components can move between them. Collect every rect in one `page.evaluate`, retry the whole reading with `expect.poll`, and sort by `x` rather than assuming DOM order is visual order. (`2026-09-16`, late vendor components produced an overlap that never rendered.)
- **A phone-sized screenshot is not a phone-sized viewport.** Chrome on Windows will not open a window narrower than about 548 CSS px: `--window-size=390,844` renders at 548 and crops the image to 390, so a screen that fits looks broken and a screen that overflows looks fine. Set the viewport instead — Playwright's `viewport`, `Emulation.setDeviceMetricsOverride` over CDP, or an iframe of the exact width — and assert `document.documentElement.scrollWidth` against it rather than trusting the picture. (`2026-08-27`, observed while building a product's first screens.)
- **A browser test that reloads on an optimistic state cancels the write it meant to check.** Wait for the server's response, not for the pixels. **A form field can exist before the thing behind it has happened:** an identity provider's verification-code box renders while the code is still being sent; the field is the pixels, the code-preparation call is the event — wait for the call, not for the input. **The same after every navigation in the authenticated suite:** wait for the identity provider's client script to load before the first action, as a person's first click does; an action fired before it refreshes the stored session answers signed-out. (`2026-08-27`, a reload cancelled a write; `2026-08-31`, verification outran code preparation; `2026-10-24`, a monitoring product's step clicked 0.8 s after navigating, before Clerk had loaded, and failed two runs in three under a parallel review's load.)
- **Find a container that can hold its own kind by structure, not by descent.** Nest a second instance of a pattern inside the first — a disclosure in a disclosure, a list in a list item, a dialog in a panel — and every shared helper that found the first by descent (`.locator("summary")`) now matches two elements. Playwright's strict mode then fails every journey that uses the helper, mostly journeys unrelated to the change, with a locator error rather than anything about the screen that changed. Write the path out (`details.panel > summary`). A reading review cannot see this, because a strict-mode violation exists only against a rendered DOM. (`2026-09-21`, a disclosure nested inside another failed six specs on one helper.)
- **When a change alters what a polled list shows, search for the waits, not the actors.** Before the change, find every test that waits on that list — long `toHaveCount` or `toBeVisible` timeouts on its rows — whoever put the row there, including tests that seed it by a direct RPC or fixture rather than through a person's journey, which a search for related journeys cannot see. (`2026-09-25`, holding a polled list's new rows behind a count broke a spec that created its row by RPC and waited 20 s for it; the search for user journeys had found only the other one.)
## The harness's environment
- **A Playwright worker inherits the environment of the process that spawned it, and nothing after.** A token every worker needs (Clerk's testing token) has to be fetched in `globalSetup`, which runs before any worker exists; fetch it in a *setup project* and the next worker starts without it. (`2026-08-31`.)
- **An identity provider can put a screen in front of yours.** With organizations on, a new Clerk account meets the `choose-organization` task before the app, and a task-pending session is signed out as far as `auth()` is concerned. A person clicks through it in seconds; a headless sign-in cannot, so `globalSetup` lands the test accounts past it. **A sign-in that succeeds and a `waitForURL` that times out anyway is the symptom of a harness that did not.** (`2026-08-31`.)
- **A harness default decides what every existing test asserts.** Playwright defaults to `colorScheme: 'light'`; a new token set can therefore switch every suite's palette without a test edit. Pin the default for any mode the whole product renders through, and say why in the config. (`2026-09-16`, the light theme would have silently changed every capture.)
- **The developer's `.env` is a harness default too: pin every optional configuration in the shared `webServer.env`.** `next start` loads `.env` itself, and `@next/env` never overwrites a key already in `process.env`, an empty string included. So every optional or third-party variable a suite's meaning depends on — an analytics id, a demo record, a support mailbox, a paid provider's key, a feature switch — is declared in the shared module, never left to `.env`.
- **Pin the off state as an empty string**, which the code must read as unset (`environments`, `references/variables.md`: an empty string counts as unset).
- **Pin the on state as an obviously fake value** the code sends to a deterministic stand-in.
- **A comment beside each pin** says which state it asserts and where the other is covered.
- **Hold it with a unit test:** every optional key in the env schema is either pinned in `webServer.env` or named in an exemption list with its reason, so a new optional variable fails until someone decides. (`2026-11-07`, a live Q&A product: its adoption pass found nine variables pinned but the email provider's pair omitted, so a local inbox-check configuration could send real mail from gate runs.)
Unpinned, one assertion passes, fails, goes vacuous or becomes a live third-party check depending on whose machine runs it, and the failure names the assertion, not the environment. (`2026-09-20`, a landing assertion failed the hour a demo record was configured locally; `2026-09-22`, a locally configured analytics id quietly turned a cookie test into a live third-party check.)
- **Everything else writing to the shared development environment is part of the harness.** A background worker running against the development database acts on the suites' fixtures, and another session — an agent reviewing the design, a person — signed in as a test account writes into what a journey asserts. Scope development's workers away from the test accounts' workspaces (an explicit list of the workspaces they act on, which production leaves unset), and let nothing else use the test accounts while a gate runs. (`2026-10-22`, a monitoring product: its development workers picked up the suites' records at their next refresh and ran about 90 real checks per gate run, racing assertions such as "a new monitor says Not checked yet"; and a gate went red when a design-review session, driving the dashboard as test account A, created records the signed-in journey had never made.)
- **A new precondition breaks the harnesses CI does not run.** When a change adds a precondition to starting the product — a stored consent, a connection the person must make — every harness that launches a real instance must state it, and the ones outside CI fail where nobody looks. Grep for every harness that starts a real instance and make it seed the precondition; seeding it models the person's action, while skipping the assertion would hide the next real regression. Run those suites **before** the release script, not inside it. (`2026-09-25`, the remote-control product: every unit test and every CI job stayed green while two release-only suites failed on the same cause, and a third, in a suite no gate ran, was seeding the old key and failing silently.)
- **Test sign-in the way a new user meets it: with no credential on the machine.** A machine already signed in passes a broken sign-in, because the saved credential is read and the broken write is never reached. Use a machine that has none, or sign out on purpose. (`2026-09-25`, the remote-control product: a vendor CLI's update could no longer save a new sign-in on two platforms, and every machine checked looked fine because each held a credential the previous version had written. A new user is exactly the person with no credential.)
- **Never test against production data or with production credentials.** Development instance, development project, dedicated test accounts. Only `smoke` touches production, and it writes nothing. No authenticated smoke ever runs with a real user's credentials (`release-gate` § Never).
## Same-origin checks
- **A same-origin check must survive the headers a real browser sends, not a clean `Origin`.** A page served with `Referrer-Policy: no-referrer`, or a sandboxed frame, posts with `Origin: null`, even from a same-origin form or `fetch`, so an Origin-equals-host check refuses every real user while a unit test sending a tidy `Origin` stays green. **Read `Sec-Fetch-Site` first** — the browser sets it whatever the referrer policy, and it is `cross-site` for a form another site submits — and fall back to `Origin` only when no fetch metadata is sent. **Test with the header set captured from the deployed app:** `Origin: null` with `same-origin` passes, `Origin: null` with `cross-site` is refused, and `Origin` decides alone only when `Sec-Fetch-Site` is absent. (`2026-10-03`, every real sign-in through an embedded panel was refused on production, and the unit test's clean `Origin` is why it passed.)
## Generated files
- **A test can arrive broken from the tooling that wrote it.** Each layer a generated file passes through — shell heredoc, interpreter string, file — handles its own escapes and encoding, and each can rewrite the file silently: a regex written through a heredoc into a Python string had its `\b` turned into a backspace byte, because `\b` is a valid Python escape and `\[` is not, so one regex on the line could never match while its neighbour survived.
- **Generate through the fewest layers that will do** — the agent's file-write tool, not a shell into an interpreter.
- **Prefer a pin whose natural form is positive**: `toEqual([...])` fails loudly on `[]`.
- **Read the bytes produced, not the source meant**: `od -c` on the line settles it.
(`2026-09-20`, the regex above; earlier, a double-encoded em dash left two assertions that could never pass.)
- **A generated or vendored copy is checked against its source by the build and the suite**, by hash, so a stale or hand-edited copy fails before a misleading green; a generated store listing is held equal to its generator's output, and a test fails on any image reference it or its source leaves dangling (`release-gate`, `references/runbook.md`).
- **Commit messages go through a heredoc (`git commit -F -`), never `git commit -m "…"`.** Messages full of backticked identifiers meet the shell, and a backtick inside a `-m` argument is command substitution: the shell runs the word and replaces it with its output, which is usually nothing. The text is deleted *silently* — a commit in a sibling repository landed reading "Grok sends , so". Nothing warns you, and the message cannot be fixed after a push without a rewrite.
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| finishing-a-development-branchobra/superpowersUse when implementation is complete, all tests pass, and you need to decide how to integrate the work | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| systematic-debuggingobra/superpowersUse when encountering any bug, test failure, or unexpected behavior, before proposing fixes | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| test-driven-developmentobra/superpowersUse when implementing any feature or bugfix, before writing implementation code | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| skill-creatoranthropics/skillsCreate new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |