# public-claims

Adopt this skill: https://proskills.md/skills/other/grit-77-done-is-a-claim-skills-public-claims

Page: https://proskills.md/skills/other/grit-77-done-is-a-claim-skills-public-claims
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: skills/public-claims/SKILL.md
size: 4553
sha: d33066b9edda8b349f84b7daad76a26ac7b30324
upstream: https://github.com/grit-77/done-is-a-claim/blob/main/skills/public-claims/SKILL.md

```text
---
name: public-claims
description: "Write and fact-check public copy so that every figure, credential, promise and command has a receipt - a source with a locator, a command that re-derives it, or the author's own words - and remove any claim without one instead of softening it. Use when drafting or reviewing a README, release notes, a launch post or thread, slides, or a website page; and whenever a draft states a number, a ranking, a credential, a promised result or a command."
---

# Public claims

**No receipt, no claim.** In public copy every figure, credential, promise and
command has a receipt. A claim without one is removed, never softened into
"about", "up to" or a vaguer label that implies the same thing.

A receipt identifies what supports the claim and how it was checked:

- a source with a locator: `path:line`, a document and section, the issuer's
  own listing;
- a command that re-derives the value on a pinned commit;
- the author's own words, with date and the exact text, supporting an
  attributed report rather than independent reproducibility.

Distinguish current reproducible results from historical or private-source
reports. For a historical result, retain the original revision, date and
evidence; a recount today measures today's state. If the source is private,
say so in the public claim and identify its type and date without exposing
the private link or material. A row can preserve the exact authorized author
report, for example, "The author reported 42 collected cases on <date>;
the underlying run is private and was not independently reproduced."
Do not turn that report into a verified current test count. If disclosure is
not authorized or adequate evidence is unavailable, omit the claim.

This skill never posts anything. Publishing is a separate decision for a human.

## Procedure

1. **Pin the reviewed revision** and write its commit at the top of the fact
   sheet. Current recounts run on it; historical claims name their own
   revision and date.
2. **Keep one fact sheet**, `FACTS.md`, beside the drafts. A row holds the
   claim, its value, receipt and verification limits. Drafts quote the sheet
   and never introduce a new fact.
3. **Find the receipt for each claim** in every draft. No receipt: delete the
   sentence and log it in the changelog.
4. **Check each figure against its stated basis.** Recount current figures on
   the pinned revision; retain and verify the source for attributed historical
   reports. For pytest cases, run `pytest --collect-only -q tests` in a clean
   checkout of the pinned commit and record its exit status and collection
   summary, with configuration and environment. Counting `def test_` lines
   counts matching definitions, not collected cases: parametrization, methods
   and collection rules can change the total. Collection also does not prove
   that the cases passed.
5. **Check every universal.** "Every", "never", "all" and "only" each need a
   receipt for the universal. When the claim is narrower, write the narrower
   sentence. Precise beats grand.
6. **Show only real output.** Quote the actual message text the tool prints;
   never write an imagined terminal session.
7. **Tag unshipped work** `[PENDING]` in drafts and keep it off public pages.
8. **Use tokens for undecided names**: `{{NAME}}`, `{{REPO_URL}}`, so one
   replace lands the final choice. A private link never appears.
9. **Check length** with tokens filled at their final length. Verify the
   platform's current counting rules and limits for the account and post
   type, including link handling; use its composer or documented counter.
10. **Keep a changelog** at the bottom of the fact sheet: what was removed,
    recounted or tagged, why, and on which revision.

## Fact sheet row

| Claim | Value | Receipt | Checked on / limits |
|---|---|---|---|
| Collected pytest cases in `tests` | <n> | `pytest --collect-only -q tests`, exit status and saved collection summary | `<commit>`, <date>, <environment>; collection only |
| Historical author report | <exact dated statement> | <authorized source and locator> | <source date/revision>; private source or not independently reproduced, if applicable |

## Done when

Every claim in every draft has a fact-sheet row that supports its actual scope:
current results re-derive on the pinned revision, and historical or private
reports carry clear attribution and verification limits. Unreceipted claims
are gone, not hedged; every `[PENDING]` tag has been re-checked; and the changelog
names the revision reviewed.
```

