Skip to content
Skills Library
Personal productivity · Review & audit

errata

/errata

Correct what was written wrong — the binding line rewritten in place, the record it came from appended to and never touched, both carrying the evidence that overturned it. Use when a run, a file, or the user contradicts something already written in a work file, a plan's contract, the glossary, or the decision index; when a pinned value or a stated fact turns out not to hold; or when another skill needs the correction discipline.

Licence
MIT
Last repository change
03.10.2026

Assessment and security

100/ 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.
Content35 / 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
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

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

Licence

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

What it does and when to use it

Correct what was written wrong — the binding line rewritten in place, the record it came from appended to and never touched, both carrying the evidence that overturned it. Use when a run, a file, or the user contradicts something already written in a work file, a plan's contract, the glossary, or the decision index; when a pinned value or a stated fact turns out not to hold; or when another skill needs the correction discipline.

Original author description

Correct what was written wrong — the binding line rewritten in place, the record it came from appended to and never touched, both carrying the evidence that overturned it. Use when a run, a file, or the user contradicts something already written in a work file, a plan's contract, the glossary, or the decision index; when a pinned value or a stated fact turns out not to hold; or when another skill needs the correction discipline.

How it works

  1. The test
  2. The three moves
  3. The discipline
  4. What this skill is not
Original SKILL.md headings · 60 lines, 956 words
SKILL.md preview
---
name: errata
description: "Correct what was written wrong — the binding line rewritten in place, the record it came from appended to and never touched, both carrying the evidence that overturned it. Use when a run, a file, or the user contradicts something already written in a work file, a plan's contract, the glossary, or the decision index; when a pinned value or a stated fact turns out not to hold; or when another skill needs the correction discipline."
---

# Errata

Every stage writes at the moment of action, which is the only way a record is honest and also why some of what gets written is wrong: a fact its instrument could not see, a number pinned on a machine that later changes. What it cannot be allowed to do is compound: a wrong line in a work file is read by every session after it, believed because the file outranks memory, and built on.

The concept: **the layer that binds gets corrected; the layer that records gets appended to.**

## The test

One question sorts any line into its layer: **would a cold session act differently because of this line?**

- **Yes — it binds.** The snapshot, the work's `CONTRACT.md`, `.genius/DECIDED.md`, `CONTEXT.md`, `DESIGN.md`, `ARCHITECTURE.md`, `.genius/BACKLOG.md`'s seeds, the `## Working Genius` section. A wrong line here is an instruction, and it gets rewritten in place.
- **No — it records.** Everything in the log (a work's root `<slug>.log.md` and its `log/` branches, `.genius/BACKLOG.log.md`), and every file at `stage: done`. Append the correction; never edit the line, because the record is the evidence of what a session believed when it acted, and an edited one can no longer explain the work that was built on it. ⚠ A rule about correcting, not a freeze on routing: a done snapshot still gets compacted by `/compact`, because nothing there is wrong, only misfiled. What stays forbidden at done is rewriting a line because it turned out to be false.

A fact that was wrong is usually in both, and both get handled — the binding copy rewritten, the record it came from annotated.

## The three moves

**Correct — it was wrong when it was written.** Rewrite the binding copy. Append to the record: what was written, what is true, what overturned it, and what made it wrong.

```markdown
> **Corrected 2026-08-17** — "no headless browser in this project" was wrong:
> Chromium is installed at `/opt/pw-browsers/chromium`, off `PATH`. Slice 3's
> `npx playwright --version` found it. The check was `which chromium`, which
> reads `PATH` and nothing else.
```

**Supersede — it was right, and the world moved.** The binding copy takes the new value; the record keeps the old one and gains a pointer to what replaced it.

```markdown
> **Superseded 2026-08-17** — the 200ms budget held until the batch endpoint
> existed; slice 5 measured 340ms and the contract now pins 400ms.
```

Supersede is for a single fact or value. When the work's *shape* moved — criteria, scope, slices, seams — that is a contract version bump (`genius-file` skill): the new version replaces the old whole, and the annotation lands in the old version's log entry. Correcting a reshaped plan line by line builds the scar tissue versioning exists to prevent.

**Retire — it is neither wrong nor stale; it has no reader left.** A criterion whose slice was reshaped away, a convention for a seam that no longer exists. Remove it from the binding copy, and say in the record why it left.

```markdown
> **Retired 2026-08-17** — criterion 3 went with the slice it belonged to when
> slice 4 was reshaped (slice 4's entry has the reshape). Nothing replaced it.
```

## The discipline

- **Only evidence overturns what is written.** A command's output read in this session, a file read at a named place, a sentence the user said. A re-read that merely feels wrong is a second unexamined judgement wearing a correction's clothes and outranking the first. Where the evidence is not in yet, go get it; where it can't be got, write a question, not a correction.
- **The correction lands where the reader already looks.** An erratum that exists only in the record is one nobody reads, and the wrong line goes on being obeyed.
- **Every correction carries its source** — which run, which slice, which file, which words from the user. A correction that can't be traced is a new claim.
- **A corrected fact carries the scope it should have had.** Most wrong facts are true of an instrument and were written as true of the project: restate them with the instrument inside — `nothing named chromium on PATH`, not `no headless browser` — or the same wrong line comes back from the same blind check.
- **Inline, at the moment the contradiction lands.** Later is a chore someone has to remember, and this one never gets remembered. A slice's corrections ride the commit that closes it.
- **A decision is not corrected here.** A settled decision that now looks wrong goes back to `/discern` with the drift as ammunition; overturning it is a fight. What moves here is what a finished fight settled — the index line following its new record (`decision-record` skill).

## What this skill is not

Not a cleanup pass on the log: nothing there is compressed or tidied, because a kill-reason shortened to a verdict has been destroyed. The snapshot's compaction at closes is the `genius-file` skill's own discipline, lossless under its invariant.

Not a second home for corrections: no `ERRATA.md`, nothing a reader has to know to go and check — every correction lives in the two places the wrong line already lived.

Not a deletion tool. A line removed without its retirement note leaves a hole that reads exactly like a stage that never ran. Nothing is removed silently, including something you wrote an hour ago. Tenacity's close-out distillation — and `/distill`, its retroactive form — is the one carve-out: a single announced move on work that is finished and verified; while work is in flight, no log loses a line, and nothing leaves a binding copy without the record saying where it went or why.

Versions

RepositoryScoreLicence
This page · donald-ada/workinggenius100MIT
danielmiessler/LifeOS95MIT

Database snapshot: 13.11.2026 · package version aac178c9ef13 (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

No similar skills in the database.

Feedback and reports

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