typefox/agent-skills/write-like-me

Write like me

Machine-written drafts carry a recognizable voice that is not the user's. This skill moves a draft toward the user's own voice as the step before their manual polish — never a replacement for it — using a style-pattern DB: a JSON profile of the user's writing habits, each habit backed by counts and verbatim quotes from documents the user wrote by hand. The DB format is in references/db-schema.md; the dimensions along which habits are recorded in references/taxonomy.md. Those files say author where this one says user — the same person, the one whose hand-written documents the profile is built from and who is asking for the rewrite.

The picture behind both modes. The taxonomy's dimensions are the axes of a style space, and a profile marks out the region of it the user's own writing occupies: one measured band per axis (a range, not a point), with the tier saying how well that band is known. Extraction draws the region; processing moves a draft into it, axis by axis and in whichever direction each axis is off — machine prose has a region of its own, and where the two overlap there is nothing to do. It is a map, not a metric: the axes carry different units and there is no distance to compute, so the comparison table ranks rows one at a time instead of scoring the document as a whole. Two founding rules follow. The user's profile has veto power: a coordinate already inside the region does not move, even where the construction is machine-typical — a user who writes with em dashes keeps them. Converge on rates, not extremes: the region is a box drawn around real documents, so its corners — every habit at once, each at its maximum — are precisely the places none of the user's writing occupies; that corner is caricature, and aiming at measured rates keeps a rewrite out of it. Inside the region a rewrite is free: strictness decides which axes it may move along at all, tone decides where along them to aim.

Modes

Extraction is never implicit. A processing request with no profile does not turn into an extraction, and an extraction request without document pointers ("learn my style", "set this up for me") gets one question back — which documents, by path — and stops there. The skill does not scan disks or guess which files the user wrote: the corpus is the user's claim of authorship, and only the user can make it. Extraction writes the DB; processing only reads it.

Before either mode: the profile

1. Locate. Use the path the request names, otherwise the default $HOME/.agents/write-like-me/user-style.json.
2. Missing profile in process mode → ask, deliver no rewrite. A rewrite without a profile is a generic "humanize" pass — the caricature this skill exists to avoid — unless the user chooses it knowingly, so reply with the path you checked and this choice, through the agent's built-in question tool where it has one and in the reply otherwise, then end the turn:

• AI-only run (Modes): the machine's habits come out and nothing of anyone's voice goes in.
• Extract first: gather 8 or more documents you wrote by hand — roughly 6,000 words; blog posts, emails, docs, notes; sole-authored; mixed lengths. Ask for extraction with the paths, for example: _"write-like-me: extract my style from ~/writing/posts/.md and ~/writing/emails/.txt"_ — the paths are required. Review the rendered profile when asked, then repeat the rewrite request.

An AI-only run the request already asked for skips steps 1–4. In extract mode a missing file at the default path is the normal starting state; replacing a profile that is there has its own rules (technique.md, Step 6) — the short of it is that the old one is never gone.

1. Version check. Run python3 scripts/styledb.py info PROFILE (script paths in this file are relative to the skill directory; PROFILE is absolute — see Scripts). Exit 0: proceed. Exit 2: the DB is older than the skill — apply references/migration.md first. Exit 3: the DB is newer than this skill — stop and tell the user to update the skill. A DB with partial: true is an unmerged extraction part; refuse it and point at the merge command in technique.md.
2. Review status. review.status: pending means the user never confirmed the profile. Proceed, but say so in the report and offer the review round.

The AI DB. Processing (bar a profile-only run) also reads the skill's own AI style-pattern DB, data/ai-style-patterns.json (path relative to the skill directory): its rows are the AI-evidence column of the comparison table, measured in the same run (--db PROFILE --db data/ai-style-patterns.json). Give it the same version check (info); it must have kind: ai and partial: false. It ships with the skill and is written by neither mode — if it is missing or fails its checks, the rewrite proceeds with the built-in ai_* counters of scripts/textstats.py as fallback evidence, and the report says so.

