A worked example · one person and an AI on one record of decisions · 18 September 2026

A Calculator on a Throughline

Residents of a housing estate keep being charged for parking they did not do: two short visits in a day, read by the cameras as one long stay. A person wanted a public page that shows how likely that is. In one evening a person and an AI put the page live, then changed it eleven more times as he used it, taking two features out as well as putting others in, with the reason for every change kept. The map the page needed became a tool that can draw the next site.

Two pagesThis is the account for a general reader. The technical page shows how throughline was used: the two graphs, the working contract as it actually ran, the three rounds of signing and the fault between them, and the measurements.
26minutes from the request to the page answering from the public internet, by the session record's timestamps
12times the page was rebuilt and rolled out that evening, each after a request or a finding
40decisions on the page's record, every one written by the AI and signed by the person before the evening ended
2signed decisions whose words moved afterwards, both reported by the tool within seconds and signed again
18decisions on a second record, for the tool that fell out of the work, with eight tests

The problem, and the page

Residents of a housing estate keep being charged for parking they did not do. The store on the estate allows thirty minutes. The cameras at its two entrances read number plates on the way in and on the way out, and the operator pairs each exit with the earliest entry still open. A driver who calls in twice in a day makes four passes. If the cameras miss the middle two, the morning's arrival is paired with the afternoon's departure, the stay is measured across the gap, and a notice follows. The first example on this site is the register those residents keep of such notices. This one is its companion: a public page, no sign-in, that shows how likely a wrong charge is, given how often a camera misses a plate.

The model already existed. The person had built it a week earlier in a chat with an AI, as an interactive page inside the chat: sliders for the miss rates, three ways an operator might pair the reads, all sixteen patterns of read and missed passes, and the chance of a wrong charge per day and per year. It lived nowhere a resident could reach. The request was one paragraph: make it a companion site to the register, at a name beneath the register's, open to anyone, no sign-in.

How the work was divided

The arrangement from the first two examples held, with one difference. The AI proposes and nothing it writes counts until a named person signs it. Every decision says why it exists, and every change to the page names the decision it serves. The difference is order: the page was live before anything was signed, and the person signed in three rounds as he went, the first of them without saying so. What that cost is part of this account.

Live in twenty-six minutes

The AI found the model in the record of the earlier chat and took its page apart into a page, a stylesheet and a script, so that the page could forbid every script but its own. It wrote the decisions first: one intent, one thing the page would never do, and nine requirements each with a test, from "anyone can read it and nothing asks who they are" to "a new build is seen on the next load". Then the image the page is served from, the pipeline that builds and scans it, and the few lines the hosting needs to route a name to a running thing. The certificate and the public address already covered any name beneath the register's, so the page needed neither; only a route.

Twenty-six minutes after the request the page answered from the public internet, and the AI checked it from outside: the security headers, the redirect from plain to encrypted, the health check, the page in a browser with no errors. That figure is from the timestamps of the session record. It could have been an hour; it was short because the register had already paid for the hosting.

Reshaped by the person who asked for it

Then the person used the page, and it changed eleven more times before the evening ended. Each change went the same way. He wrote a line or two; the AI wrote the decision and its test, changed the page, checked the record, and rolled the page out; the next line usually arrived before the last change had landed. In the order they came:

  • "A little asymmetry." In the model one entrance's cameras could be down for a day and the other's could not. Both could, within the hour.
  • Light and dark. The page followed the reader's system; he wanted a choice. It got one, kept in the reader's browser and applied before the page first paints.
  • A fault the AI found in its own work. The network in front of the page keeps a copy of the stylesheet and the script for four hours. A returning reader could run last hour's script against this hour's page, and a new slider would silently do nothing. Every file is now named by its own contents, so a changed file has a new name, and the build fails if a name is left unstamped.
  • Fewer sliders. Eight was too many. He designed the replacement in one message: one rate by default; a rate for each entrance behind a control; a rate for each camera behind another; and, at either level, entries and exits separately behind a switch. The values at each level stay put while another is shown.
  • Two features removed. A setting that let the two cameras at one entrance fail together was "too complicated, and actually shifts responsibility to the number plate". Out. The offline-day settings "over-complicate it too". Out. Each removal is a decision on the record with his reason kept beside it, so the next person to wonder where a setting went can read why.
  • Economics. A slider for how many drivers make two visits in a day, and from it the number of wrong notices a year and what they come to at the charge on the notice and at the reduced charge for paying promptly. He read the first wording and found it "a little provocative". It now calls itself an illustrative estimate of the reader's own choices, and both charges are inputs.
  • Photographs. He had taken five on site. The AI blurred every number plate beyond reading, cropped his thumb out of one, straightened the two signs into flat boards and typed out their wording in full, so a reader can search it and a screen reader can say it. Hovering over a camera on the page's map now shows its photograph. The originals stay outside the record and are never published.
  • Order and defaults. The signs moved to the end. Every rate now starts at three per cent, and the wide-angle camera at one hundred, because it reads no plates; so the headline reads the same at every level until a slider moves.
  • One sentence at the top. The two visits are each shorter than the thirty-minute limit, including the drive in from the entrance and back out to the exit.
  • Remembered settings. Every slider, switch and choice is kept in the reader's browser and there on the next visit, with a note saying so and a link to reset. "No need for an accept toggle": it serves only the reader, and nothing leaves the browser.

The map, and a tool that fell out of it

Between the sliders and the economics he asked for a map of the car park in front of the store, so the cameras could be marked on it. The AI drew one from open map data: the store, its car park, the roads and paths, and each place where the car park's roads meet the public road, labelled so he could point at them. Then it served him a page beside the map where he clicked where each camera is mounted and set the direction it looks, how wide, and how far. He placed three and said "done". The map went onto the page with the cameras numbered and a shaded wedge for what each can see. It is not reproduced here: a map names roads, and roads name the place.

