agentleFS
ryanportfolioryanportfolio/Harness-Firmware/.claude/skills/gauntlet/SKILL.md

gauntlet

Skill1 starsChanged 9 days agoMITView on GitHub

Only on explicit /gauntlet: draft → dare → final draft → why → rewrite → arena → commit, stop for /merge. Skills fully; other artifacts need declared apply method + real check.

19 other projects use a version of this.

Adopted by

Most recently taken up by

The file

We split this skill into the rules it gives an agent

8 rules. 0 are common, 3 are distinctive, and 5 are very specific to this project.

  • 0

    Common

    Most of the 12 edited versions we read keep these.

  • 3

    Distinctive

    This author's own choices. Worth a look.

  • 5

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  • could be automatic: a setting could enforce it
  1. Distinctive:

    Use only the sections this file names.

    line 19
  2. Very specific:

    Write it through the artifact's usual create route (addskill for a skill, writing for prose, the repo's normal path for code or design), …

    line 38
  3. Very specific:

    Read dare's SKILL.md and follow its "Orchestration" section with its D, A, R and E subsections, and its "Boundaries".

    line 42
  4. Very specific:

    Read arena's SKILL.md and follow all of it, with arena/ as its folder:

    line 64
  5. Distinctive:

    Before Stage 7, scan the final for repo rules the criteria do not cover: commands valid in the shell the runtime uses, no machine-specific …

    line 73
  6. Distinctive:

    Run the real check. A failure goes back to the arena base for a fix.

    line 77
  7. Very specific:

    Never push, open a PR, merge or deploy.

    line 87
  8. Very specific:

    Never skip dare, and never edit dare, why or arena during a run.

    line 88

“Common” is measured: kept by at least 6 in 10 of the 12 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Gauntlet

One command for the quality chain the owner ran by hand on a skill build: first-principles pass (dare), final draft, one fresh reviewer (why), rewrite, competing versions judged blind (arena), then a commit that waits for /merge. The owner typing /gauntlet authorizes every stage below for this run, including dare's four steps, which the owner otherwise starts by typing /dare.

Skip it for small edits, a single recommendation to pressure-test (why), a problem with no artifact yet to build (dare alone), or work whose candidates cannot be tested. The one measured run (a skill, ui-quality) took 14 Claude agent runs, 2 Codex runs and about 1 hour 40 minutes including owner waits, half of it in arena.

Gauntlet does not review code as code. /merge's Codex review still runs on the result; on the measured run it found six real defects the chain had missed.

Requirements

  • A fresh-context Agent tool. Without one, stop before the contract: every stage depends on it.
  • The called skills, read at run time: dare, why, arena. Look in the repo's .claude/skills/<name>/SKILL.md first, then ~/.claude/skills/<name>/SKILL.md. Missing one, stop and name it. Record the path and SHA-256 of each file used in state.md.
  • Use only the sections this file names. If a named heading is missing from a called skill, stop and say which; never guess its replacement.

Run folder

.tmp/gauntlet/<slug>/ in the repo that holds the artifact (in place for a non-repo artifact), with dare/, why/ and arena/ inside. Slug from the artifact name; an existing folder gets -2, -3. state.md records: current stage, contract version, artifact path, branch and worktree, called-skill paths and hashes, every gate decision in the owner's words. Write it at each stage boundary; re-read it after compaction or on resume and continue from the recorded stage.

Stage 0: intake and contract

  1. Find the artifact. A path or the conversation names it; if none exists yet, the owner's brief is the input and Stage 1 runs.
  2. Decide where edits happen. An artifact already on a branch or open PR: that branch, in its worktree. Another repo artifact: a new worktree on freshly fetched origin/<default>, placed as the repo's rules require. A non-repo artifact: in place, with the original copied to the run folder first.
  3. Fix the apply method and the real check:
    • Skill: candidates are applied by fresh agents to at least one saved case and one unlike live case. Fix one saved case per mode the acceptance conditions name (an audit mode gets a page with planted defects, a build mode gets a task brief plus a list of required outcomes, such as states covered, decisions saved and checks run). A mode without a case is waived by the owner at Gate 1 in their own words, or listed as untested in the report.
    • Saved cases are built now, after Gate 1 and before dare, by a fresh agent, so dare's tests and arena share them. Its answer key (planted defects for an audit case, required outcomes for a build case) goes to parent/key.md in the run folder, outside every folder a candidate or applicant reads; the contract names the case, never the key. The agent holds back about a third of the planted defects in parent/key-held.md. The parent does not read the held-back file; dare's tests, the final draft and the rewrite work from key.md only, and arena's judge scores against both files.
    • Real check for a skill: the repo's skill checks. In Harness Firmware repos: for a skill registered native in .agents/skill-modes.json, once the final replaces both runtime copies, sync-codex-skills.mjs --baseline <name> (a disabled skill has no port and skips this step); then, for every skill, --check, test-codex-contract.mjs, and the template manifest check where it exists. A drift or registration warning counts as a failure even though the script exits 0.
    • Any other type: the owner states how a candidate gets applied and one real check (tests, build, render, measurement). Without both, refuse the run. Label the run experimental in state.md and the report.
  4. Draft contract.md, version 1, from the owner's words only: goal, constraints, authorization, acceptance conditions, apply method, real check. No preferred solution, no assessment. Show it. Gate 1: wait for the owner's OK. Only the owner amends it; keep earlier versions. Every later dispatch receives it verbatim.

