Last summer I wrote about teaching my assistant to reach and to remember. Reach meant tools for looking at the live world; remember meant a small local database that survives between our conversations; and in both cases my part was to name what was missing while the assistant built the way to fill each gap. I closed that essay on a promise I meant: there would be another gap to name next week.

This one was in how the assistant writes.

The request was four sentences, sent on a Sunday afternoon. I asked the assistant to research what makes written material pleasant to read. Then it was to analyze the gap between that research and the writing skills it already had, and make a plan to fill it. That assignment carried an irony: I was asking a system that cannot feel anything about a sentence to find out what makes sentences pleasant. The answer stepped around the irony rather than through it. Much of pleasant reading turns out to be measurable.

What the Research Said

The assistant ran seven research passes, checked the load-bearing numbers against their original sources, and came back with a short list of levers.

The first lever is ease of processing. Readers misread the difficulty of reading as a property of the thing being described. In one experiment, identical exercise instructions printed in a plain font led readers to estimate the exercise would take 8.2 minutes. Printed in a hard-to-read font, the same words suggested 15.1 minutes (Song and Schwarz, 2008). Ease even masquerades as truth: rhyming aphorisms were judged more accurate than the same sayings with the rhyme removed (McGlone and Tofighbakhsh, 2000).

The next levers sit inside the words and sentences. Concrete writing helps: important material tends to be more interesting and better recalled when it is concrete (Sadoski, 2001). In news writing, humans scatter their sentence lengths more widely than language models do (Muñoz-Ortiz et al., 2024).

Interest has a trap: anecdotes that are interesting without carrying load hurt recall of the ideas that matter (Lehman et al., 2007). Difficulty has its uses, too. Ask readers how many animals of each kind Moses took on the Ark, and most answer two without noticing that the Ark was Noah’s. In one study, 7 percent caught the error in an easy font, and 40 percent did in a hard one (Song and Schwarz, 2010). That is why the new guidance treats a suspiciously smooth passage as a reason to check facts rather than trust them.

The Voice Was Fine, the Instrument Was Blind

Before writing any guidance, the assistant measured my own essays, a step I would not have thought to ask for. There were seven of them, about twelve and a half thousand words. The point was calibration: if we were going to set target bands for readability, they should come from my voice rather than from a committee style guide.

The result was a small surprise: my prose already sat inside the evidence bands. My sentences averaged about seventeen words, inside the fifteen to twenty that the U.S. Office of Personnel Management recommends for plain writing (OPM, n.d.). Sentence lengths varied widely, and passive voice was rare. The gap was in the tooling: no skill could see any of this.

That same measurement turned up something embarrassing. The open-source style checker we trusted to audit my drafts counts sentence length one source line at a time. My source files wrap paragraphs across lines, the way text editors have wrapped prose for decades, a convention harmless to every reader but that one tool. A fifty-word sentence spanning three wrapped lines reads to the tool as three short and perfectly legal fragments.

The assistant counted properly, joining the lines the way a reader does, and found eighty-one sentences over thirty words hiding in my published essays. One ran seventy-seven words. Every previous audit had passed all of them without comment. We had been grading with a blind instrument and collecting clean report cards.

Even the measurement needed debugging, which I found perversely reassuring. The first count came back at eighty-three. Then the assistant noticed that web addresses had inflated some of its sentences and corrected the number to eighty-one. I decided to leave the sentences alone. They are published, they read well, and retroactively sanding my own prose smooth is not a job I want a machine doing on its own initiative.

Four Small Decisions

What and whether stayed with me, and the how belonged to the assistant: the same division of labor I described in August. The plan came back staged, with stop points and four decisions reserved for me. Three of my answers were your recommendation. On the fourth I made it explain, and then I declined.

The question I made it explain was presentation: should the new guidance say anything about line lengths, fonts, and page layout? I did not follow the details at first, so it measured my live site and showed me: an 18-pixel font, a 720-pixel column, 72 to 84 characters per line. Its explanation was reasonable, and I said drop anyway, for a reason that has nothing to do with typography. An agent that adjusts the site stylesheet to improve one article can break every article. Layout belongs to the theme.

One recommendation I took concerned register: whether to push my prose toward easier scores on the Flesch reading-ease scale, which runs from zero to 100, higher meaning easier. My essays average about 58, and my audience is working engineers, so the register stays. The bands follow the voice, not the other way around.

What Got Built

