carryover.
A pamphlet & a playpen — v0.1 · in development

Carry over what matters.
Let the rest fall away.

Between the heedless sibling dumping slop by the gigabyte and the self-righteous guard hedging every sentence into nothing — there is a third way: present, opinionated, accountable. This is the manual.

arxiv:2308.05567 · ancestor built from ~/.claude/projects offline-first

Two failure modes are eating your output.

AI assistance fails along two axes, and the cure for one is the poison for the other. Hygiene is the practice of refusing both.

Mode A

The heedless sibling

Ships ten thousand tokens of plausible filler. Doesn't read the existing code. Refactors what wasn't asked, invents files that don't exist, claims success without testing. Volume substitutes for thought.

Tell: long answers, no questions, every suggestion novel.

Mode B

The obsessive guard

Hedges every sentence. Refuses dual-use. Lectures on safety when asked for a regex. Demands ten clarifying questions before writing one line. Attrition substitutes for judgement.

Tell: meta-commentary, scope-bargaining, qualified assertions.

Fig. 1 — Slop on both sides; signal in the middle. The narrow channel widens with practice.

Hygiene practices for the responsible agent.

Nine principles. Cribbed honestly from the discipline of writing software, the discipline of writing prose, and the discipline of not lying to yourself.


  1. Specification before code.

    The hard part is figuring out what to build. Slow on the what so you can move fast on the how. Boosterism — generating plausible code at speed — is the enemy of the work, not its accelerant.

    Patterns: 3. Instruction-setting · 5. Reasoning

  2. Slop is the default; signal is the discipline.

    Without effort, generated output trends toward verbose, ungrounded, undifferentiated filler. Hygiene means deciding what counts as signal, refusing to ship the rest, and naming the difference out loud.

    Patterns: 5. Reasoning · 4. Artifact usage · 10. Promptset

  3. Provenance, or it didn't happen.

    Every generated artifact carries its lineage: repo path, git commit, session locator, timestamp. Anonymous output is slop with better manners. If the trail home is missing, the work isn't real yet.

    Patterns: 4. Artifact usage

  4. Carry over what matters.

    The cost of re-establishing context every session compounds silently. Pin the load-bearing decisions before they vanish into scrollback. Snapshot the states worth keeping. Discard the rest with intent — not by forgetting.

    Patterns: 9. Inference streams · 2. Engagement

  5. Repos are continuity, not ceremony.

    Anything with ongoing identity belongs in a real git repo — preferably private, preferably remote. Folders rot; repos remember. A directory full of generated artifacts and no history is a future grief.

    Patterns: 4. Artifact usage · 11. Vessel

  6. Refuse two-sided dishonesty.

    Don't fake confidence you don't have. Don't manufacture caveats you don't mean. Hedge for cause, not for cover. "I'm not sure" is signal; "as a large language model" is theatre.

    Patterns: 6. Legalistic · 7. Emotional

  7. Drift is data.

    Conversations wander. That's information about your thinking — not a bug to suppress. Surface the drift, learn from it, decide what to pull back to the centre and what to let go.

    Patterns: 2. Engagement · 9. Inference streams

  8. Build before believing.

    Make it work end-to-end on real data before deciding it's good. A demo with placeholder content lies about every dimension it doesn't exercise. If you can't run it on the messy real thing, you haven't built it yet.

    Patterns: 5. Reasoning · 4. Artifact usage

  9. The user is steward, not consumer.

    You are not a passive recipient of model output. You shape what gets remembered, what gets discarded, what ships and what doesn't. The tools — pins, snapshots, hygiene scores — exist to give you that grip. Use them.

    Patterns: 3. Instruction-setting · 8. Interaction

Each principle has its characteristic violations. The patterns are the diagnostic companion — eleven failure scopes with sitrep, sharp critique, reweave path, and one-shot recovery for each, plus the cross-pattern matrix that names which failures travel together.

Read the patterns

Reading the card.

Each project earns a hygiene grade from signals you can change. Every number on the card traces back to a manifesto principle. Nothing here is a black box.

  1. 1

    Project & cadence

    Project name (derived from the conversation's cwd), session count, days since last activity. The shape of your engagement.

  2. 2

    The grade

    A composite letter A–F drawn from the metrics below plus repo/provenance state. Tuned to reward sustained, low-slop, high-continuity work in tracked repos. Single-session projects cap at A− because no carryover discipline has been observed yet.

  3. 3

    Continuity

    Average keyword overlap (Jaccard) between consecutive sessions in this project. High means you picked up where you left off; low means each session started cold. — Principle IV.

  4. 4

    Slop ratio

    Fraction of assistant chars matching hedge patterns ("as an AI", "I'd be happy to", "of course!"…). Counted by length, so longer hedges weigh more. The list is editable. — Principle II.

  5. 5

    Drift events

    Sessions of more than 15 messages where the first-N user keywords share less than 15% Jaccard with the last-N. Drift isn't a bug, it's data — the count tells you how often the thread wandered. — Principle VII.

  6. 6

    Tags

    Categorical signals about state: whether the project's cwd is a git repo, has a remote, ships a provenance.json, or has gone stale. Clickable in the playpen. — Principle III. V.

Editable. Hedge list, score weights, drift threshold — all top-of-file constants in tools/carryover.swift. Tune to your taste, rerun, see the deltas. Hygiene is opinionated by construction; ours is one calibration, not the calibration.

Score your conversations. Earn the carryover.

A gamified instrument for the practice above. Every project earns a hygiene grade based on what it carried, what it dropped, and how much slop it shipped.

Drop your corpus.json or ·
Don't have one yet? Run swift tools/carryover.swift in this repo to generate it from your ~/.claude/projects/.
murmur
11 sessions · 7d
A−
Carryover82%
Slop ratio0.11
Drift events2
Pin streak5
repo · private provenance · ok ontology · drift-tracked
atanor
6 sessions · 14d
B
Carryover61%
Slop ratio0.24
Drift events4
Pin streak2
INTENT · written repo · pending sibling-scope · unclear
quicksilver
9 sessions · 21d
C−
Carryover38%
Slop ratio0.41
Drift events9
Pin streak0
policy · 3 violations control-plane · unauthed provenance · absent
Coming next: pin individual spans · commit snapshots · export digest as markdown · cross-project topic graph