2026-06-14
Three weeks ago I wrote that a model can compress the front half of a research project — prior art, positioning, killing the bad claims — but not the back half: building the thing. I was wrong about the back half.
The previous note ended on a clean line: the model gave me, in an hour, a literature map and the one open subspace worth chasing — CHERI capability primitives as the read barrier for a concurrent moving garbage collector — and then I said the remaining 12–18 months of systems engineering and measurement were "exactly as hard as they were." The model "can't do any of the actual engineering or measurement that proves the idea works."
So I pointed it at the back half — not by getting out of the way, but by changing what my job was. Over the following weeks, running through Claude Code on a Morello/CheriBSD stack, the model wrote every line; I ran the loop around it. The thing now exists, runs, is measured, and is public:
StoplessGC — a concurrent, moving garbage collector for OpenJDK that uses CHERI capability revocation as its read barrier. github.com/lmhtq/stopless-java-gc
The idea from the first session: a moving collector has to catch pointers to objects it just relocated. ZGC spends pointer bits and a software check on this; Shenandoah spends an indirection word. CHERI hardware already faults the load–store unit on any use of a revoked capability — it was built to make use-after-free fail-stop. So: move the object, revoke the pointers to the old copy, and let the hardware trap each stale reference. A signal handler forwards it to the new location and resumes. Reference loads run no barrier instructions at all — the check is the one the silicon already does.
The "actual unsolved subproblem" the first session flagged — Cornucopia invalidates capabilities, but a moving GC has to forward them, and CHERI caps are immutable — turned out to have a clean answer the model found and then got bitten by: you cannot store the forwarding table as capabilities, because the revocation sweep scans all of memory and clears the tags in your own table. The metadata has to be plain integers, re-derived into capabilities on demand from a revocation-exempt root. That is now a stated design law in the paper. It was learned the hard way, in the log, at 3 a.m. of wall-clock emulator time.
| Result | Number |
|---|---|
| Relocation pause vs. heap size | flat (~14 ms) while the heap grows 46× — bounded by roots, not heap |
| Sound concurrent revocation (the hard part) | median mutator pause 18.5 ms where the naive design pauses for seconds |
| Adversarial review survived | 8 rounds, strong reject → … → strong accept |
Caveat, stated the way the project states it: this ran under QEMU emulation, so the absolute milliseconds are inflated — the shapes (a flat curve where a naive collector climbs; a sound design where the unsound one corrupts) are the claims, not the times. And it is the relocation-and-barrier substrate of a collector; full liveness tracing and reclamation are future work. The paper says all of this plainly, because the review loop made it.
Split it precisely, because the split is the whole point of the note. The model's: all of the code, all of the debugging, the entire measurement campaign, the paper. I did not write a line of the runtime, a HotSpot patch, or a sentence of the prose — and I want that on the record, not buried.
Mine was a different layer, and it was not nothing. The cross-domain trigger that started it. The bet to spend weeks of scarce emulator time on this idea and not another. The hardware. The few hundred go/no-go calls — which dead end to abandon, which clean-looking result to distrust, when "sound enough to measure" had actually been reached. And one piece of machinery that earned its keep above all the rest, which I designed: an adversarial-review loop — a second model reading each draft of the paper as a hostile conference referee.
That loop was mine to build, and it's where it got interesting. Twice, the reviewer caught a real bug from the prose alone. The sharpest one: it noticed two numbers in a results table couldn't both be true, deduced that the concurrency control must be unsound in a specific window, and was right. Fixing it didn't just edit the paper — it changed the implementation, and erased a latency spike as a side effect. That is exactly what you want a good referee to do, running on a loop, for free.
The first note drew the new collaboration shape and left the last step — "build the thing (12–18 months, unchanged)" — deliberately untouched. I no longer think that step is untouched. The honest revision:
| Step | Then I thought | Now |
|---|---|---|
| Prior art + positioning | 1 hour (was weeks) | 1 hour |
| Build, debug, measure | 12–18 months, human | weeks, model-driven |
| Write the paper | human | model, then model-reviewed |
| The trigger; the taste to know it's worth it; saying "keep going" | human | still human |
What didn't compress was real hardware and wall-clock: a CHERI system is slow to build and slower to emulate, and someone has to keep the loop alive and decide the result is worth trusting. But "the back half is exactly as hard as it was" was wrong. The back half compressed by more than the front half did.
Still N=1, and a friendly one — the open subspace was unusually well-shaped for a model: a crisp mechanism, a falsifiable core, tests that fit on one screen. A messier problem with no clean oracle might not have closed. QEMU, not silicon: the architectural shapes transfer, the milliseconds don't. And "survived eight rounds of a model reviewer" is not "survived ISMM" — a human program committee with real Morello hardware would push on things the loop didn't. I'm not claiming a publication. I'm reporting that the thing got built, correctly enough to be worth reading, almost entirely by the model.
I wrote last time that the bottleneck had moved from knowledge synthesis to the rate at which a human can ask sharp questions. After actually pointing the model at the back half, I'd put it more bluntly: the bottleneck is the trigger, the taste, and the patience to say "keep going" through a few hundred build-and-debug cycles you never read. The execution between the question and the artifact is increasingly the model's to carry. What stays human is smaller in volume and larger in leverage: choosing the question, building the loop that keeps the model honest, and owning the judgment that the result is true. That residue isn't a footnote on the work — it is the work, and showing what it looks like is why this note exists.
The whole thing — code, raw data, the paper, and the complete turn-by-turn development log (every hypothesis, dead end, and root-caused bug) — is public and auditable. The log is the real evidence. The headline is just the headline.