## File: README.md
upstream: https://github.com/grit-77/done-is-a-claim/blob/main/README.md

````text
# Done is a claim

**English** · [Türkçe](README.tr.md)

<picture>
  <source media="(prefers-reduced-motion: reduce)" srcset="assets/receipt.svg">
  <img src="assets/receipt-stamp.gif" alt="Done is a claim. A red SHOW THE RECEIPT stamp lands on the ivory cover.">
</picture>

[Replay stamp](assets/receipt-stamp.gif) · [Static cover](assets/receipt.svg)

**Your agent says “done”. What would prove it?**

An evidence-first development workflow for coding agents: **understand → plan →
implement → diagnose → review → verify → deliver**. 15 connected skills, 18
incident-backed rules, and optional tools that keep the evidence attached to the
work it tested. Small tasks take a shorter path.

[Get started](#get-started) · [Use in your project](docs/REPORTS.md) · [Follow the workflow](docs/WORKFLOW.md) · [Choose a skill](#choose-a-skill) · [Try the demo](#watch-a-false-green)

## Get started

**Recommended first use: one small task in a project you already have.**

**1. Install with your coding agent.** Give it this request:

> Install https://github.com/Grit-77/done-is-a-claim. Follow INSTALL.md, preserve
> my existing instructions and settings, verify the installation, and explain
> what changed and how I start using it. Use my current account and permissions.

**For the installing agent:** follow [INSTALL.md](INSTALL.md). Identify the
current host and installation scope, preserve existing work, verify the result,
and finish with a short explanation in the user's language.

**2. Open a fresh session in your project and choose a small task.** Include
your actual bug or change request, then add:

> Use using-done-is-a-claim for this task. Before editing, identify the observable
> result and the check that can test it. Take a proportionate path through the
> work and review. Report the actual result, tested inputs and remaining gaps.
> Continue within my existing authorization.

**3. Inspect the result, then tell us what happened.** Can you identify the
check that ran, what it established, and anything still unverified? If the
skill did not load or the check could not run, keep that visible. For an optional
saved command receipt, follow [the existing-project guide](docs/REPORTS.md).

[Share a first-use report](https://github.com/Grit-77/done-is-a-claim/issues/new?template=use-report.yml):
include your client, release or revision, task, observed result and uncertainty.
A failure or confusing step is useful feedback too. Remove private information
before sharing. Installing instructions does not enforce agent compliance.

### Manual installation

Install all skills as a native plugin:

**Claude Code**

```bash
claude plugin marketplace add Grit-77/done-is-a-claim --scope local
claude plugin install done-is-a-claim@done-is-a-claim-marketplace --scope local
```

**Codex**

```bash
codex plugin marketplace add Grit-77/done-is-a-claim
codex plugin add done-is-a-claim@done-is-a-claim-marketplace
```

Start a fresh session. In Claude Code, invoke
`/done-is-a-claim:using-done-is-a-claim`; in Codex, select
`using-done-is-a-claim` through `/skills` or the `$` skill picker.
[Plugin scope, updates and validation limits →](docs/PLUGINS.md)

Prefer project-local copies or the rules alone? Use a [toolkit clone](#watch-a-false-green):

| You use | Add to your project |
|---|---|
| Codex or an agent that reads `AGENTS.md` | Copy [AGENTS.md](AGENTS.md) to the project root. |
| Claude Code | Copy [AGENTS.md](AGENTS.md) and [CLAUDE.md](CLAUDE.md), which imports it with `@AGENTS.md`. |
| Existing instructions | Merge the relevant rules into your file. Keep your project-specific commands and constraints. |

You can start with that one rules file. Native plugin installation does not add
these rules to the adopting project's instructions.
[Installation options on macOS, Linux or Windows →](docs/INSTALL.md)

Want the workflow in your project without overwriting existing files? From this clone,
replace `../my-project` with your existing project path and preview the copy:

```bash
python tools/install_skills.py --project ../my-project --agent codex --profile workflow --dry-run
```

Then omit `--dry-run` to install. For Claude Code, use `--agent claude-code`.
Existing skill destinations are refused; your project instructions stay untouched.
Use `--list` to see profiles and individual skills. Explicit `--update` can replace
unmodified installer-owned copies while retaining backups; local edits are refused.

## Watch a false green

Try the local example with **Python 3.10+**:

```bash
git clone https://github.com/Grit-77/done-is-a-claim.git
cd done-is-a-claim
python examples/false_green.py
```

**Synthetic demo:** the verifier fails with exit **1**; the summarizer displays
its output and exits **0**. The receipt follows the verifier and says **FAIL**.
The demo itself exits **0** because it exposed the mismatch—not because the
verifier passed.

<picture>
  <source media="(prefers-reduced-motion: reduce)" srcset="assets/demo/false-green-recorded.png">
  <img src="assets/demo/false-green-recorded.gif" alt="Recorded synthetic output: verifier exit 1, summarizer exit 0, receipt FAIL. Demo exit 0 means the mismatch was demonstrated.">
</picture>

[Runnable source](examples/false_green.py) · [Static proof](assets/demo/false-green-recorded.png) · [Recording and limits](docs/demo-recording.md)

Recorded output excerpts, paced for reading. This is a synthetic demonstration,
not a production log or an agent-performance benchmark.

## One workflow, short paths

**Use it during ordinary development:** [shape a feature, implement with tests,
resolve PR feedback, and keep the task across interruptions →](docs/DAILY-WORK.md)

Start with [using-done-is-a-claim](skills/using-done-is-a-claim/SKILL.md). It routes
substantial work through planning and execution, sends unexpected results into
diagnosis, and closes review findings with fixes and fresh checks. A clear, small
change goes straight from inspection to implementation, review and verification.
Workers are optional; an unavailable reviewer is reported as a self-review limit.

[See the flow and a worked task →](docs/WORKFLOW.md)

Want to test your installation on real work? From this repository's clone, create a small broken CSV project,
let your installed skill handle it, then check the result independently:

```bash
python tools/native_smoke.py create --project ../claim-smoke
python tools/native_smoke.py verify --project ../claim-smoke --json
```

The initial independent check deliberately fails even though the starter's narrow
tests pass. The tool creates and checks the fixture; you run the agent through
your normal host and account. [Real session procedure and observed limits →](docs/NATIVE-TESTS.md)

## Check the delivered artifact

A successful copy can also deliver the wrong artifact. The
[delivery demo](examples/wrong_delivery.py) contrasts a stale copy, the correct
copy, and identical bytes that still fail to parse:

```bash
python examples/wrong_delivery.py
```

It uses temporary local fixtures. Exit zero means the traps were demonstrated,
not that a real delivery succeeded.

## Get a real receipt

[Three field notes and a real PR: what did the check actually prove? →](docs/FIELD-NOTES.md)

**Already have a project and a test command?** [Capture your check and bring a
Markdown or JSON evidence summary to your next PR →](docs/REPORTS.md). The report
separates the command's historical result from current evidence freshness.
Arguments, raw logs and filenames are omitted by default; it does not publish
anything or declare your task complete.
For CI consumers, `--format json` emits a minimal v1 projection with the same
reporter exit status. The guide lists its exact fields and disclosure limits.

Capture a command's own exit, full output and Git state with the optional local tool:

```bash
python tools/receipt.py -- python tools/run_tests.py
```

It writes a fresh `receipt.json` and `command.log` under `.local/receipts/`.
Use `--input` to fingerprint
````
