Skip to content
Skills Library
Programming · Review & audit

correct

/correct

Close a piece of engineering work: record it as an evidence ledger, then turn every mistake that escaped into a check that fails on it (a driver assertion, a check.sh command, a gate.sh rule, a lint, a test, or a hook), proven failing on the mistake and passing on the fix. Use after resolving, disproving, reviewing, or investigating an issue, PR, incident, or agent run; when backfilling an old session; when a review finding escaped; when a papercut has a probable fix; or when someone says make sure this never happens again. Do not use to fix the mistake itself, to write release notes, or to pr

Repository
skills ↗
Licence
MIT
Last repository change
16.10.2026

Assessment and security

90/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
7
Scripts
2
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 16.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What to check before installing
  • 2 scripts in this package. Review them before installing, as Claude may execute them.

Scripts: scripts/resolve-source-root.mjs, scripts/work-item.mjs

What it does and when to use it

Close a piece of engineering work: record it as an evidence ledger, then turn every mistake that escaped into a check that fails on it (a driver assertion, a check.sh command, a gate.sh rule, a lint, a test, or a hook), proven failing on the mistake and passing on the fix. Use after resolving, disproving, reviewing, or investigating an issue, PR, incident, or agent run; when backfilling an old session; when a review finding escaped; when a papercut has a probable fix; or when someone says make sure this never happens again. Do not use to fix the mistake itself, to write release notes, or to pr

Original author description

Close a piece of engineering work: record it as an evidence ledger, then turn every mistake that escaped into a check that fails on it (a driver assertion, a check.sh command, a gate.sh rule, a lint, a test, or a hook), proven failing on the mistake and passing on the fix. Use after resolving, disproving, reviewing, or investigating an issue, PR, incident, or agent run; when backfilling an old session; when a review finding escaped; when a papercut has a probable fix; or when someone says make sure this never happens again. Do not use to fix the mistake itself, to write release notes, or to pr

How it works

  1. Canonical write root
  2. 1. Record the case
  3. 2. Pin each mistake
  4. 3. Pick the cheapest enforcer that would have caught it
  5. 4. Write it and see it fail
  6. 5. Link it
  7. Rules
Original SKILL.md headings · 50 lines, 547 words
SKILL.md preview
---
name: correct
description: "Close a piece of engineering work: record it as an evidence ledger, then turn every mistake that escaped into a check that fails on it (a driver assertion, a check.sh command, a gate.sh rule, a lint, a test, or a hook), proven failing on the mistake and passing on the fix. Use after resolving, disproving, reviewing, or investigating an issue, PR, incident, or agent run; when backfilling an old session; when a review finding escaped; when a papercut has a probable fix; or when someone says make sure this never happens again. Do not use to fix the mistake itself, to write release notes, or to promote a lesson straight into a skill."
compatibility: "Requires access to the work evidence and git. Writing a case requires an authorized destination. Driver and check.sh enforcers require a .agents/verify kit (verify-setup)."
---

# Correct

A lesson that lives in prose gets read and skipped. A lesson that lives in a check fails the next time. Correct does two things in order: it records what happened, then it moves each escaped mistake from the first kind to the second.

## Canonical write root

Before writing, run the packaged `scripts/resolve-source-root.mjs`, which honors `RAILLY_SKILLS_REPO`. Never write a case, eval, or log into the current repo's `.agents/skills`, `.claude/skills`, another installed skill copy, or the target repository. Enforcers are the exception: they belong in the target repo's `.agents/verify/` or its own checks.

## 1. Record the case

Follow [the case ledger method](references/case-ledger.md): bound one case, build the ledger with claim classes, assign independent statuses for validation, human review, maintainer acceptance, and delivery, extract the lesson, pass the confidentiality gate, and write it to `cases/<repo>/` using [the template](references/template.md).

**Complete when:** the case validates and every escaped mistake is listed with its evidence.

## 2. Pin each mistake

For every mistake that escaped a step, name it as an observable state, not a feeling: the command, input, or tree where it happened, and what was wrong. If no observable signal exists, write `Enforcer: none: <reason>` and stop for that mistake.