Strictness settings (process mode)

Every pattern carries an evidence tier (1 strong, 2 moderate, 3 weak; rules in db-schema.md). The setting picks which tiers may drive a rewrite:

A softer setting leaves more machine voice in place; a harder one risks applying a habit the corpus only weakly supports. Tiers gate which patterns are eligible and nothing else: a row inside the ceiling is worked as hard on soft as on hard, in both directions, so a light touch is a shorter list of rows and not a lighter hand on each. The gap between draft and profile still decides the order of work. What no setting ever licenses is inventing material — that line sits between substitution and manufacture, is the same at every setting, and is drawn in Step 3 of references/processing.md. Patterns dropped by the setting are listed in the report so the user sees what a harder run would touch.

Tone steering (process mode)

Strictness is one dial, tone the other: strictness says how much evidence an edit needs, tone says which end of the user's own range to aim for. A request like "more formal", "warmer, less clinical", or "keep it factual but friendly" is written down as a short tone brief — the axes named, where the user wants this document on each, one sentence of intent — and carried through every step, including into chunk subagents. No request means no brief, and the profile's rates stay the targets. The brief steers selection among the forms the profile attests and never reaches past them: where a request needs a register the corpus does not contain, the report says so instead of inventing it. (A register is the document type each corpus document is tagged with — article, email, docs, note — and the profile's only record of how formal the user gets.) The brief's shape, the axes, and the four precedence rules — among them the one case in which tone outranks the do-not-touch veto — are in references/processing.md, Tone steering.

Process mode

The procedure is references/processing.md; read it before Step 1. It defines the verdicts and marks measure prints, the table classes, the rule-derivation rules, the invariants, the convergence criteria, and the report template; where this spine and the reference disagree, the reference is right, and a change to one belongs in both. Its spine, per input document:

1. Measure — python3 scripts/textstats.py measure INPUT --db PROFILE --db data/ai-style-patterns.json --sort-gap --setting SETTING --register REGISTER. The output is the agenda: every measurable profile row with a verdict, class, and gap, the setting's [manual] marks, one folded line each for the rows the input is too short for and the rows its register sets aside, and the judged patterns to read for under read for these.
2. Compare — the three-way table (AI evidence / draft / user), adding what no counter sees: the AI-evidence column, the judged patterns, an example per row, the tone brief's targets.
3. Derive rules — one per rewrite row, removals and additions alike; replacements come from the profile's evidence, displaces, and instead references, never from invention; targets are the user's rates, read per register where a description splits them, shifted inside the range by the tone brief.
4. Fix invariants — facts, structure, subject vocabulary, and who did what stay as the input has them; ask once which earlier manual decisions must survive.
5. Rewrite the whole body — rhythm and paragraph shape do not respond to sentence patching.
6. Converge — re-measure and run python3 scripts/structure_check.py INPUT REWRITTEN, with targeted edits until no rewrite row still reads absent or gap and the structure check has no errors. A non-zero exit is a gate, and every row left outside the range is named in the report with its reason.
7. Hand over — text that lives in this session comes back printed in the reply; a file input gets <name>.styled.<ext> beside it, never overwritten unless asked. The report's measured sections are printed by textstats.py measure INPUT REWRITTEN --db … --report-table and transcribed from it rather than recalled; a short input gets one line, and the report on request.

A single-DB run (Modes) walks the same spine with one --db on the measure line; what each step drops is owned by references/processing.md, Single-DB runs.

Inputs beyond ~3,000 words, or several documents at once, are processed in section-aligned chunks by subagents that receive the same rule set and the same tone brief; measurement, rules, and convergence stay on the whole document.

Extract mode

The procedure is references/technique.md; read it before starting. Its six founding rules — evidence-paired patterns only, reading discovers and counters rank, rates not extremes, absences are data, nothing confidential, subject vocabulary is content — shape every step, and the DB fields and tier rules are in references/db-schema.md. Where this spine and the reference disagree, the reference is right, and a change to one belongs in both. Its spine: