How it works
From your writing to your rewrite
Six steps, in order. The engineering behind them is at the bottom, for anyone who wants it.
- 1
Give Timbro writing you actually wrote
An essay, an email, a post — a few pieces you had a hand in.
- 2
It builds a Voice Profile
Sentence length and how much it varies, how you connect ideas, punctuation, how paragraphs open and close.
- 3
Paste an AI draft
From ChatGPT, Claude, or anywhere else.
- 4
Timbro rewrites toward your patterns
Your measurements become the targets, instead of a general idea of good prose.
- 5
Facts are checked against the source
Numbers, dates, quotations and citations are compared back to your draft, both ways.
- 6
You review the changes
Your original stays beside the rewrite with a paragraph-level diff. Nothing is accepted for you.
Privacy
Your writing stays yours
A tool you paste unpublished work into has to be specific about what happens to it. Four commitments, each of which is a property of how the software is built.
- You can delete any of it
- A single rewrite from your history, one writing sample, a whole Voice Profile, or the account itself. Deleting the account takes the documents, samples and profiles with it rather than leaving them orphaned in a table somewhere.
- Nothing you write trains anything
- Your documents and your writing samples are not used to train or fine-tune a model, and they are not sold or shared. They exist to do the rewrite you asked for and to be there when you come back for it.
- Full documents are never logged
- Logs carry counts, timings and error codes — the things needed to tell whether the system is working. The text of your document is not among them, by rule and not by habit.
- Nothing sits at a public URL
- There are no share links and no public pages for your documents. Access is restricted to your own account and enforced in more than one place, so one failure is not enough to expose anything.
What that cannot cover: rewriting means sending your document to the model that rewrites it, and there is no version of this product where that does not happen. That is the one place your text goes.
Six stages, and what each one is for
Two of these stages never call a model. That is not a cost decision — a measurement is reproducible and a judgement is not, so anything that can be computed is computed.
- 01No model call
Read and measure
Your document is split into blocks, and roughly twenty style signals are computed from it.
Every signal is a measurement turned into a severity between 0 and 1 against an explicit threshold, not a yes-or-no flag: how far sentence lengths spread around their mean, how often sentences open the same way, transition and hedge density, corporate filler, nominalisation load, paragraph symmetry, restatement, and more.
- 02Local + model
Record what must not change
Everything countable is extracted before a single word is rewritten.
Numbers, percentages, currency, dates, years, quotations, citations, URLs, email addresses, acronyms and load-bearing hedges are found by pattern matching. This layer always runs and is authoritative, because comparing strings is a far more reliable check than asking a model whether it preserved your figures.
- 03No model call
Plan the rewrite
The plan is derived from the measurements, deterministically, before any rewriting happens.
Each directive traces back to a specific signal, so the instruction the model receives is about your document — the words that are being overused, the average your sentence lengths are clustering around — rather than generic advice about good writing.
- 04Model call
Rewrite
The strongest available model rewrites the document with the plan and the constraint list in front of it.
Blocks come back in the same structure they went out in — same count, same order, headings still headings, lists still lists — so the result can be compared with the source paragraph by paragraph.
- 05Local + model
Verify against the original
The rewrite is checked back against your draft, in both directions.
Deterministic checks run first and always: every extracted value is looked for in the rewrite, and every value in the rewrite is looked for in the source. The first direction catches omissions. The second catches fabrications, which is the failure mode that matters most here.
- 06Model call
Repair only what drifted
Failing paragraphs are regenerated with their specific problems named. Everything that passed is kept.
Regenerating a whole document to restore one dropped figure would cost more, take longer, and throw away work that was already correct.
Verification catches the failure modes it can name, and it catches them well. It is still a check rather than a proof, which is why every rewrite arrives with a diff and your original sitting next to it. You are meant to be the last reader.
Four things it deliberately will not do
The constraints matter more than the capabilities. These are the ones the product is built around.
- It will not add anything
- No invented anecdotes, no opinions your draft did not hold. A value present in the rewrite but absent from the source is treated as a fabrication.
- It will not flatten a register it was asked to keep
- Academic mode preserves every hedge, because in academic writing those carry meaning. Each mode declares which signals it should tolerate.
- It will not rewrite what is already good
- Prose that measures as well written gets a small change budget and an instruction to leave good sentences alone. Untouched paragraphs are marked as such.
- It will not overwrite your original
- Your draft stays beside the rewrite with a diff between them. Nothing is accepted on your behalf.