01Regole di verifica nel CLAUDE.md
adottataaggiornata di recenteaggiornata il #
perché
Un agente fa ciò che le istruzioni gli rendono facile. Senza regole scritte dichiara vittoria con una build verde, ripete un test instabile finché passa, o modifica il test invece del codice. Poche righe esplicite nel CLAUDE.md globale cambiano il comportamento predefinito di ogni sessione.
come
- Metti le regole nel
~/.claude/CLAUDE.md globale, così valgono per ogni repository, e lascia le specifiche di progetto nel CLAUDE.md del repository. - Verificare eseguendo: la skill
verify del repository quando c’è, altrimenti pilotare la vera app. - Tre tentativi, poi stop: dopo tre correzioni fallite l’agente consegna l’output dell’errore e cosa ha provato.
- Tieni i controlli fuori portata: una modifica non deve mai indebolire, nello stesso commit, i test, la configurazione di lint, la skill
verify o il REVIEW.md che la giudicano.
Estratto per il tuo CLAUDE.md
markdown
## Verification
- After any non-trivial change: run build/typecheck and relevant tests before declaring it done
- If you can't verify, say so explicitly instead of assuming it works
- Don't edit tests just to make them pass: if a test fails, understand why before touching it
- Add/update tests when changing public behavior
- **Verify by running**: if the repo has a `.claude/skills/verify` skill, run it before saying "ready for testing". Otherwise drive the real app (a browser automation tool for anything web) when the change is user-visible. Always state how the change was verified
- **Three rounds, then stop**: if a check still fails after three fix attempts, stop and bring me in with the failing output and what you tried
- **Flaky tests**: never add retries, sleeps or skips to make them pass. Find the root cause; if you can't, propose deleting the test with the reason written down, and wait for my confirmation
- **Checks are out of reach**: a change must not weaken or rewrite, in the same commit, the existing tests, lint/typecheck config, `verify` skill or `REVIEW.md` that judge it (adding new tests for new behavior is fine). If an existing check genuinely needs changing, do it in a separate commit and flag it to me
## Commit Messages
- Every commit ends with a `Verified:` trailer stating how the change was checked: `verify` (verify skill or end-to-end run), `tests` (automated tests only), `manual` (I tested it), or `none (<reason>)`. It is a verification stamp, not an attribution line
Il ciclo descritto da queste regole. sorgente Markasso
02Una skill verify in ogni repository
adottataaggiunta il #
perché
"Esegui l’app" significa una cosa diversa in ogni repository. Una skill verify lo scrive una volta sola: i controlli rapidi, come avviare il programma vero, quali flussi pilotare e cosa aspettarsi, così l’agente raccoglie prove invece di tirare a indovinare.
come
- Copia il modello in
<repo>/.claude/skills/verify/SKILL.md e sostituisci ogni segnaposto; elimina le sezioni che non servono. - Tienila in git: ignora
.claude/* ma non .claude/skills/. - Eseguila due volte di fila su un main pulito prima di fidarti: è il tuo smoke test, deve essere veloce e deterministica.
- Scrivi cosa è fuori ambito (chiamate API a pagamento, deploy, ciò che gli strumenti non vedono) e quando invece chiedere a una persona.
- Ogni nuovo progetto parte con
.claude/skills/verify dal modello, fin dal primo giorno. - Nei repository di lavoro o di clienti che non sono tuoi, tieni la skill in locale con
.git/info/exclude e non committarla mai.
Modello
markdown
---
name: verify
description: Verify a change to <PROJECT> end to end before saying "ready for testing" or committing. Runs the cheap checks first, then drives the real <app|CLI|service> and reports the evidence plus the Verified trailer value.
---
<!--
Copy it to <repo>/.claude/skills/verify/SKILL.md, replace every <PLACEHOLDER>,
delete the sections that do not apply and this comment. Make sure .claude/skills/
is tracked by git (ignore .claude/* but not .claude/skills/).
Keep it fast and deterministic: run it twice in a row on a clean main before trusting it.
-->
# Verify <PROJECT>
Run the steps in order and stop at the first failure. Fix the code, not the check.
## Rules
- Never add retries, sleeps or skips, and never edit the existing tests, lint/typecheck config or this skill to make a step pass.
- If a step still fails after three fix attempts, stop and report the failing output and what was tried.
- Clean up what you started (servers, temp dirs) even when a step fails.
## 1. Cheap checks
<typecheck command>
<lint command, check-only, no auto-fix>
<test command>
## 2. Run it
<How to start the real thing: dev server, built CLI, local service. Where it listens, how to tell it is ready, how to stop it.>
Servers: pick a free port at runtime with `--strictPort` (or equivalent), fail the wait loop if your process dies, and check an identifying marker (page title, health payload) before testing. Other sessions and agents run their own servers: never reuse or stop one you did not start.
Smoke flows (always):
1. <Flow>: <steps>. Expected: <observable result>.
2. <Flow that must fail>: <steps>. Expected: <error, exit code>.
Flows for the changed area: <where the feature map lives, e.g. docs/MANUAL.md>. Pick the flows that cover the diff and check their expected results.
Out of scope: <commands this skill must not run, e.g. paid API calls, deploys>.
## 3. Report
Reply with:
- each command run with its exit code;
- the evidence for every flow (output excerpt, screenshot path);
- the `Verified:` trailer value: `verify` when steps 1 and 2 passed, `tests` when only step 1 ran, `none (<reason>)` otherwise.
Avvio del progetto, e skill solo locali per i repository non tuoi
bash
# New project: start with a verify skill from day one.
mkdir -p .claude/skills/verify
cp <path-to-your-template>/SKILL.md .claude/skills/verify/SKILL.md
# Track the skill, ignore the rest of .claude/ (in .gitignore):
# .claude/*
# !.claude/skills/
# Work or client repo you don't own: keep the skill local, never commit it.
# .git/info/exclude works like .gitignore but is never shared.
echo ".claude/skills/verify/" >> .git/info/exclude
git status --short .claude # must print nothing
Sezione per una suite end-to-end con Playwright
markdown
## 2. End-to-end (Playwright)
Before running the suite, make sure the port in `playwright.config` is free. With `reuseExistingServer: true`, Playwright happily tests whatever already answers on that port: another project, or this project on another branch.
PORT=<port from playwright.config webServer.url>
if lsof -tiTCP:$PORT -sTCP:LISTEN >/dev/null; then
echo "port $PORT is busy: stop, do not test someone else's server"; exit 1
fi
BROWSER=none npx playwright test
- `BROWSER=none` keeps `vite --open` from opening browser windows during the run.
- `Executable doesn't exist at ...` means the browser build for this Playwright version is missing. It is setup, not a test failure: run `npx playwright install chromium`, then run the suite again. Do not count it as one of the three rounds.
- Use selectors that do not depend on the UI language (roles with stable names, `data-*` hooks), or set `use: { locale: 'en-US' }` in the config.
Esempio reale: Markasso, un’app web pilotata con Telemaco
markdown
---
name: verify
description: Verify a change to Markasso before saying "ready for testing" or committing. Runs typecheck, Biome (check only) and vitest, the MCP build when mcp/ changed, then boots the web app on a private dev server and checks it loads cleanly with Telemaco. Reports the evidence plus the Verified trailer value.
---
# Verify Markasso
Run the steps in order from the repo root and stop at the first failure. Fix the code, not the check.
## Rules
- Never add retries, sleeps or skips, and never edit the existing tests, `biome.json`, `tsconfig*.json`, `vitest.config.ts` or this skill to make a step pass.
- If a step still fails after three fix attempts, stop and report the failing output and what was tried.
- Use `pnpm lint:ci`, never `pnpm lint`: the latter rewrites files.
- Never reuse or stop a dev server you did not start: other sessions and agents run their own (5173 is usually the user's). Start your own on a free port picked at runtime and always stop it, even when a step fails.
## 1. Cheap checks
pnpm typecheck
pnpm lint:ci
pnpm test
`pnpm test` also runs `mcp/tests/`. If the diff touches `mcp/`, also build the server:
pnpm mcp:build
## 2. Boot smoke (Telemaco)
Start a private dev server on a free port and wait until it answers. The loop fails if the server dies, so a port taken in the meantime can never make you test someone else's server:
PORT=$(node -e "const s=require('net').createServer();s.listen(0,()=>{console.log(s.address().port);s.close()})")
pnpm dev --port $PORT --strictPort > <scratchpad>/markasso-dev.log 2>&1 &
PID=$!
until curl -fs -o /dev/null http://localhost:$PORT/; do
kill -0 $PID 2>/dev/null || { tail -20 <scratchpad>/markasso-dev.log; exit 1; }
sleep 0.5
done
echo $PORT
With the Telemaco MCP tools:
1. `browser_navigate` to `http://localhost:$PORT/` with `waitUntil: networkidle0`. Expected: title starts with `Markasso` (any other title means you reached a server that is not yours: stop).
2. `browser_console_messages`. Expected: no errors.
3. `browser_evaluate`:
({ canvas: !!document.getElementById('main'), toolbarButtons: document.querySelectorAll('#toolbar button').length, rectangle: !!document.querySelector('#toolbar button[title^="Rectangle"]') })
Expected: `canvas: true`, `toolbarButtons` greater than 0, `rectangle: true`.
4. `browser_close`, then stop the server:
kill $(lsof -tiTCP:$PORT -sTCP:LISTEN)
Out of scope: drawing or any interaction on the canvas. Telemaco has no layout engine (`getBoundingClientRect` returns placeholder values), so canvas hit-testing cannot be driven from it; canvas behavior is covered by the vitest suite. When the change is a visible canvas or UI behavior, say so in the report and ask the user for a manual check (`Verified: manual` once they confirm).
## 3. Report
Reply with:
- each command with its exit code, and the vitest totals;
- the Telemaco results for steps 2.1 to 2.3;
- the `Verified:` trailer value: `verify` when steps 1 and 2 passed, `tests` when only step 1 ran, `manual` when the user checked a visible change, `none (<reason>)` otherwise.
da Markasso ↗
Esempio reale: Themis, una CLI pilotata in un progetto temporaneo
markdown
---
name: verify
description: Verify a change to Themis end to end before saying "ready for testing" or committing. Runs npm run check, rebuilds dist/, then drives the real CLI (check, init, status) in a temp project and reports the evidence plus the Verified trailer value.
---
# Verify Themis
Run the steps in order from the repo root and stop at the first failure. Fix the code, not the check.
## Rules
- Never add retries, sleeps or skips, and never edit the existing tests, `biome.json`, `tsconfig*.json`, `vitest.config.ts` or this skill to make a step pass.
- If a step still fails after three fix attempts, stop and report the failing output and what was tried.
- Never delete `dist/`: `~/.local/bin/themis` links to `dist/cli/main.js`. Rebuilding in place is fine.
- Do not run commands that call agents (`plan`, `tests`, `run`, `retro`): they cost money and minutes. Their logic is covered by the vitest suite with `FakeAgentRunner`/`FakeExecutor`.
- Always remove the temp directory, even when a step fails.
## 1. Cheap checks
npm run check
(typecheck, Biome, vitest including `tests/e2e/`).
## 2. Build
npm run build
## 3. Drive the real CLI
Run in bash (the commands rely on bash arrays and `PIPESTATUS`):
bash -c '
set -u
C=(node "$PWD/dist/cli/main.js")
T=$(mktemp -d)
trap "rm -rf \"$T\"" EXIT
"${C[@]}" check examples/webhook-service/spec.md; echo "check-valid exit=$?"
printf -- "---\nthemis: 0.2\nstack: node-ts\n---\n# X\n" > "$T/bad.md"
"${C[@]}" check "$T/bad.md"; echo "check-invalid exit=$?"
cp examples/getting-started/spec.md "$T/"
cd "$T" && git init -q
"${C[@]}" init; echo "init exit=$?"
"${C[@]}" status --json; echo "status exit=$?"
ls .themis
'
Expected:
| Flow | Expected |
|---|---|
| check-valid | exit 0, `valid (6 acceptance criteria, ...)` |
| check-invalid | exit 1, errors `invalid-field`, `unsupported-version`, `no-acceptance-criteria` |
| init | exit 0, writes `.themis/agents/*.md`, `.gitignore`, installs dependencies (needs network for `npm install`), ends with `next: themis plan` |
| status | exit 0, JSON with `spec.ok: true`, `plan: "absent"`, `contract.state: "absent"` |
| .themis | contains `agents`, `guard.mjs`, `local.json`, `verify.sh` |
If the change touches a command not listed above (for example `new`, `approve`, a new flag or a new diagnostic), add a run of that command against the temp project, with its expected exit code and output, to the report.
## 4. Report
Reply with:
- each command with its exit code;
- the relevant output lines for every flow, and any deviation from the table;
- the `Verified:` trailer value: `verify` when steps 1 to 3 passed, `tests` when only step 1 ran, `none (<reason>)` otherwise.
da Themis ↗
03Un trailer Verified su ogni commit
adottataaggiunta il #
perché
A posteriori nessuno ricorda se un commit è stato eseguito, testato o solo compilato. Un trailer di una riga lo registra, e siccome none è ammesso, i commit non verificati restano onesti e facili da trovare.
come
- Chiudi ogni messaggio di commit con
Verified: verify, tests, manual o none (<reason>). - Lascia che sia il report della skill
verify a dire all’agente quale valore usare. - Interrogalo con i trailer di
git log: non serve altro.
Formato e query
bash
# The last line of every commit message says how the change was checked:
# Verified: verify verify skill or end-to-end run passed
# Verified: tests automated tests only
# Verified: manual a human tried it
# Verified: none (<reason>) not verified, and why
git commit -m "feat: add how we build guide" -m "Verified: tests"
# How was each recent commit verified?
git log -20 --format='%h %<(10,trunc)%(trailers:key=Verified,valueonly,separator=%x20) %s'
# Commits that shipped unverified, with their reason
git log --grep='^Verified: none' --format='%h %s [%(trailers:key=Verified,valueonly,separator=%x20)]'
04Un hook Stop che osserva prima di bloccare
in provanuovaaggiunta il #
perché
Le regole dicono "verifica prima di dire che hai finito", ma niente ti dice quanto spesso una sessione finisce senza farlo. Un hook Stop può misurarlo. Bloccare subito punirebbe ogni falso positivo, quindi la prima versione si limita a osservare e ad annotare ciò che ha visto.
come
- Eseguilo alla fine di ogni turno: legge il transcript della sessione e registra un verdetto per ogni repository modificato,
verify, commands, docs-only o none. - Conta solo le modifiche della sessione corrente, così altre sessioni sullo stesso repository non possono generare falsi allarmi.
- Non bloccare mai, non stampare mai, esci sempre con 0: un hook rotto non deve rompere la sessione.
- Leggi il report dopo una o due settimane, correggi i falsi positivi, e solo allora decidi se bloccare i turni che finiscono con
none.
Registrazione e report
bash
# A Stop hook that only watches: it runs at the end of every turn, never
# blocks, never prints, always exits 0. It reads the session transcript and
# appends one JSON line per repo the turn edited, with a verdict:
#
# verify the repo's `verify` skill ran after the last edit
# commands a test/build/lint/typecheck command ran after the last edit
# docs-only only documentation files were edited
# none code was edited and nothing checked it afterwards
#
# Only edits made by this session count (Edit, Write, NotebookEdit calls in
# its own transcript), so other sessions on the same repo raise no false alarms.
# Merge this into the "hooks" object of ~/.claude/settings.json, next to your
# other hooks: do not overwrite the file. The guard matters: a Stop hook that
# exits 2 sends the agent back to work, and python3 exits 2 when the script is
# missing, so a hook meant to only watch would block every turn.
{
"Stop": [
{
"hooks": [
{
"type": "command",
"command": "f=\"$HOME/.claude/hooks/verify-gate.py\"; [ -f \"$f\" ] && python3 \"$f\"; exit 0",
"timeout": 10
}
]
}
]
}
# After a week or two, read the verdicts per repo before deciding to enforce:
python3 ~/.claude/hooks/verify-gate.py --report
06Un secondo parere con Codex o opencode
in provaaggiornata di recenteaggiornata il #
perché
Un agente che rivede il proprio diff ne condivide i punti ciechi. Un secondo modello con un prompt nuovo trova bug diversi, a patto di dargli il codice e non la tua conclusione, e di trattare il suo output come un input, non come la verità.
come
- Codex è il reviewer a lungo termine per le review profonde e critiche, con una sola chiamata per review perché la sua quota è limitata; i modelli gratuiti di opencode si occupano dei diff più piccoli, delle esecuzioni di controllo e dei task circoscritti.
- Scegli il modello in base al compito: leggero per una domanda veloce, standard per un diff piccolo o medio, profondo per un branch, un piano o una sessione di debug, dove due modelli gratuiti girano in parallelo e ne confronti i risultati.
- Chiedi prima di eseguirlo, e di’ cosa invii e perché.
- Quando il repository ha un
REVIEW.md, prendilo dal branch di base, invialo e chiedi al reviewer di applicare le regole il cui trigger corrisponde al diff. - Sola lettura per default: l’agente
plan di opencode o la sandbox read-only di Codex. Scrittura solo dentro un worktree git separato. - Un subagent che lavora su un altro repository crea lì il proprio worktree con
git worktree add: l’isolamento a worktree dello strumento agent copre solo il repository della sessione. - Usa solo modelli il cui fornitore non conserva i dati e non ci addestra, e non inviare mai segreti o codice di clienti che non puoi condividere.
- Verifica ogni segnalazione sul codice, correggi ciò che è reale, e annota cosa hai scartato e perché.
Comandi
bash
# Two reviewers with different roles:
# Codex the long-term reviewer for deep and critical reviews (a branch, a plan, security);
# one call per review, its subscription quota is limited.
# opencode free models for smaller diffs, control runs and scoped tasks.
# Size the model to the task, and use only providers that keep no data and do not train on it:
# light explain a snippet, a small question, a trivial edit one small free model
# standard review of a small or medium diff, a scoped task one stronger free model
# deep branch review, debug after failed hypotheses, a plan Codex, or two free models
# in parallel, cross-checked
# Review a diff, read-only: opencode's built-in `plan` agent cannot edit files.
# If the repo has a REVIEW.md, send it from the base branch, never from the working tree.
# `git diff main` covers commits and uncommitted work; an empty diff is no review.
git diff main > /tmp/change.diff
test -s /tmp/change.diff || echo "empty diff: nothing to review"
git show main:REVIEW.md > /tmp/review-rules.md 2>/dev/null
opencode run --agent plan -m <model> \
"Review the diff in /tmp/change.diff for correctness bugs, unescaped input and missing tests. \
If /tmp/review-rules.md is not empty, apply the rules whose trigger matches a path in the diff. \
Give each finding a file:line, a severity (must-fix / should-fix / nit) and a concrete failure scenario. \
Do not edit files." > review.md
# Delegate a scoped task with write access, only inside a separate git worktree.
opencode run -w <worktree-name> -m <model> "<task, files, what is already ruled out>"
# Codex for deep or critical reviews: read-only sandbox, findings written to a file.
codex exec -s read-only -C . -o codex.md "<same review prompt>"
# `codex review --base main` is quicker but takes no rules file: prefer `codex exec`
# with the same prompt when the repo has a REVIEW.md.
07Un REVIEW.md che la modifica non può riscrivere
in provanuovaaggiunta il #
perché
Un prompt di review generico trova problemi generici. Un REVIEW.md dice al reviewer cosa si rompe in questo codice, e siccome viene sempre letto dal branch di base, una modifica non può ammorbidire le regole che la giudicano.
come
- Dai al reviewer il diff insieme a
git show <base>:REVIEW.md, mai la copia nel branch sotto review. - Ogni regola nasce da un bug reale, citando i commit che lo correggono, o da un vincolo di progetto dichiarato. Niente consigli generici.
- Rendi ogni regola verificabile da un diff: un trigger sui percorsi, un controllo concreto, e il motivo per cui esiste.
- Tienilo sotto le 15 regole circa: aggiungine o affinane una quando un bug sfugge alla review, elimina quelle che non scattano mai o producono solo rumore.
- Modifica
REVIEW.md in un commit a parte, mai insieme al codice che giudica.
Modello
markdown
<!--
Copy it to <repo>/REVIEW.md, replace the placeholders, delete this comment.
How it is used: the reviewer (Codex, opencode, /code-review) gets the diff plus
this file read from the base branch (`git show <base>:REVIEW.md`), never from
the branch under review, so a change cannot rewrite the rules that judge it.
Change REVIEW.md in its own commit, never together with the code it judges.
Writing rules:
- Every rule comes from a real bug (cite the fix commits) or a stated project
constraint (cite CLAUDE.md, an ADR, a spec). No generic advice.
- A rule must be checkable from a diff: concrete trigger paths, concrete check.
- Keep it under about 15 rules. When a bug slips through review, add or sharpen
a rule; when a rule never triggers or only produces noise, delete it.
-->
# Review guide: <PROJECT>
Check only the rules whose trigger matches a path in the diff. For each finding, name the rule (R1, R2, ...) or say "outside REVIEW.md" when it is a bug no rule covers. Report real defects with a concrete failure scenario; skip anything listed under "Do not flag".
## Rules
### R1: <short title>
Trigger: <paths or globs>
Check: <what must hold in the diff>
Why: <the failure it prevents> (fixes: <sha>, <sha> | source: <CLAUDE.md, ADR, spec section>)
## Do not flag
- Formatting, import order and lint-level style: <linter> enforces them in CI.
- <Deliberate convention that looks wrong but is intended, with its source.>
08Themis: cancelli e un contratto bloccato
adottataaggiunta il #
perché
Per lavori più grandi le regole non bastano: l’agente non deve poter spostare la porta. Themis trasforma una specifica in test di accettazione, li blocca tramite digest, e solo allora lascia scrivere agli agenti il codice che un verifier separato giudica.
come
- Scrivi la specifica: obiettivo, passi di verifica, limiti, criteri di accettazione.
- Approva il piano (cancello 1) e i test (cancello 2): approvare i test registra i digest di test, specifica, verifier e configurazione in
.themis/lock.json, e una guardia rifiuta qualsiasi modifica. - Esegui: ogni task lavora nel proprio worktree; l’exit code del verifier dice se riprovare o se è bloccato, e
max_iterations limita i tentativi. - Chiudi con una retro (cancello 3): gli errori sfuggiti diventano modifiche alle istruzioni degli agenti.
Il flusso a cancelli
bash
themis new # spec skeleton: goal, verify steps, limits, acceptance criteria
themis check # every problem with line, column and field
themis init # generates the judge: verifier + guard, no AI involved
themis plan # planner agent proposes the task graph
themis approve plan # gate 1: does the plan make sense?
themis tests # test-author agent writes tests/acceptance/
git add -A && git commit -m "themis contract"
themis approve tests # gate 2: digests of tests, spec, verifier and config go into .themis/lock.json
git add -A && git commit -m "lock contract"
themis run # each task in its own worktree, verifier exit 1 = retry, 2 = blocked
themis status # gates, tasks, iterations against max_iterations, cost
themis retro # retro agent turns misses into instruction changes
themis approve retro # gate 3: apply them, then commit .themis/agents/
da Themis ↗
La pipeline a cancelli di Themis: i controlli sono bloccati prima che il worker inizi. sorgente Markasso
05Un segreto stampato una volta è già perso
nuovaaggiunta il #
perché
Tutto ciò che un agente stampa entra nel transcript, e il transcript va al fornitore del modello. Basta un cat .env veloce o un grep troppo largo per controllare che una chiave esista, e il suo valore lascia la tua macchina; cancellare il messaggio dopo non lo riporta indietro.
come
- Scrivi la regola nel CLAUDE.md globale: mai stampare qualcosa che può contenere un segreto, quindi niente
cat, head, env, printenv, echo o grep semplice su di esso. - Controlla una chiave solo per nome o per conteggio:
grep -q, grep -c, o l’elenco dei nomi delle chiavi. - Ancora il pattern alla chiave esatta: uno troppo largo trova altre chiavi e ne stampa i valori.
- Se un valore viene stampato comunque, l’agente lo dice subito e il segreto va ruotato, non solo cancellato dalla chat.
Controlli che non stampano valori
bash
# Everything that enters the transcript goes to the model provider and cannot
# be taken back. Check secrets by name or count, never by value.
ENV_FILE=path/to/your/env/file
# Never: these print values into the conversation.
# cat "$ENV_FILE" grep TOKEN "$ENV_FILE" env printenv echo "$API_KEY"
test -r "$ENV_FILE" || echo "cannot read $ENV_FILE"
# Is the key there? Exit code only.
grep -q '^STRIPE_API_KEY=' "$ENV_FILE" && echo present || echo missing
# How many times is it defined? A count, no value.
grep -c '^STRIPE_API_KEY=' "$ENV_FILE"
# Which keys exist? Names only.
grep -o '^[A-Z_]*=' "$ENV_FILE"
# Anchor the pattern to the exact key, and still never print the line:
# grep STRIPE "$ENV_FILE" also hits STRIPE_WEBHOOK_SECRET, and prints its value
# grep -c '^STRIPE_API_KEY=' "$ENV_FILE" one key, a count, no value
# If a value does get printed: say so at once and rotate the secret.