His next message was that the map and the placement tool were "amazing, please capture it somewhere so we can use it again for different sites". So the drawing code came out of the page's repository into a tool of its own, with five commands, a record of eighteen decisions and eight tests, and the page's own map was redrawn by the tool the same evening; the hand-made version was deleted. The tool found two faults in itself the moment it ran on the real data. It listed two junctions the picture did not show; then, told to keep to the picture's frame, it dropped a junction that sat exactly on the edge. The tests caught the second.

Signing, and a fault in the process

Some way into the evening the person signed the thirty-two decisions then on the record, without saying he had. The AI's next save of its own work swept those signatures up with it, so the record of who signed what sits, in the history, under the AI's name. The signatures themselves are intact and carry his name; the presentation is wrong. The rule that stops it happening again, name each file you save in a record you share, is now written down where the AI will read it at the start of its next session.

Minutes later the AI changed the words of a decision he had signed, to set the new defaults he had asked for, and the tool said the signature no longer matched. It said so again when the note about remembered settings changed what the page says it keeps. He signed both again, and the eight new decisions with them, in one command on a hand-off; then the tool's eighteen in one more. That the tool reported the moved words within seconds is what this example has to show for the method. That the person signed thirty-two decisions in one go, and later ten and eighteen, leaves open the question the second example left open.

Where the evening went

From the first question to the tool's signature was under three hours. The page's own share was measured by the assessment script over its window of the session record: 2.1 hours of active work, sixteen messages from the person, three hundred and sixty-five turns by the AI. The rollouts, twelve, are counted from the hosting's history. The tool's window overlaps the page's, because the AI built it while the person was still changing the page, so its hours cannot be separated from the page's and this account does not pretend to.

Who did what

Only the person couldOnly the AI wouldBoth, through the record
Ask for the page, and say what it is for and where it livesFind the model in an earlier chat's record and move it into a repositoryPut the page live before anything was signed, and sign afterwards
See that one entrance could fail and the other could notNotice the four-hour cache and fix it before any reader met itKeep the reason for each removed feature beside the decision that removed it
Design the three-level sliders in one messageBlur the plates, crop the thumb, straighten the signs, type out their wordsTurn "capture it somewhere" into a tool with a record of its own
Take five photographs, and click three cameras onto a mapRoll the page out twelve times and check it from outside each timeReport a moved signature within seconds, and renew it
Decide that two features should go, and say whyWrite nineteen requirements, each with its test, in the same turns as the codeMeasure the evening with a script rather than remember it

What went wrong, and what caught it

  • The model could take one entrance offline but not the other. Caught by the person, reading the sliders. Fixed.
  • A returning reader could run a stale script against a new page for up to four hours. Caught by the AI reading the live response, not by any test. Fixed so that the build itself fails if a file is left unnamed.
  • The map tool listed junctions its own picture did not show, then dropped one on the frame's edge. Caught by comparing its output with the hand-made map, then by its tests. Fixed.
  • Thirty-two signatures were saved under the AI's name. Caught by nobody at the time; seen when the tool reported a moved signature and the AI asked itself why the decision had been signed at all. The record is intact; the rule is written down.
  • Two signed decisions were changed after signing. Caught by the tool at once, both times. Signed again.
  • The wording under the economics read as an accusation. Caught by the person. Rewritten as an illustrative estimate of the reader's own choices.
  • Two features were more model than the page needed. Caught by the person using it. Removed, with the reasons kept.

Time

PhaseThe AI, elapsedThe person, attention
Finding the model in the earlier chat's recordabout 6 minone question
Repository, record, image, route; live and checked from outside26 minone request
Symmetry, the cache fault, the theme, the map and its placement pageabout 1 hfour messages, and three clicks on a map
The tool, extracted and tested, while the page went on changingabout 30 min, overlappingone sentence
Sliders, two removals, economics twice, photographs, signs, defaults, the lede, remembered settingsabout 1 h 15ten messages, most under three lines
Signing: thirty-two, then ten, then eighteenminutes eachthree commands, one of them unannounced

The AI's minutes are from the session record's timestamps and include waiting on its tools. The assessment script, over the page's window of the same record, measures 2.1 hours active against 2.4 on the clock; over the tool's overlapping window, 1.4 against 1.8. The person's attention was about twenty messages across both. The figures on the index card are the script's, not this table's.

What this shows

Live first, argue after. The page was on the internet in twenty-six minutes, and every later change was made against a thing the person could use rather than a description of it. The record did not slow that down; it was written in the same turns as the code.
A removal deserves a reason as much as an addition. Two settings went because the person said one shifted responsibility onto the number plate and the other over-complicated the page. His sentences are on the record beside the decisions they retired; the history alone would show only that something vanished.
The tool reports a moved signature within seconds. Twice the AI changed words the person had signed; twice the next command said so. That is what a signature is for.
Name what you save. Sweeping every changed file into one save put thirty-two of the person's signatures under the AI's name. The record survived; the rule is now written down.
When the person says "capture it", make a tool with a record of its own. Eight requirements and eight tests, one of them that the same inputs always give the same picture, and the picture on the page is now something the tool can redraw for the next site.
Publish the measurement, not the memory. The hours, turns and tokens here are a script's reading of the session record and the graph, and the index card carries only figures the script produced.
Signing in bulk is the open question, again. Thirty-two, ten and eighteen signatures in three commands. The record shows who signed; it cannot show whether the reading happened.