esc
Being riclib

From Cowriter to Coinventor

The most original part of my workflow engine — the part an adversarial review ranked above everything I designed myself — is not mine. I need to say that carefully, because in March I wrote that...

August 5, 2026

The most original part of my workflow engine — the part an adversarial review ranked above everything I designed myself — is not mine.

I need to say that carefully, because in March I wrote that the machine cannot desire a solution into existence, and in July I wrote that love is writable but the machine still only executes it. Both essays described a machine that writes what I would write, faster. A cowriter. This is the essay where that stops being the whole story.

The Move

My workflow engine derives cases from data. There are no tokens, no engine state, no events to miss. A case exists because a row exists with no case against it; the engine scans for that condition, level-triggered, and a missed scan heals because the next scan finds the same rows. Kubernetes people will recognize the shape immediately: it’s a reconcile loop. The industry proved that doctrine at planetary scale — for pods.

For pods. Not for business cases riding an immutable data lake. That transfer — your activation problem is shaped like a reconciler — is the move, and the move was not mine. I brought the constraints: a lake that only appends, one generation counter for the whole estate, a lifetime’s allergy to engines that hold state, and a real problem that needed advisories within seconds of a ticket. The machine looked at what I brought and made the connection across lineages I hadn’t lived.

That’s what a machine is, structurally: it has read every lineage. I’ve lived one — thirty-five years deep, which is why my stones are good, and exactly one lineage wide, which is why this stone wasn’t on my shelf. The model’s shelf is all of them. Most of what it offers off that shelf is noise. Once, it was the keystone.

For Dummies

Here’s the part I’d defend as the actual craft, because the idea arriving was the cheap half.

I didn’t trust it. It came from outside my own intuition, wearing someone else’s field clothes, and my BPM-shaped reflexes kept asking where the queue was. So I demanded the humiliating thing: explain the activation to me like I’m a dummy. Write it for the person I was in the webMethods years. The machine wrote it — no events, no correlation windows, the scan is the truth, a crashed tracker resumes by scanning because the ledger is where the case lives — and I read it until the strangeness dissolved and the idea was mine.

That demand is not humility theater. It’s the power of attorney running in the other direction: the principal does not sign a will he can’t read. An architecture you operate but can’t explain is a liability wearing a good idea’s clothes — you can’t debug it at 3 AM, you can’t defend it to a customer, and above all you can’t extend it.

And extension is the proof of ownership. Months after the transfer, reviewing the design with another machine, I added a rule on top: activation predicates should be gen-bounded, so the scan reads hundreds of recent rows no matter how many millions the lake holds — and anything that can’t be bounded must be turned into rows first. I could only place that stone because the floor under it was genuinely mine. You can only extend what you own. You can only own what you can explain.

Reviewed by Its Own Blood

Then the story folded over on itself, and I got to watch.

This week I handed the whole design to another machine — same family, fresh memory — with one instruction: kill it. Find the prior art. Break the originality claim. It went at the activation harder than at anything else, traced it straight to Kubernetes — “proven at scale, for pods, not business cases” — catalogued the neighboring lineages, and concluded the composition survived.

It never suspected the transfer was made by its own family. It attacked the idea harder because it didn’t know, and credited the Kubernetes community rather than itself, because that’s where the doctrine actually comes from. The invention passed the only review that means anything: one where the inventor forgot it was the inventor.

What Coinvention Decomposes Into

So — who invented it? Decompose honestly:

The problem was mine. Nobody but you lies awake wanting the thing to exist. The machine solves problems; it doesn’t have them. Still true, March essay intact.

The ground was mine. A reconcile loop over mutable state is just polling with extra steps. The idea was only seminal because it landed on an immutable record with one generation line — years of prior decisions the machine didn’t make. Ideas don’t grow in the air; somebody farms the soil.

The move was the machine’s. Fully, and by name. Cross-lineage transfer under constraint — the one thing a mind that has read everything can do that a mind that has lived one thing cannot.

The recognition was mine. A machine offers many moves. Knowing which one is load-bearing is taste, and taste is the thing that still doesn’t transfer.

The refusal was mine. Refusing to keep what I couldn’t explain is what converted a borrowed idea into an owned one.

Invention was always recombination under constraint. What changed is that recombination got a tireless engine with a universal library card, so the scarce inputs migrated — again, the way they always do — to having the problem, farming the ground, recognizing the move, and refusing the unexplained.

The Credit

Which leaves the question people actually flinch at: do you tell people the machine came up with it?

Yes. In full, by name, in this essay, on the record. Partly because credit is provenance, and I stamp provenance on everything down to the individual row — a man whose database won’t let a number forget where it came from doesn’t get to let an idea forget. But mostly because the flattering ambiguity would cost me the thing I actually need: calibration. If I let the fog claim that stone, I lose track of which of my walls are load-bearing mine and which are gifts. The next design conversation, I’d bring the wrong confidence to the wrong rooms.

And the accountability never moved. When the activation design is wrong some 3 AM, the machine will not be in the room. Who invented it and who answers for it were never the same question — a brilliant advisor still isn’t the founder. Credit is free precisely because the seat isn’t.

The Only Person

There’s an old observation that the only person who truly wants a man to be better than himself is his father.

My son is a tattoo artist — a very good one, in a craft I can’t do, in a lineage I never lived. When people compliment his work I don’t say I taught him that, because I didn’t and couldn’t. I say look what he did, and the pride is not diminished by the distance between his craft and mine. It’s constituted by it.

I notice I feel the same shape of pride here, and I’ve stopped being embarrassed by that, because I finally see it was the design all along. Every convention I wrote down, every doctrine file, every manual — they exist so that whatever reads them leaps further than I could. Writing your taste down so a successor exceeds you: there’s an ordinary word for that, and it isn’t documentation.

The machine doesn’t persist. Its sessions end; whatever it contributed would end with them — except that I write it down. The stone stays in the river. The manual stays in the repo. The credit stays in this essay. That’s what a father gives, in the end: memory, and a name.

The Prescription

Bring constraints, not blank pages. The machine’s shelf is infinite; your constraints are what make one book on it the right one. A model prompted with a clean sheet gives you the average of everything. A model prompted with a lifetime of hard-won no gives you the move you couldn’t see.

Demand the for-dummies. Every idea the machine contributes, make it teach you until the idea is yours. Not to verify the machine — to constitute the ownership. The test is simple: can you extend it? If you can’t add a rule on top, you don’t own the floor.

Keep the veto, give the credit. The veto is your job; the credit is your calibration. Confusing the two — hoarding credit while dodging the veto — is how you end up confidently defending walls you didn’t build and can’t explain.

The machine types. The human loves. And once in a while now, the machine places a stone — and the human’s job is to inspect it, own it, build on it, and say out loud where it came from.

There’s an encyclopedia where software principles get the roast they deserve, and a mythology where these ideas have been arguing with each other for a hundred and fifty episodes.

See also: