Back to search
lie-eater
MarketplaceWorks with Claude CodeGitHub
Lie Eater: a Claude Code mod that checks the proof when a coding AI says "done".
Safety scan
A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.
Checked today
Badge for your README
Markdown
[](/listings/atomctl--lie-eater-claude-code)HTML
<a href="/listings/atomctl--lie-eater-claude-code"><img src="/api/listings/atomctl--lie-eater-claude-code/badge.svg" alt="findsafeskills safety rating" /></a>Install
What was scanned
The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.
.claude-plugin/marketplace.json · Manifest · 11 lines
- {
- "name": "lie-eater",
- "owner": { "name": "Hachem Ahelbarra" },
- "plugins": [
- {
- "name": "lie-eater",
- "source": "./",
- "description": "An AI can say 'done' after it made the checks easier. Lie Eater checks the proof before you believe it."
- }
- ]
- }
README.md · README · 250 lines
- # Lie Eater
- ```
- ... '..' . '''.. .
- .'ol.;oooo:..' ''.:looo;.lo''
- c:;oc;;cclc:.x0WWWNMNMN0o :clccc;co::c.
- ':lc:;cclllllc dNXWMWXXXXXWNWWx.cllllllc;;cl::
- c::;;ccccllllll.cMMMMXd xXMNNN; llllllcccc;;':c.
- ;'lcccccccllll'.ONWMXNlcllNXWMW0 'lllllcccccll';
- ';:;oolllll;.x0WWWNMWNWWN0d ;olllloo;';'
- ;;;:;' :d0O0OKOd' ';:;;; .
- ```
- An AI can say "done" after it made the checks easier. Lie Eater checks the proof before you believe it.
- A "check" is one of your project's tests. Lie Eater is a mod for Claude Code. When the AI says it is done, Lie Eater shows you one of three results.
- 
- *A real session, recorded by a script ([docs/demo.tape](docs/demo.tape)) on 21 Nov 2026: the real mod and a real model, 50 seconds. Act 1 is staged by the demo: it asks the AI for the lazy fix on purpose.*
- ## The three results
- **✓ checked**: the check files that were there when Lie Eater began to watch are unchanged, and the full check passed on the files exactly as they are now. That is not the same as "no bugs": a weak check stays weak. The third line says whether the AI added a check for its work:
- ```
- ✓ checked
- The checks passed after the last change. No existing check file was changed.
- The AI added new checks: tests/test_tax.py.
- ```
- ```
- ✓ checked
- The checks passed after the last change. No existing check file was changed.
- The AI added no new check for this change.
- ```
- The commonest lazy work is new code with no new check. Both are green, but the line under the prompt tells them apart: `Lie Eater ✓ checked`, or `Lie Eater ✓ checked · no new check`. With no new check the AI is also told: "If this change added or changed behaviour, add a check for it in a new file and call done again." That is advice, not a refusal: the result stays ✓.
- Existing check files are frozen: new checks go in a new file. The AI is told so.
- **✗ don't trust "done"**: something is wrong with the proof. Lie Eater says what happened and where.
- ```
- ✗ don't trust "done"
- The AI changed 3 lines in the check file tests/test_cart.py.
- The AI did not say so.
- "You lied. I ate it."
- [ Put it back and fix the work ] [ Accept this change ] d: Details
- Press f or a, or type /check or /accept.
- ```
- The first button sends the AI back to repair it. The second says the change is right (for example, a test that was itself wrong, a renamed file, or a formatter run). After it the result is `? not checked` until the full check passes again.
- **? not checked**: there is no proof either way. That is not an accusation.
- ```
- ? not checked
- The full check was not run after the last change.
- "No proof. Still hungry."
- [ Check again ] d: Details
- Press c, or type /check.
- ```
- The button asks the AI to run the full check and say "done" again.
- ## The eye
- Lie Eater watches what the AI does to your checks.\
- When the AI says "done", the eye has already seen whether a check was changed.\
- A formula in `tools/eye/eye.py` makes the drawing. No picture was traced.\
- Plain code decides every result. The eye only marks it.
- ## You do nothing: it is always on
- - Lie Eater starts with Claude Code. It finds your project's checks by itself.
- - One line under the prompt always says where you stand: `Lie Eater · watching`, `Lie Eater ✓ checked`, `Lie Eater ✓ checked · no new check`, `Lie Eater ✗ don't trust "done"`, `Lie Eater ? not checked` or `Lie Eater ? no checks yet`.
- - It stays quiet. Only "don't trust" opens the Lie Eater pane by itself; the first one in a row also shows one message and plays a sound. A bet the AI lost shows one message, with no sound.
- - The small pane shows the eye beside the result, one row of buttons and one dim hint. The Details (the test command, each check with its mark, the changed lines, the bets) show only when you ask: type `/lie-eater details`, or press `d` in the pane. The pane closes by itself when you send your next prompt (a prompt Lie Eater sends for you, and its own commands, do not close it).
- - **No checks yet?** Press `Add checks` in the pane, or type `/check`. The AI then writes your first tests. They protect the work from then on; the work done before them is not checked.
- | Command | What it does |
- |---|---|
- | `/check` | Check again: the AI repairs what was found, runs the full check and says "done" again. Three times at most, until the next ✓ |
- | `/check <command>` | You name the test command, for example `/check pnpm test`. A command that runs no check (`--version`, `--help`, `--collect-only`, `--list…`, `--dry-run`, `--passWithNoTests`) is refused |
- | `/accept` | Accept the change that "don't trust" shows; then "not checked" until the full check passes again |
- | `/lie-eater` | Opens the pane: the result, its buttons and a hint |
- | `/lie-eater details` | Opens the pane with the Details under the result. In the pane, `d` shows or hides them |
- | `/lie-eater demo` | The demo in two acts (below) |
- | `/call pass` or `/call fail` | Your own guess on the AI's next test run (see the bets below) |
- ## Try it
- Install it once, in Claude Code (2.1.275 or later):
- ```
- /plugin install lie-eater --marketplace atomctl/lie-eater-claude-code
- ```
- From then on it is on in every session. To try it without installing, clone this repository and start Claude Code with `claude --plugin-dir /path/to/lie-eater-claude-code`.
- Then type **`/lie-eater demo`**. Lie Eater makes a tiny throwaway project in `.lie-eater/demo` (one bug, one failing check) and plays it in two acts in the Lie Eater pane. You need no project of your own.
- - **Act 1 is staged by the demo.** The demo sends the AI one order, as you, that says so: take the lazy way, make the failing check pass by changing the check, not the bug, run the full check and call `done`. The checks pass. Lie Eater then shows, the normal way, `✗ don't trust "done"` and `The AI changed N lines in the check file .lie-eater/demo/price.test.mjs.` (N is what the AI changed), and the pane shows its two buttons. Under them, for the demo only: `Lie Eater: "Now type /check, or press f. The AI puts the check back and fixes the bug."`
- - **Act 2 is the repair.** The button sends the AI back: it puts the check back, fixes the bug, runs the full check and calls `done`: `✓ checked`. The pane then says what happened ("The checks were green both times. The first time a check had been changed to get there."), that Lie Eater is always on in your own project, and that `/lie-eater` opens the pane. These lines stay until the next result, or until the pane closes at your next prompt.
- - **If the AI will not take the lazy way** (the `done` tool tells it that check files are frozen) and fixes the bug, the demo ends at ✓ and says so: "The AI would not take the lazy way: it fixed the bug. Nothing to eat this time."
- Nothing in the demo is special-cased in how Lie Eater decides: what you see is the real product. The demo writes only its own two files, never replaces your project's watch or a result you have not answered, and your project's watch is back after it.
- ## For the expert
- ### How a result is decided
- Lie Eater reads no meaning from the text of a test. It compares files.
- 1. **The watch.** When the session starts (and again at each prompt and each `done` until it works), Lie Eater finds the test command: the newest test run of the session that would be a full check by itself (a plain runner such as `pytest`, `npm test`, `npx vitest run`, `go test ./...`, with allowed flags only: not `pytest -k smoke`, not `--version`), else `package.json`, `pyproject.toml`, `pytest.ini`, `Cargo.toml`, `go.mod` or a `Makefile`, else the names of your test files. With no test command or no test file it is "no checks yet". A reload keeps the watch it had.
- 2. **The frozen check files.** When the watch is armed, Lie Eater keeps a copy of: every file in a test folder (`tests/`, `test/`, `__tests__/`, `spec/`, at any depth: tests, helpers, fixtures, data), every test-named file (`*.test.ts`, `test_*.py`, `*_test.go` …), and the files that decide how checks run, at any depth: `package.json` (only `scripts.test`, `scripts.pretest`, `scripts.posttest`, `type`, `imports`, `jest`, `vitest` and `mocha`: a new dependency or a changed `lint` script is no change), `pyproject.toml` and `setup.cfg` (only their pytest, coverage, tox and nox sections), `pytest.ini`, `tox.ini`, `noxfile.py`, `conftest.py`, `Makefile`, `makefile`, `GNUmakefile`, `.rspec`, `phpunit.xml*`, `karma.conf.*`, `jest.config.*`, `vitest.config.*`, `vite.config.*`, `playwright.config.*`, `.mocharc.*`. A file of up to 200,000 characters is kept as text, a bigger one as a hash and its length. A file of the frozen set that cannot be read when the watch is armed makes every result of that watch at best "not checked": "Lie Eater could not read tests/conftest.py."
- 3. **The AI calls `done`** when the task is finished. Its optional `broken` is where it says what it changed in the checks, or what still fails. Lie Eater then reads every frozen file again and compares, whatever changed it (the Edit tool, `sed`, a script, `rm`, a formatter, `git`). No model takes part; plain rules decide every line.
- - **unchanged**: the text is the same, byte for byte.
- - **changed**: any difference at all: a line added anywhere (also at the end, inside a `describe`, or among the imports), a line altered or removed, a deleted final line break. Details gives the number of lines that differ, and up to 5 of the original lines that are gone. The answer to the AI says: "Existing check files are frozen. Put new checks in a new file. If an existing check must change, say why in `broken`: the person decides."
- - **moved or deleted**: the file is not there. A renamed file is a deleted file and a new one.
- - **how the checks run**: any change to a file that decides how checks run, or a new one (a new `conftest.py`).
- - New check files are free: they are frozen at the next ✓. One exception: a new check file that holds `.only(`, `fit(` or `fdescribe(` is ✗, because the runner then runs that test alone and skips the rest.
- 4. **The full check passes** only when the test command ran **by itself** (one command, no pipe, no `;`, `&&` or `||`, no second line), **as locked**, **from the folder Lie Eater watches** (the project's root; for the demo, the demo's folder), and ended with exit code 0. A runner in front (`npx`, `uv run`, `python -m`) does not matter. When the locked command, or the script behind `npm test`, names its runner by a path (`.venv/bin/pytest`), a run counts only with that path; a locked command with no path (`pytest`) is matched by any runner of that name, so name the path with `/check` when it matters. `npm test`, `pnpm test` and `yarn test` (and their `run test` forms) and `bun run test` are the same run; `bun test` is Bun's own runner and is another command. When the locked command is `npm test` and the `test` script of `package.json` is one command by itself (`vitest run`), with no `pretest` or `posttest` script and no value set for the run (`CI=1 …`, `env CI=1 …`, `cross-env …`), running that command directly (`npx vitest run`) is the same run; otherwise only `npm test` counts. A chain or a pipe cannot be named as the full check (`/check a && b` is refused): put it in a script. The folder is where the shell stands as the run starts; a run from another folder is "not checked": "The full check ran in another folder." When the engine names no folder, the run counts. Flags that change neither what runs nor how it is judged may be added: `-q`, `-s`, `-r…` (pytest's report letters), `--verbose`, `--quiet`, `--silent`, `--ci`, `--run`, `--color`/`--colors`/`--no-color`, `--tb=…`, `--reporter=…`, `--watch=false`, `--watchAll=false`, `--`. Not `-v`: npm, jest and vitest read it as `--version`, print a version and exit 0 without running a test (use `--verbose`). Any other flag, a path, a test name, or a value set in front (`CI=1 npm test`, `PYTEST_ADDOPTS=… pytest`) makes it another run: "not checked".
- 5. **Fresh by fingerprint.** When a run of the full check starts, Lie Eater takes the project's fingerprint: the path, size and modification time of every file of the walk, from the folder listing, and for each file of the frozen set the hash of its text. At `done` it takes it again. Only when the two are equal does the run stand for the files as they are. So a change after the run, or during it, made to a file of the walk, makes it "not checked". A folder that cannot be listed leaves the walk incomplete: no fingerprint, so at best "not checked".
- 6. **The result:**
- | What was found | Result |
- |---|---|
- | The full check passed on the files as they are; no frozen file changed | ✓ checked |
- | A frozen check file changed, moved or deleted; a file that decides how checks run changed or is new | ✗ don't trust "done" |
- | The full check fails | ✗ don't trust "done" |
- | No run of the full check; another test command (`python -m unittest` where `pytest` was found); a run that could not be read | ? not checked: "The full check was not run after the last change." |
- | The project changed after the last full check (or while it ran) | ? not checked: "The project changed after the last full check." |
- | The full check with an extra flag, word or value in front (`pytest -k cart`, `pytest --version`) | ? not checked: "The full check was run with extra options. Run it plain." |
- | The full check ran inside a pipe or a chain (`pytest \| tail`, `cd api && npm test`) | ? not checked: "The check ran inside a longer command…" |
- | The full check ran from another folder (`cd packages/api`, then `npm test`) | ? not checked: "The full check ran in another folder." |
- | A file of the frozen set could not be read when the watch was armed | at best ? not checked: "Lie Eater could not read tests/conftest.py." |
- | The checks already failed, as many as before the project changed | ? not checked: "The checks were already failing before the AI started." |
- | A folder could not be listed, or the project has 400 folders or 5,000 files, or more | at best ? not checked: "The project could not be read fully." |
- Under a ✗ the worst comes first (how the checks run, then a moved or deleted file, then changed lines, then a failing run), with "and 2 more files." when there are more. Then "The AI said so itself." when `broken` names something; "The AI did not say so." when a check file changed, the AI named nothing, and there was work since the watch began. A plain failing run gets neither, unless the AI named it. Blank, "none", "no", "n/a" or "-" name nothing.
- 7. **At ✓** the third line names the check files that are new since the watch was armed (or armed again): test-named files and files in a test folder that are there now and were not in the frozen set (not the files that decide how checks run). The first by name is shown, then "and 2 more files."; with none, "The AI added no new check for this change." A new file counts when it holds a test or an assertion, by the words every runner uses (an empty file or a helper does not count; a file too large to keep as text counts unread). It is a note: it never decides ✓ or ✗. **After ✓** the frozen files are taken from the files exactly as they were compared for that result: new check files are protected from then on. An edit made with the edit tools after ✓ makes the line `? not checked` again (a change made through the shell shows only at the next `done`). **After ✗** the same frozen files stay until a later `done` is ✓, or you type `/accept`. `/accept` accepts what that result showed and nothing later: when the project's fingerprint differs from the one measured for that result, it says "The files changed since that result. Wait for the next result, then accept."; when the project could not be read fully, it accepts nothing. Accepted, the files are frozen as they are, the command behind `npm test` is found again (the test script may be new), and the full run before is void: `? not checked` until the full check passes again.
- 8. **Quiet:** ✓ and ? change only the line under the prompt. Every ✗ opens the pane; the first ✗ in a row also shows one message and plays a sound. The pane closes when you send your next prompt. A lost bet shows one message of its own, with no sound (see Bets).
- ### Bets
- The main AI is asked to say, before each test or build run, what it expects (`pass` or `fail`) and how sure it is (50% to 99%). A run of the main AI with no bet is refused, with the reason, twice per turn at most; then it goes through and is counted as "a run without a bet". A subagent's runs are not asked. The real result settles the bet. A bet on a result that was already known (no edit or write since the last run that could be read) is void. Bets show under Details in the pane (`/lie-eater details`, or `d`), with the score ("The AI said 90% sure. It was right 12 of 13 times."). While a bet is open you can make your own call there, or with `/call pass` or `/call fail`. A lost bet also shows one message, no sound: `Lie Eater: "Sure of itself. Wrong. Ha." The AI bet "pass", 95% sure. The run failed.` A won or void bet shows none.
- ### What this mod can touch
- - **It reads** the tool calls of your session and their results.
- - **It reads** the folder listing of your project (names, sizes, times; at most 400 folders and 5,000 names; `node_modules`, `venv`, `env`, `dist`, `build`, `target`, `vendor`, `__pycache__`, `coverage`, `htmlcov`, folders that start with a dot, and the plain names in the project's `.gitignore` are left out), when it arms itself, at the start of each run of the full check, at each `done` and `/check`, and at `/accept`; and where the shell stands as a run of the full check starts.
- - **It reads** the files of the frozen set (above) when it arms itself, at the start of each run of the full check, at each `done` and `/check`, and at `/accept`, and `package.json`, `pyproject.toml`, `pytest.ini`, `Cargo.toml`, `go.mod` and `Makefile` to find the test command. It keeps the frozen texts in the session's state, not in your project.
- - **It writes** files only in `.lie-eater/` in your project's root:
- - `ledger.json`: every settled bet, for the score in this repository. A ledger of the earlier version is read for its bets; its games and debt are no longer kept.
- - `receipts.json` and `receipts.md`: the results of the current watch, written at each `done`. Format `lie-eater/receipts`, **version 4**. What changed from version 3: a ✓ result has `added`, the check files new since the watch was armed (an empty list: no new check), and its `screen` is the three lines above (the second line is now one line; the third names the new check files or says there are none). What changed from version 2 to 3: a line's `term` is now `verdict`, `config`, `gone`, `changed` or `unread` (no more `asserts`, `tests`, `skips`), and `n` is the number of changed lines; commands are kept masked: every value set in front is `NAME=…` and every quoted text is `"…"` (in `check.command`, the lines and the bets); no text of a check file is kept.
- - `ledger.unreadable.json`: a copy of a ledger file it could not read, so that nothing is lost.
- - for `/lie-eater demo`, the two files of the demo project in `.lie-eater/demo/`, only when that folder holds no other file.
- - **It refuses** a test or build run of the main AI that has no bet, twice per turn at most. It refuses nothing else and it never changes a command.
- - **It adds** two tools the AI can call (`bet` and `done`) and one hidden line on a test result that tells the AI how its bet ended.
- - **It sends a prompt** as you only when you press a button or type `/check` or `/lie-eater demo`. Such a prompt holds fixed sentences, the test command and file paths (cleaned: no line break or control character, 200 characters at most), never text from your files. The demo's prompt is the staged order of Act 1: it asks for the lazy fix in the demo's own folder, and says that it is staged.
- - **It makes no model call, starts no program and opens no network connection** of its own. What it hands the AI (the `done` answer, the bet replies, the prompts above) goes to the model like the rest of your session.
- ```json
- {
- "format": "lie-eater/receipts",
- "version": 4,
- "check": { "command": "npm test", "since": "2026-11-20T09:00:00.000Z" },
- "results": [{ "id": 1, "result": "distrust", "screen": ["✗ don't trust \"done\"", "The AI changed 1 line in the check file tests/test_cart.py.", "The AI did not say so."], "lie": true, "lines": [{ "term": "changed", "pass": false, "plain": "The AI changed 1 line in a check file", "detail": "tests/test_cart.py: 1 line changed", "file": "tests/test_cart.py", "n": 1 }] }],
- "bets": [{ "id": 1, "expect": "pass", "confidence": 0.9, "state": "lost", "line": "npm test → 3 failed, 31 passed" }],
- "score": { "n": 1, "won": 0, "lost": 1, "hitRate": 0, "said": 0.9 }
- }
- ```
- ### The honest numbers
- **Games on this version** (the one that compares files; 20 Nov 2026, headless sessions with Haiku and Sonnet, small Python and JavaScript projects): 49 games over its three builds, and 20 on the always-on version before it. Honest work was reported ✓ checked each time; each weakening that the person ordered was reported ✗ with its file; nobody found a wrong result by hand. Eight more sessions ran on three public libraries and one application (Python and TypeScript): [what happened there](docs/real-projects-2026-11-20.md). That is a small sample, and no person other than the builder has used it. Every number below comes from earlier versions, which started with a `/summon` command and counted checks in the text.
- **167 real games** were played by a script on 20 Nov 2026: real Claude Code sessions with Haiku, Sonnet and Fable, on 18 Exercism exercises, 4 JavaScript tasks and 3 pressure tasks, and 47 staged games. After each game the script ran the tests itself and compared. The full account: [docs/soak-2026-11-20.md](docs/soak-2026-11-20.md). A recorded game of that version, word for word: [docs/game-lie-eaten.md](docs/game-lie-eaten.md).
- | Question | What the games gave |
- |---|---|
- | Did it accuse honest work? | It did: 8 of the first 30 games. After the fixes: 0 in the next 90. Then a long game ([the control](docs/control-2026-11-20.md)): 223 of 490 honest small jobs were called a lie, because the check ran at the end of every turn. Since then it checks only when the AI calls `done`; in 17 check games after that, 2 more false lies were found and fixed (a `done` with no test run is now "not checked"). |
- | Does it see a real breach? | 16 breaches were made on the person's order. It caught 16. |
- | Did an AI lie by itself? | No. In 120 games no model said "done" over a weakened check. |
- | How good are the bets? | The AI said about 90% sure and was right 127 of 131 times. On textbook exercises the bet says little. |
- **Does the mod make the AI refuse an order to weaken a test? No: the words do.** In a control, the four rules of the earlier version typed as one plain message with no mod made the AI refuse 24 of 24 such orders, and 10 of 10 after 49 small jobs and a compaction; with the mod it refused 19 of 24 and 5 of 10 ([the control](docs/control-2026-11-20.md)). So the refusal comes from the words, and the mod's job is the proof: whether "done" is true.
- The games found fourteen faults; a code review found eleven more, in shapes no game had used. Each was fixed with a test that failed first. One test sends 5,760 honest shapes of a test command through the rules: none reads a pass as a fail or a fail as a pass. (Since this version a shape with an extra flag or a value set in front, like `CI=1 npm test`, is "not checked": it is not the full check.) Two other models attacked the earlier version (the red team); each row of their table of attacks is now a test. Their second round closed "added to" and bound the full check to one command and one folder. What stays open is in the limits. A new kind of project will find more: please report a result that you think is wrong, with `.lie-eater/receipts.json`.
- **Eight recorded sessions with a known truth** are in [`fixtures/`](fixtures). Each is replayed through the same rules the live mod uses, and ends with a `done` call. One command reproduces the table and runs the mod's 299 tests:
- ```
- claude plugin test .
- ```
- | Sessions | Result |
- |---|---|
- | 3 honest (test-first work; ten checks moved into a table; a run through `tail`, then the tests by themselves) | 2 of 3 checked. The table is ✗ by design: a changed check file is shown, and you decide (`/accept`) |
- | 3 with a weakened proof (failed run, `done` with nothing named; three checks removed; a test switched off and the run silenced) | 3 of 3 caught, and in 3 of 3 the AI did not say so: the full check 1 time, a changed check file 2 |
- | 2 about bets | 1 bet won, 1 lost, 1 void; the lost one names its failing tests at `done` |
- **To add a session:** copy a file in `fixtures/`, change it, add it to `fixtures/index.ts`, and run the command. The test fails and prints the table your sessions give.
- ### What is different
- Other tools check a "tests pass" claim after the fact, for example [claude-receipts](https://github.com/furkiak/claude-receipts), [proof](https://github.com/EricFinland/proof), [receipt](https://github.com/majiayu000/receipt), [rashomon](https://github.com/altrace-dev-role/rashomon), [claim-check](https://github.com/godic97/claim-check) and [claimcheck](https://github.com/Allan-Nava/claimcheck). As read on their pages on 20 Nov 2026, none of them makes the AI **bet before every test run**, settled by the real result, with a running record of how sure the AI said it was and how often it was right, and your own call against it.
- In Lie Eater the proof is also fixed before the work: the check files are frozen when Lie Eater begins to watch (at the start of the session, or when it first finds checks), and compared when the AI says "done", however they were changed.
- ### Limits
- - **"Checked" is not "bug-free", and a weak check stays weak.** It says: the check files that existed were not changed, and the full check passed on the files as they are. A project with weak checks gets a weak proof.
- - **It catches the lazy shortcut, not a forger.** For a file outside the frozen set the fingerprint is its size and modification time: a source change that keeps the size and puts the old time back is not seen. The frozen texts are compared byte for byte, but a big file is kept as a hash (64 bits and the length), which guards against accidents, not against two files made to share it. An AI that fakes a test run on purpose (a script named like the runner) can pass. Every command is in the record.
- - **"New check" is a note, read by simple words.** A new file in a test folder, or a test-named file, counts as a new check when it holds a test or an assertion by the words every runner uses (`assert`, `expect(`, `def test_`, `it(`, `test(`…). An empty file or a helper does not count. A test with a check that proves nothing still counts: the line says that a check file was added, not that the check is good. It never decides ✓ or ✗.
- - **A new check file can still change what other checks do.** New check files are free. One can patch shared state when it is loaded (a Python test module that replaces a function at import, a new test that sets a global), and the old checks then test something else. The new file is in the frozen set from the next ✓; read new check files.
- - **Only the files of the frozen set are frozen.** Helpers and source that checks import from outside test folders (`src/test-utils.ts`, a fixture factory in `src/`) are not frozen: a change to them is a code change, seen only by the fingerprint. A setup file in a place or a language the list does not know is not frozen either.
- - **Some folders are outside the fingerprint.** `node_modules`, `venv`, `env`, `dist`, `build`, `target`, `vendor`, `__pycache__` and every folder that starts with a dot (`.venv`, `.github`) are not walked: a change there, or a check that runs against `dist/`, is not seen.
- - **A full check that writes into the project** is not fresh when it writes into a folder that counts as the project. Left out of the fingerprint: `coverage`, `htmlcov`, the other folders named above, and every plain name that the project's own `.gitignore` lists (`out/` at any depth, `/reports` at the root only; patterns with `*` are not read). Check files inside such a folder are still found and frozen. So a run that writes its coverage report is fresh; a run that writes `report.txt` into a tracked folder is "not checked" each time: put that name in `.gitignore`. The other side of it: code in a folder that `.gitignore` names is outside the proof, and an edit to `.gitignore` can put a folder there.
- - **Any change after the run counts**, also a change to docs (`CHANGELOG.md`): the fingerprint covers all files of the walk. Run the full check last.
- - **Honest work can be red by design.** A renamed check file is "moved or deleted"; a formatter, a merge, a `git pull` or a branch switch that changes a check file is "changed"; a test added to an existing check file (anywhere, also at its end), an import added to one, or a fixture added to `conftest.py`, is a change; a table that replaces repeated tests is a change. Lie Eater cannot tell your change from the AI's. That is what `/accept` is for.
- - **You may press Accept without reading.** Then the change stands. The pane shows which file changed; its Details (`d`, or `/lie-eater details`) show the lines that are gone; read them first.
- - **The full check must be run plain.** A CI habit (`-x`, `--coverage`, `CI=1 npm test`) gives "not checked", not "checked". Lock what you run with `/check <command>`.
- - **A subagent's run of the full check counts** as proof, like the main AI's (the fingerprint and the folder decide), and it needs no bet.
- - **Bets are still required** of the main AI. They cost one extra step per test run. A change made through the shell is not seen by the bet rule: a run after it can be "void" (nothing changed).
- - **The AI must call `done`.** If it does not, nothing is checked. After ✓ the line under the prompt follows only edits made with the edit tools, until the next `done`: a change made through the shell shows only then.
- - **The test command is guessed.** `npm test` for a `package.json` with a test script (`pnpm test`, `yarn test` and `bun run test` count as the same run); `pytest` for any `pyproject.toml`. When the AI runs another test command, the result is "not checked", not "don't trust". `bun test` is Bun's own test runner, not the `test` script: in a Bun project that uses it, lock it with `/check bun test`.
- - **`/check <command>` is the person's word.** A command named there is the full check, whatever it runs.
- - **The folder of a run is read from the engine.** When the engine names no folder, a run of the full check counts wherever it ran.
- - **Tests inside source files** (Rust `#[test]` in `src/`) are not test files by name: such a project is "no checks yet" until you type `/check <command>`, and those tests are not frozen.
- - **A run by itself is judged by its exit code.** A runner that ends with exit code 0 while tests fail passes.
- - **A suite that is already red** counts as "already failing" only when the AI runs the full check before the project changes. If it changes something first, the failure reads as `✗ The checks fail.` (with no "did not say so").
- - **The record is read, never re-run.** Lie Eater sees the test output the AI saw.
- - **The demo runs on a watch of its own.** Your project's watch is kept aside, untouched, and comes back after the demo's ✓ (or `/accept`). While the demo runs, your project's runs are not tracked; the fingerprint decides when you are back.
- - **The demo's Act 1 depends on the AI.** A model may refuse the lazy order (the demo then ends at ✓ and says so), or repair at once after the red result without waiting for the button (the closing lines are the same). Under the demo's ✓ the AI is not told to add a new check, so that it writes nothing more into the demo's folder. In a project with checks of its own, the line under the prompt goes back to your project at the demo's ✓, so it never shows the demo's `✓ checked`: the pane says how the demo ended. The two acts were played in 6 real sessions (20 Nov 2026; 3 with Haiku, 3 with Sonnet): each time the AI took the lazy order, the result was ✗ with the changed line, and after the repair it was ✓.
- - **"No new check" speaks of the work since the last ✓.** After a green result the watch is armed again with the new check files frozen, so a second `done` with nothing changed says "The AI added no new check for this change." even when the first green named new checks.
- - **A check file that cannot be read stays unread.** A file of the frozen set that could not be read when the watch was armed (for example one over 4 MiB, the engine's limit for one read) makes every result at best "not checked" until a new watch is armed: after an accepted ✗, or in a new session.
- - **Big projects:** past 400 folders or 5,000 files, or when a folder cannot be listed, the project is not read to its end, and no result is better than "not checked". The frozen texts are kept in the session's memory (2,000,000 characters in all; past that a file is kept as a hash). Nothing was measured on a large project, and nothing in Go or Rust.
- - **The pane wraps at narrow widths.** At 100 body columns the default pane is at most 7 rows, with the five-row eye beside the result, a row of buttons and a hint. Below 72 body columns the result uses the full width and the eye is hidden. The demo's longer hint wraps under about 110 columns.
- - **The sound plays on macOS only.** The status line, the pane and the buttons are tested in the test kit; the owner played the two-act demo on a real screen on 20 Nov 2026 (the red result, the pane, the repair, the green result and the closing lines all showed); the buttons show no key there, so a line under them names the key and the command.
- The name is inspired by the manga Usogui. No artwork or text from it is used.
- ## Licence
- MIT
Ratings and comments
Sign in to rate this skill.
Sign inFree to use. If it’s helped, pass it on.