WatchMeType: reproducing the writing process a school asks a student to prove.
A macOS app that types an essay the way a person would, with the hesitations, the typos and the second draft. It exists to ask what a process check is actually measuring.
Schools met generative AI with surveillance.
The burden of proving a piece of writing is genuine was handed to teachers, who were given no time for it.
Detector scores, revision history, timing data, paste events: a set of tools that promise to tell a teacher whether a piece of writing is real. The work of running them lands on teachers, who did not ask for it and were not given time for it, while the thing that changed goes untouched.
The trouble is that this misreads how writing works. Students think out of order. They draft on their phones, in notes apps, on paper, in fragments they later stitch together. A clean, traceable revision history is not what learning looks like; it is what a particular piece of software can see. And when the only thing being checked is the finished product, the shortcut to a finished product becomes the rational move. Calling that dishonest misses it. Students take the path of least resistance, the way everybody does.
| what the check inspects | what the student actually did |
|---|---|
| one document, edited in one place | Notes on a phone, a paragraph on paper, and a paste from both. |
| steady growth from blank to finished | Wrote the middle first, then the opening, then cut the middle. |
| elapsed time between keystrokes | Left the tab open on a laptop for two days. |
| a large paste, treated as suspect | Moved their own paragraph in from the notes app. |
| no detector flag | Nothing, in either direction, that a teacher can act on. |
If the revision history is the proof, then the revision history is what is being assessed.
So I built the thing that manufactures one, in public. An argument is easy to wave away; a working demonstration is not.
So I built the tool that manufactures one, and put it in public. Not to help anyone cheat, and not because the shortcut needed building. Because an argument about what a check is worth is easy to wave away, and a working demonstration of what the check accepts is harder.
Typing like a person is rhythm. Revising like one is a diff.
It types at 40 to 120 words per minute with the pauses and the typos, then diffs two drafts and replays the difference.
WatchMeType types into any macOS window at a pace a person would: an adjustable 40 to 120 words per minute, pauses where thinking happens, longer pauses at commas and sentence ends, and occasional mistakes it goes back and fixes. That much is rhythm, and rhythm alone produces a document that appears in one sitting, fully formed, which is its own kind of tell.
The harder half is revision. A believable history is not a draft arriving; it is a draft becoming a second draft. So the app takes two drafts, diffs them, and replays the difference as edits made in place.
| control | what it changes |
|---|---|
| speed | 40–120 wpm, set to the writer rather than to a default, because one consistent speed is itself a signature. |
| thinking pauses | Stops mid-sentence, where a person stops, rather than tidily between them. |
| punctuation delays | Separate holds at commas, at sentence ends, and at paragraph breaks. |
| mistakes | Occasional errors, caught and backspaced a few characters later. |
| minimum duration | Stretches a session to a target length when the estimate lands short. |
-
01
Split both drafts into sentencesAbbreviation-aware, so Dr. and etc. do not end one.
-
02
Pair each sentence with its closest matchJaccard similarity between the sentences of draft 1 and draft 2.
-
03
Choose how finely to edit the pairAbove a similarity of 0.4, diff the words inside the sentence. Below it, retype the sentence whole.
-
04
Split into words, keeping the whitespaceSpaces are tokens too, so a cursor position still means what it says.
-
05
Map every edit back to a character positionWhich leaves one question: what order to apply them in.
Replaying edits right to left needs no bookkeeping. Left to right needs a running offset.
The app walks both ways anyway, because two passes in the same direction repeat the same shape.
Walking the edits right to left means each edit lands at a position nothing has disturbed, because every edit already applied is further right. No bookkeeping is needed. Walking left to right is the opposite: each applied edit shifts everything after it, so the traversal has to carry a running offset and adjust every position still to come. Same edit list, two directions, and only one of them needs to remember what it has already done.
The app does both, because a second revision pass reads as more human than one, and two passes going the same way would repeat the same shape.
It is also typing into a document somebody else owns, which makes safety a design problem rather than an afterthought. Before every destructive edit the app compares the live document against its own snapshot and stops if the two have drifted. Changing focus pauses typing and aborts editing outright. Escape stops it.
draft 1 → 2 · right to left
Applied from the right. Everything still to come lies to the left of the edit just made, so all three sites are used exactly where the diff found them.
draft 2 → 3 · left to right
Applied from the left. The first edit lengthens the document by six characters and the second by eight, so every later site has moved by the time the pass reaches it.
Seven releases, 663 downloads, and the only evidence I have is conversation.
Teachers told me it exposes the flaw in the checks their schools enforce. Nobody wrote that down, including me.
Source-available on GitHub since December 2025, through seven releases to a three-draft version in April 2026, with 663 downloads and a couple of dozen stars. Teachers who tried it told me, in conversation, that it exposes the flaw in the measures their schools have been enforcing in the name of academic integrity. That is the response I wanted, and it is worth being plain that conversation is the only evidence I have for it.
What I learned: I had built a case against my own marking.
The uncomfortable part is that I teach.
Building the thing that defeats a process check made me look at my own assessments and find some of them checking for the same shallow signals. It moved me toward designing work that teaches the skill and shows it being used, rather than work that collects an essay and hopes the essay was earned. The app argues in public. I still had to answer the argument in my own classroom.