## 3. Pick the cheapest enforcer that would have caught it

| Level | Enforcer | Catches |
|---|---|---|
| 1 | assertion in an existing `drive/<feature>.sh` | wrong behavior on a surface already driven |
| 2 | new driver plus feature file | behavior on a surface nobody drove |
| 3 | command in `check.sh`, a lint, or a test | statically detectable patterns |
| 4 | `gate.sh` rule | diff shapes that recur across repos |
| 5 | hook in the agent settings | agent actions, not code |

A mistake that already has an enforcer and happened again moves one level up. Record why the lower level missed it.

## 4. Write it and see it fail

Recreate the mistaken state: revert the fix (`git revert --no-commit <sha>` or `git apply -R`), restore the input, or replay the command. Run the enforcer and see it fail with a message that names the mistake. Restore the fixed state and see it pass. Save both outputs. An enforcer never seen failing does not count. When the original state cannot be recreated, build the smallest synthetic reproduction of the same mechanism and say so.

## 5. Link it

- Add a row to the target repo's `.agents/verify/ENFORCERS.md`: rule, enforcer, origin.
- Set the case's `Enforcer: check: <path or command>`.
- For a papercut, replace its line with a pointer to the enforcer, or delete it if the fix shipped.

Report the case path, each mistake, the level chosen and why, the failing and passing outputs, and the files changed. Label each claim measured, inferred, or guess.

## Rules

- One mistake, one enforcer. Batches hide which check guards what.
- Never weaken an existing check to make a new one pass. A check that flags correct code is a bug in the check.
- Hooks are a last resort: they slow every session, so use them only for agent actions.
- A case may propose a lesson for a skill; it never edits an installed skill. Promotion is a separate reviewed change.
Files in this package (7)
  • SKILL.md 4 KB
  • evals/evals.json 5 KB
  • evals/triggers.json 2 KB
  • references/case-ledger.md 4 KB
  • references/template.md 1 KB
  • scripts/resolve-source-root.mjs 1 KB
  • scripts/work-item.mjs 1 KB

Versions

RepositoryScoreLicence
This page · railly/skills90MIT
Calvin-LLC/skills100MIT
smarzban/agent-skills100MIT
SammyLin/skills100MIT
workerstack/repo100MIT
arjitj2/open-pstack100MIT
r3dbars/transcripted100MIT
haowjy/creative-writing-skills100Apache-2.0
workerstack/clients100MIT

Database snapshot: 13.11.2026 · package version 9cbfeec9e191 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100fix-with-checks
    Use when fixing a review finding or a CI failure whose kind is listed under "Mistakes that keep coming back" in AGENTS.md, or when the same mistake shows up a second time. The fix then includes the check that would have caught it - a lint rule, a Semgrep rule with examples, a…
  • 90mistake-to-constraint
    Use when a mistake repeats. Encode it as the strongest guard — type or runtime, lint, test, directory convention, then a rules line — and log it in CONSTRAINTS.md.
  • 100add-rule
    Turn a code-owner correction (or a recurring mistake) into a durable rule - the right conventions-doc edit, and a real failing lint guard whenever the rule is mechanically checkable. This is the self-improving loop the factory leans on - when something goes rogue, capture it so…
  • 100learn
    Turns an incident or mistake from a session into a durable rule with a mechanism (test, hook, ratchet or check) in the current project, and drafts a protocol issue when the lesson is generic. Use after an incident is fixed, when the user says "this must not happen again",…
  • 100agents-correct
    Find the mistakes agents keep repeating in a repo and make each one impossible, trying architecture first, then types, lint, tests, and docs last. Use when the operator keeps correcting the same mistake, or for /agents-correct.
  • 90taste-to-checks
    Turn a review correction we keep making on agent output into something that runs on its own, a test, lint rule, hook, CI step or project rule, so the miss does not come back next session. Use when we keep correcting agents on the same mistake (import order, naming, a forbidden…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.