Stage 1: first draft (only when none exists)

Write it through the artifact's usual create route (addskill for a skill, writing for prose, the repo's normal path for code or design), held to the contract. Then continue.

Stage 2: dare

Read dare's SKILL.md and follow its "Orchestration" section with its D, A, R and E subsections, and its "Boundaries". This stage changes three things:

  • The contract is contract.md from Stage 0; do not write a second one.
  • Problem statement for D, saved as dare/problem.md: what this artifact must achieve and how it is built, with the draft's path. Artifacts go to dare/, not .tmp/dare/.
  • Gate 2: stop only when D names a deeper problem; otherwise record "none" in state.md and continue. Gate 3: A's audit table; always stop and wait, never take dare's unattended path. In chat show the load-bearing rows (facts the draft gets wrong, gaps, unknowns) and a count of the rest; the full table stays in dare/audit.md.

E's runnable tests execute as dare says, against parent/key.md only. A test that needs a fresh agent applying the skill to a case runs inside arena's application runs instead; record it as deferred in dare/report.md. Unmatched findings in E's output may be held-back defects: check them for false positives, but do not add them to the draft as targets. Skip dare's "Output" section: no stop for a single next action and no writing-plans hand-off. Write dare/report.md with the audit table, solutions, test results and the owner's reclassifications, then continue.

Stage 3: final draft

Rewrite the artifact from the dare report, held to the contract. In final-draft-notes.md, mark each audit entry that changed the draft and each solution taken or left, with the reason.

Stage 4: why

Read why's SKILL.md and run its Steps 2 and 3 only, on the final draft: ground the facts the draft leans on, then one fresh reviewer that gets the draft and contract.md, not the conversation. Skip Step 4 and self-run's wait for an answer. Save the reviewer's findings and your grounding to why/findings.md.

Stage 5: rewrite

Fold the findings in as you judge best, held to the contract. In why/applied.md, mark each finding taken or left, with the reason.

Stage 6: arena

Read arena's SKILL.md and follow all of it, with arena/ as its folder:

  • The rewritten draft is baseline c0.
  • criteria.md comes from a fresh agent that gets contract.md, the artifact type and the apply method, before any candidate starts. The parent edits a criterion only to make it checkable, and logs the change.
  • Candidates are applied as Stage 0 fixed: for a skill, fresh application runs, each seeing only its lettered candidate and the case. Dare tests deferred to arena run here. The parent copies both key files into judge/, and the judge scores the application outputs against them.
  • A non-base candidate's tested fix for a defect the base still has is a repair, not one of arena's one or two ideas per candidate. Take it, or list it in the report as a known defect.

Arena's own rerun limit and authorization rules hold. Its final artifact replaces the draft at the artifact's path; for a skill with a Codex port, it replaces both runtime copies.

Before Stage 7, scan the final for repo rules the criteria do not cover: commands valid in the shell the runtime uses, no machine-specific paths in anything that ships, and the repo's writing rules. Fix what the scan finds.

Stage 7: check and stop

  1. Run the real check. A failure goes back to the arena base for a fix; run the check again. Report what still fails rather than shipping it.
  2. Repo artifact: stage explicit paths and commit on the branch. Do not push. If merge mode is on in this session, continue into the merge loop. Otherwise stop with one line: type /merge to push, open or update the PR, run the Codex review loop and merge.
  3. Non-repo artifact: stop at the final file path.

Report

Contract version; each stage's artifact path and outcome; gate decisions in the owner's words; the dare audit summary; why findings taken and left; arena's worker table, verdict and grafts; real-check commands and results; held-back defects caught per candidate; modes left untested; experimental label if set; the next step, with a note that /merge's Codex review has not yet run.

Boundaries

  • Never push, open a PR, merge or deploy. /merge does that, started by the owner.
  • Never skip dare, and never edit dare, why or arena during a run.
  • Each called skill's model, fresh-context and browser rules apply inside its stage. Never claim a stage ran isolated when it did not.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.