DevReceipt · Claude Code plugin

Your agent says it is tested.
DevReceipt shows whether that is true.

For every change: what was demonstrably checked, and what was not.

Tests, typecheck, lint, build and the coverage of the changed lines, each after the last change. Plus reviews by a second model and the risky commands of the agent. As a Claude Code plugin, with no setup. DevReceipt sends nothing anywhere.

Claude Code plugin · Local-first · 49 EUR once, 12 months of updates included
Not open for purchase yet. Currently in beta, on request.

What was checked in feat/invoice-export against develop, 4 commits

- 1 existing test changed after failing, before passing
- 1 failed test run not run again
- Tests: passed before later changes to 2 files
- Lint: passed, 1 changed file not in a run after its last change
…
Excerpt. The whole block is under Example.

“Tests green” is in the chat.
Whether it is true is nowhere.

A claim, not an observation

The agent writes “tests green” itself. Whether and when the tests ran, nobody checks.

The run came before the last change

A green run says nothing about code changed after it. Often the agent touched three more files after the run.

Nobody checks it afterwards

With hundreds of commits a week, nobody reads the history. The reviewer believes it or retraces everything.

This is what a block looks like.

What was checked in feat/invoice-export against develop, 4 commits

- 1 existing test changed after failing, before passing
- 1 failed test run not run again
- Tests: passed before later changes to 2 files
- Lint: passed, 1 changed file not in a run after its last change
- Build: no run recorded after the changes
- Typecheck: passed after the last change
- Coverage: 62% of changed lines run (41 of 66)
- Requirement: linked, Invoice export as CSV (plan from 2026-10-21)

All details: devreceipt pr --no-commit

That is the whole output. Ten lines at most, the details folded below.

Open points come first. Here: a test was changed after it failed. A failed run was not run again. The tests ran before two more files changed.

Branch and numbers are an example. The lines are word for word what /devreceipt prints.

Three steps.
One of them is your normal work.

01

Install the plugin

Two commands. No init, no account, no configuration. You get them with your beta access.

02

Work as before

A hook records what the agent changes, which checks it runs and which risky commands it tries. Paths, checksums and results, never file contents. Commands are redacted before they are stored.

03

Look before it goes out

Before the merge, /devreceipt in the session. Before the release, /devreceipt:release. For the pull request, devreceipt pr prints the block as markdown.

On your own, before the release.
In a team, in the pull request.

Solo: your own branches into develop

You merge your own branches into develop. Before the release, /devreceipt:release shows every branch since the last release, with its checks as they were at the merge. Open ones first.

You see which branch was green after its last change and which failed run was not run again.

It finds merges by the message “Merge branch …”. Squashes and fast-forwards are not in the list.

Optional: the merge gate. Once you turn it on with /devreceipt:setup, Claude Code asks you before the agent merges a branch with open points into develop, main or master. You decide. It is the one exception to “DevReceipt never blocks”, and it is off until you turn it on.

Team: the block in the pull request

devreceipt pr prints the block for the pull request description. Open points first, the evidence folded.

The reviewer sees in ten seconds whether they can trust the change or where to look themselves. They do not need DevReceipt for that.

Four statuses. Each has one fixed meaning.

Tests, typecheck, lint and build each get one of these statuses. A check the repository does not have set up gets no line of its own. The details name it once.

checked

The check ran after the last change of every file it covers, and passed.

stale

The check passed, but files it covers changed afterwards. The result is about an older state.

not checked

No check ran after the last change, it failed, or it did not run on every changed file.

not observed

The last change of a file was not recorded, for example by hand or in a session without the hook. Then the block says nothing about it.

Coverage of the changed lines

The share of the changed lines that a test run executed after their last change. One number per pull request.

It comes from the report your tests write: lcov, istanbul JSON or coverage.py XML. When the report is older than the change, the block says so.

Warning signs

  • A test was changed after it failed, and passed afterwards.
  • A failed run was not run again.
  • Tests were skipped.

Evidence the agent cannot write.
Reviews and risky commands beside it.

Checks DevReceipt runs itself

You approve a check once, in your own terminal. The agent cannot give that approval. From then on DevReceipt runs the check itself and keeps its result. The agent never writes a result.

Results are only added, never overwritten. An edit made afterwards, by hand or with the agent's normal tools, shows. With --reverify, DevReceipt runs the checks again and names what differs from the first result.

Your GATES.md

If you keep a GATES.md in the Unlazy format, DevReceipt reads it, and the scopes under .unlazy/ as a tree. Each gate runs like any other check once you approved it. A ticked box does not count as passed.

An abandoned gate is listed in the block with its reason. It never counts as passed.

Reviews by a second model

A review by Codex or another model is a category of its own, kept apart from human review. Reviews from the Codex plugin for Claude Code are recorded automatically.

Every finding gets a decision: accepted with the change that takes it up, or rejected with a reason. DevReceipt records whether a person or the agent decided, with the history. The block shows four numbers per review: findings, decided by a person, decided by the agent, open.

Risky commands

