grit

Files (15)

• AUDIT.md
• HOOKS.md
• LEDGER.md
• METHOD.md
• SKILL.md
• grit-gates.yml
• dispatch-check.mjs · scripts/
• gate-check.mjs · scripts/
• gate-lint.mjs · scripts/
• check-supervisor.mjs · scripts/lib/
• dispatch.mjs · scripts/lib/
• gates.mjs · scripts/lib/
• process-tree.mjs · scripts/lib/
• regex-worker.mjs · scripts/lib/
• stop-hook.mjs · scripts/

SKILL.md (first lines)

# Grit (user-invoked)

Write the acceptance-gate ledger before implementation starts, then hold the finished work to it.

## Contract

```yaml
contract:
  invocation: user
  thesis: evidence
  verbs: [read, write-repo, write-host, execute]
  scope: owns
  trace: ledger
```

## When to invoke

- The user asks for completion discipline, or wants to be sure work is actually done, not just reported done
- A work item or PM artifact is substantial enough that a green build or a clean run is not evidence it met its acceptance criteria
- A pipeline needs an evidence ledger in place before implementation begins

## Procedure

1. Author the ledger from the acceptance criteria before any implementation starts. One gate per criterion, each tagged with one of the five dimensions — see `LEDGER.md`.
2. Fix the verification depth. A depth the user states is taken as given; otherwise recommend one from the rubric in `METHOD.md` and record which of the two produced it. Execution shape — loop, graph, or hybrid — stays with `conduct`; grit decides only how finely done is decomposed into gates.
3. Implement between the gates using the four passes in `METHOD.md`: complete, harden, hunt, polish.
4. Verify with the checker, `scripts/gate-check.mjs`, in order: `--status` to read the ledger without executing anything, then a dry run to see the resolved commands, then `--approve` once a human has read each command, then `--reverify` on returned work. Lint the ledger with `scripts/gate-lint.mjs` before the first run; `grit-gates.yml` is the continuous-integration backstop.
5. Close with the final audit in `AUDIT.md` — every gate met, unmet, or abandoned, with evidence.
6. Enforce per tool as described in `HOOKS.md`.
7. Two capabilities in this skill sit outside the working tree, and both are deliberate. Approvals live at `~/.grit/approved`, outside version control, and the checker refuses to run when that path resolves inside the repository, so a change that edits repository files cannot also grant itself the right to execute. A CHECK is a command the ledger supplies rather than one this skill wrote, and a human reads and approves each one before it runs — approval is consent to run one reviewed command, not a sandbox, because the check holds the ambient access of whoever ran it.

Append the trace entry under the `ledger` kind as the passes run: what each of the four passes found and discarded, and any gate whose CHECK was repaired because it measured the wrong thing. The ledger records the verdict; a gate that went red, was found to be checking the wrong file, and then passed is indistinguishable in it from one that passed first time.

## Stop conditions

- Implementation started before the ledger exists → stop and write the ledger first
- An acceptance criterion no command can decide → record it as a manual gate with recorded evidence, never as a runnable gate with a weakened check
- Unmet gates remain at close → the work is reported unfinished, never softened by editing EXPECT
- A check the approving human cannot read and understand → it does not get approved

## Output contract

```yaml
ledger: GATES.md
depth: 6
depth_source: user-stated|recommended
audit:
  met: 9
  unmet: 1
  abandoned: 1
  gates:
    - id: G1
      status: met
      evidence: "exit=0; shell=/bin/sh; cwd=/repo; EXPECT=matched; output-sha256=6bf5...; output-bytes=9"
    - id: G7
      status: unmet
      evidence: "exit=1; shell=/bin/sh; cwd=/repo; EXPECT=no match; output-sha256=1a2b...; output-bytes=142"
    - id: G9
      status: abandoned
      evidence: "criterion infeasible: no source system exposes this figure; signed off by <name>, 2026-08-30"
```

## Sibling skills

- `shakedown` — the verification doctrine grit makes runnable
- `sdlc` — the gated loop grit's ledgers report into
- `slice` — writes the work-item acceptance criteria grit turns into gates
- `conduct` — owns execution shape; grit owns verification depth only

From akmolsinc/skills, Apache-2.0.

More from akmolsinc/skills