xout

X out the AI behavior you never want again.

Quickstart · Every rule proves itself · The map · Commands · Why trust it

_{Read in: English · 한국어 · Live explanation}

Your coding agent shows two concrete ways it could behave. You X out the wrong one. Two minutes and 15 X's later, the surviving choices are compiled into 8 local rules that Claude Code loads from CLAUDE.md.

uvx xout --lang en

That's it. The whole session runs right in your terminal. X things out for about 2 minutes. Your agent gets 8 rules.

_{Nothing above is staged - the recorder photographs a live session, so every pair and rule on screen is the engine's real output.}

No cloud. No telemetry. No LLM calls. One-line rollback.

v1.0.1 · Python 3.10–3.14 · MIT · zero third-party runtime packages

pip install xout
xout

python3 -m venv .venv
.venv/bin/python -m pip install xout
.venv/bin/xout

How it works

1. You X out the behavior you hate, across three real scenes: a routine bugfix, a new feature, and a risky production migration. Each pair shows two concrete agent behaviors - ask first vs act first, standard library vs install-a-package, rehearse the migration vs trust a re-read.

2. xout compiles the survivors into 8 executable rules, written atomically under ~/.claude/xout/ with evidence and provenance. And when your X's diverge between routine and irreversible work, the rule compiles with that condition attached:

   Write a short plan first, then proceed immediately. However, for hard-to-reverse work like deletes, pushes, deploys, and migrations, always get approval before executing.

   That condition is not a template. It exists because you X'd differently in the migration scene. No interview-based tool can produce it.

3. You apply with one keystroke. The completion screen asks "apply now?" - saying yes adds exactly one owned @import line to ~/.claude/CLAUDE.md. xout undo removes only that line.

Repeat the request that used to annoy you in a fresh Claude Code session and watch the rule hold. When it ever feels stale, xout again.

Every rule can prove itself

xout why traces any rule back to the exact X's that created it:

$ xout why autonomy --lang en
[Autonomy]
rule: Write a short plan first, then proceed immediately. However, ... get approval before executing.
state: discriminated / source: your X
evidence:
  - X'd ask_first in the routine-work scene (scn-bugfix) (session a3f2c9d1)
  - X'd act_then_report in the hard-to-reverse-work scene (scn-risky) (session a3f2c9d1)

A rule you can't trace is a rule you can't trust. Every xout rule carries its receipts.

Sessions run in English with --lang en (pairs, rules, and screen text); the default without the flag is Korean. The event ledger is language-neutral either way.

What you get

After the fifteenth X, three files land under ~/.claude/xout/:

Rules you confirmed by X'ing are labeled confirmed; defaults xout guessed without asking you are honestly labeled guessed and queued for a quick re-pick. Nothing is ever activated without your explicit yes.

(Popper 1.x landed the same files as POPPER.md and settings.popper.json under ~/.claude/popper/; xout migrates them automatically on first run.)

The map

Eight axes, measured across three scenes. Five axes are measured in both contexts, so they can fork on the routine/irreversible boundary - with evidence.

These eight axes weren't invented in a vacuum, and neither were the defaults. We surveyed 100+ high-star (10k-240k+) prompt and agent projects - shipped system prompts of codex/gemini-cli/Devin, the AGENTS.md files of rust/node/pytorch/transformers, community rules collections - and kept receipts: verbatim quotes, verified star counts, per-axis tallies, all in docs/mined-prior.md. Six of eight defaults matched the field's mode; two didn't and were corrected. And your own environment is a source too: xout mine reads the rule files you already have, with file:line receipts.

One more pair

You already know how this works. Two behaviors, one X:

(1) You write CLAUDE.md from memory. The rules have no provenance, apply one-size-fits-all to a bugfix and a production migration alike, and drift silently until the agent annoys you again.

(2) You cross out behaviors you have actually seen and hated. Every rule traces to your X's, forks on the routine/irreversible boundary only where your X's diverged, rolls back by one receipt-proofed line, and gets re-struck in two minutes when it goes stale.

That X is the whole product.

Commands

Why you can trust it

• Local only. No LLM calls, no telemetry, no cookies, no network during a session.
• Crash-safe. Append-only ledger with atomic writes: interrupt anywhere, resume anywhere, land exactly once.
• Reversible. Activation is one owned import line; xout undo removes only what xout can prove it wrote.
• Honest. A kept behavior is "not crossed out yet," never "proven right." Guessed defaults are labeled as guesses.

xout demands evidence from every rule, so its own claims file receipts in the same shape:

claim: interrupt anywhere, resume anywhere, land exactly once
evidence:
  - the suite kills sessions mid-strike and replays the ledger from disk -
    the reconstructed state is identical every time
  - duplicate sessions are rejected; landing is atomic behind content hashes
  - the full suite (400+ tests) on every commit, Python 3.10-3.14,
    macOS/Linux/Windows

claim: xout cannot delete a line it cannot prove it wrote
evidence:
  - before touching ~/.claude/CLAUDE.md it records a receipt - the file's
    prefix hash and the exact byte where its one line landed
  - xout undo re-verifies that receipt first; if the file changed around
    the line, it refuses instead of guessing

claim: honesty applies to xout's own defects
evidence:
  - while dogfooding the English pack, we caught xout why printing
    "rule: None" - it read the wrong manifest key
  - the defect is on the record in CHANGELOG.md; the fix landed with a
    regression test in the same commit

Claude Code plugin & Agent Skills

xout also runs inside Claude Code as a conversation: /xout:xout shows each behavior pair in chat, you pick the one to X, and the agent records only your explicit choice. /xout:xout status, /xout:xout undo work the same way.

Or install the same skill through the open Agent Skills ecosystem - one command, any supported agent:

npx skills@latest add brnyxx/xout

python3 verify_checksums.py SHA256SUMS \
  --only xout-plugin-1.0.1.zip verify_checksums.py
DEST="$HOME/.local/share/xout-plugin-1.0.1"
test ! -e "$DEST" || { echo "destination already exists: $DEST" >&2; exit 1; }
python3 -m zipfile -e xout-plugin-1.0.1.zip "$DEST"
claude plugin marketplace add "$DEST"
claude plugin install xout@xout-marketplace

Remove

xout undo        # deactivate: removes the one owned import line

Your rules and event history stay in ~/.claude/xout/ (yours to keep or delete). Uninstalling the package never touches them.

Development

python3 -m pip install -e '.[test,release]'
python3 -m pytest tests/ -q

CI covers Python 3.10-3.14 on macOS, Linux, and Windows. Releases ship wheel, sdist, plugin ZIP, SHA256SUMS, and artifact provenance.

Credits

The /xout skill installs through the open Agent Skills ecosystem (MIT) and follows the SKILL.md conventions that mattpocock/skills (MIT) established. Everything beneath the skill - the append-only event ledger, the pure-fold compiler, the sealed preregistration - is original to xout.

MIT © 2026 Brian Kim.