When the agent tries rm -rf, git push --force, DROP TABLE or a similar command, DevReceipt records it. It does not block it.

The block lists each one with its level, high or medium, and the command text. Secrets in it are blacked out. Whether the command ran and what it did, the block does not claim.

DevReceipt says what was checked.
Not whether the code is right.

No verdict on the code

DevReceipt does not check code and does not review it. It never says code is correct. A passing run means: the tests passed at that moment.

No verdict on who wrote it

It does not say whether a person or an agent wrote the code.

No guessing

What was not recorded reads “not observed”. Every line in the block has to be true. A gap is named, not filled.

Known limits

Only agents with a hook are recorded, today Claude Code. Checks a person or CI runs outside DevReceipt, it does not see. A run from before a rebase onto a newer base stays “checked” when it came after the last change of the branch's own files; the details say so. Files in .gitignore and outside the repository are not found when a shell command changes them. The log is a file in the repository: anyone with write access can change it, and nothing in it is signed. The results of the checks DevReceipt runs show an edit made by hand or with the agent's normal tools. A script of the agent's own could rewrite them; running the checks again with --reverify is the control.

The log lives in your repository.
Nowhere else.

The hook writes to your repository's git directory. devreceipt pr commits the log under .devreceipt/ as a commit of its own. It goes wherever you push your repository, and nowhere else. DevReceipt has no server and no account.

Test commands and risky commands are cut down along an allowlist. Everything else becomes [REDACTED]: values after flags such as --token, variables, URLs, absolute paths.

The checks DevReceipt runs itself keep their complete output, and each recorded review keeps its text. Both stay in .devreceipt/evidence/ in your checkout, a folder excluded from Git, because the output can hold secrets. Your approvals are in ~/.devreceipt/approved/ on your machine.

Recorded:

  • Paths
  • Checksums
  • Kind of command
  • Exit code
  • Test counts
  • Risky commands, redacted

Never in the log:

  • File contents
  • Diffs
  • Command output

Claude Code, Git, macOS or Linux.

DevReceipt runs as a plugin in Claude Code and reads your Git repository.

Codex sessions are not recorded today. Their session files hold commands with their exit codes; an adapter for them has been examined, not built. Whether Codex records file edits with a path is open. Until then, work done with Codex reads as changed without a record. Reviews by Codex are recorded, from the Codex plugin for Claude Code.

  • Claude Code
  • Git
  • macOS
  • Linux

Buy once.
No subscription.

49 EURonce, per developer

Included: 12 months of all updates. After that, the installed version keeps working.

Compatibility with new Claude Code versions is kept after that, too. Only new features need a renewal: 12 months for 25 EUR, optional, no subscription.

No subscription, no account. Your license key comes by email.

Not open for purchase yet. Currently in beta, on request.

Request beta access

Team edition

The same checks as a merge condition in CI. In the works.

Ask by email: kontakt@kigazon.com.

Frequently asked questions

Does DevReceipt slow down my sessions?

Barely. An agent's shell command waits about 0.08 seconds for the hook on average: 36 to 38 ms for read-only lines, 85 to 94 ms with the file check. Measured on a repository with 10,262 files. The rest runs in the background. The hook ends itself after 8 seconds at most and does not stop or steer the session. The one exception is the merge gate, if you turn it on.

What happens on a rebase?

A rebase replays committed content. DevReceipt does not count that as a new change. A run that came after the last change of the branch's own files stays checked. The details then say: base moved after the last run. A git checkout or reset that changes files makes those files not observed.

Does it work retroactively?

Yes, as far as Claude Code's transcripts reach. devreceipt pr reads the session transcripts in ~/.claude/projects for work the hook did not record, also from before the install. Those entries are marked imported. Claude Code deletes transcripts after 30 days by default. Which files a shell command changed cannot be known afterwards.

What if the agent starts tests through the shell instead of a tool?

That is the normal case. DevReceipt recognises a test run by its shell command: npm test, pnpm test, yarn test, node --test, vitest, jest, pytest, go test, cargo test, also after npx or VAR=value. A test run under another name is an ordinary shell command; testPatterns in .devreceipt/config.json replaces the list. When the test is part of a longer command line, its exit code only counts when it is the last command. Files a shell command changes are found by git status before and after the command.

Do I need coverage?

No. Without a coverage report the block says: Coverage: not measured. Every other line stays the same. DevReceipt does not make a report on its own. It reads reports your tests write: lcov, istanbul JSON or coverage.py XML.

What happens after 12 months?

The installed version keeps working and stays compatible with new Claude Code versions. Only new features need a renewal: 12 months for 25 EUR, optional, no subscription.

Try DevReceipt before you buy.

Purchase is not open yet. If you want to use DevReceipt in your Claude Code sessions, request beta access. I will get back to you personally.

Requirements: Claude Code, Git, macOS or Linux.

Operating system

I only use your details for your beta request (Art. 6(1)(b) GDPR). The message is sent through the mail server of my hosting provider All-Inkl (Germany) to my Google Workspace mailbox and deleted once it has been dealt with. Details in the privacy policy (in German).