A new skill, a folder of instructions and a small script, now sits beside the older style skill in the assistant’s runtime. It went in thirty-four minutes after my request, and about ninety minutes in, I signed off on the last gate. The older skill runs the new script first in every review.

The script measures a draft the way a reader meets it, not the way a source file stores it. It joins wrapped lines so sentences are counted whole. What comes out is a small table of numbers, set against the bands taken from my own corpus. Nothing is enforced, but every number outside its band gets a stated reason in the review notes, and the reasons are where the judgment lives.

Validation was the part I enjoyed. My essays pass their own bands, seven for seven, which proves only that the bands fit their source. The real test was a synthetic sample of uniform machine sentences. It flags six of the eight metrics on sight. One editing pass for rhythm, concreteness, and paragraphing brings it inside all eight. On that test, at least, the instrument discriminates.

This essay is the third test. It scores 66 on the Flesch scale, and every number sits inside the bands taken from my own prose. The script that found eighty-one hidden sentences in my essays found two in this one, and I kept both on purpose.

Procedural Memory

In August the assistant learned to remember. On Sunday it learned a craft, and the two are more alike than they look, because both are forms of memory. The memory system stores facts and past conversations, the kind researchers call declarative memory, or knowing-that. What it built on Sunday is the other kind, procedural memory, or knowing-how (Squire, 2004).

The skill mechanism was already in the assistant’s runtime. Hermes, the agent framework I use, keeps skills as folders holding a short instruction file and whatever scripts a task needs. My assistant can also write them. At any point in a session it can distill what it has just learned into a new skill folder, scripts included, and install it on the spot. The Hermes documentation uses the same term for these, procedural memory (Nous Research, n.d.). So the mechanism was never the missing piece; what was missing was the curriculum, and the person choosing it.

Others Are Doing This Too

Skills as a storage format are well known now, and Anthropic published its version as an open standard (Anthropic, 2025). What I had not seen in daily use is the acquisition path. This skill came out of a single session’s context: the assistant wrote and installed it mid-task.

Researchers have been building that path for a few years. Voyager, a Minecraft agent, writes executable skills into a library it reuses to climb the game’s technology tree (Wang et al., 2023). Agent Workflow Memory pulls reusable routines out of an agent’s past tasks (Wang et al., 2024), and SkillWeaver has web agents practice a site and then distill what worked into callable interfaces (Zheng et al., 2025).

All three learn mostly from practice, with an automatic check deciding what counts as success. What we did was closer to assigned reading. I looked at the assistant, saw what it could not see, pointed it at the literature, and held the gates on everything that shipped. A student who only practices gets better at what it already does. A student with a teacher gets the reading list.

Who Names the Next Gap

Partway through Sunday’s session, the assistant found four bullet points in its style skill that nobody in the conversation had written. All four restated findings from earlier in the session, and one still carried the count of eighty-three that we had since corrected. We never established which process wrote them; something had read our afternoon and edited a skill on its own.

No one had asked for those edits. What happens when the human is no longer required to identify the gaps either?

Voyager points at part of the answer. Nobody tells that agent it cannot yet reach the next rung of the technology tree; the game’s feedback and its own error messages do. Wherever the environment grades the attempt, the gap names itself, and the human was never really the one identifying it.

The harder case is a gap like this week’s. No game scores an essay. A draft that reads flat returns no error code, and the assistant cannot feel the flatness; that is why I had to name it. What we built afterward is the bridge. The bands, taken from my own prose, let the machine see part of what I was seeing. Any future draft that goes flat in the same way will flag itself without me.

So the naming job is already leaving my hands, and I find that less alarming than interesting. Instruments measure only what they are built to measure, and this week supplied its own parable: the style checker passed every long sentence it could not see. A system that names only the gaps its instruments can register will drift confidently in exactly the directions it cannot see.

When the human stops identifying gaps, the work shifts rather than ends. Somebody still has to build the instruments, supply the yardstick that no benchmark offers, and decide which of the machine’s named gaps deserves to become a project.

Each of those jobs rests on imagination. A gap is the distance between what exists and what someone pictured, and every gap in this story began as a picture in a person’s head. Even Voyager’s technology tree was drawn by the people who made Minecraft. Machines can now measure the distance to a picture. The machine brings the ruler; we bring the picture, and I take that as good news. As the machines get better at closing gaps, we get more room to imagine the next ones. That is the job I am keeping.

There is already another gap forming. This time the assistant has instruments of its own, and it may name the gap before I do.

References