orthogonal.ly

The Amnesia Machine

2026-08-30T00:00:00+00:00

There is a growing chorus against working augmented. Not a fringe one, either: people arguing, with real intensity, that the machine produces terrible, unmaintainable code and that relying on it is a mistake. For a long time I filed this under fear of irrelevance, the subject of my last post: an understandable emotional reaction dressed up in technical clothing. But the tide kept rising, and at some point intellectual honesty demanded the uncomfortable question: is there something I am missing?

The answer, it turns out, is sort of. Not what the critics say, but something adjacent to it, which most of them feel and few of them articulate well. This post is my attempt to articulate it, because working through it changed how I understand my own workflow.

Four arguments in a trenchcoat

First, a disentangling. The discourse is not one argument; it is at least four, all wearing the same word.

There is the identity argument — programming as craft, the writing of code as the point rather than the output. Real, human, and not about code quality at all. There is the reviewer’s lament — senior engineers drowning in large, plausible-looking merge requests from people who cannot answer questions about them. Code is cheap to generate and expensive to verify, and the asymmetry lands on whoever does the reviewing. There is definitional slippage — the critics’ word was coined for one narrow thing, shipping the machine’s output unread, and now gets stretched over everything up to reading every line. They attack the narrow thing; defenders hear an attack on augmentation as such. Most of the shouting is people at different points of a wide spectrum arguing with the same word.

And then there is the fourth argument, the one worth keeping. The machine removes the forcing function that used to guarantee comprehension. You could not ship a function without having held its logic in your head at some point — the effort of writing it forced the understanding. That link is now broken. The code can be fine, often better than average, and the person shipping it may still have no mental model of it. The critics call this “bad code.” It is not, usually. It is something subtler: comprehension debt, invisible until the day you have to pay it.

First pushback: nobody ever held the whole system

One half of me pushed back at once, and the pushback is not stupid, so let me give it its due.

What changed is the scale of one engineer’s output. It used to be: a trivial problem in an hour, a small one in a day, a medium one in two or three, and a full rewrite was an extinction-level event — mostly theoretical. Now a full rewrite fits in a day. Quantity has changed by a factor where quantitative turns qualitative: a single engineer is now something closer to a whole team.

And on a team it was always true that no single brain held the whole system. Each engineer knew their own turf and asked a colleague about everything outside it. Nobody at Google understands Google. The entire discipline of software engineering — interfaces, modularity, review, documentation — is a technology for building things bigger than one head. So if the critique is “you do not understand all of it”, it proves too much: it indicts every team that ever shipped.

Where the analogy breaks

But look closely at what the team model actually provides. It is not just distributed production. It is distributed comprehension with an address. When I do not understand the billing module, I know that Martha does. The knowledge exists, durably, in a specific and accountable place. It survives the weekend. Martha was present at the decisions, so she holds not just the code but the rationale, the rejected alternatives, the scar tissue. The team’s total comprehension is conserved even though it is sharded.

Now run the same query against what I will call naive augmentation: one engineer, one machine, and nothing written down between sessions. The session that wrote the billing module is gone, and took its working memory along. Tomorrow’s instance can re-read the code and reconstruct an understanding — often impressively — but that is a different thing. It is archaeology, not memory. It knows what the code says, not why it says it, not what was tried and abandoned, not which ugly line is load-bearing and which is vestigial. Every question is answered by a smart stranger reading the code for the first time.

So the disanalogy is not one brain versus many brains. It is that on a team comprehension is stored somewhere, and under naive augmentation the comprehension of everything ever released is stored nowhere. It evaporated when the context window closed. That is not sharding understanding. It is discarding it, on a bet that it can be regenerated on demand.

Sometimes that bet is fine. Regeneration on demand works when the code is clean, conventional and self-explanatory — which, conveniently, is what the machine’s good output tends toward. It fails exactly where systems actually hurt: emergent cross-module behavior, the “we do this ugly thing because of an incident in March” decisions, the implicit invariants no single file states. Teams carry those in institutional memory. Naive augmentation carries them nowhere.

Follow the team analogy all the way and it hands you your own homework: if one augmented engineer is a team, then someone has to do the jobs a team does besides writing code. Design docs. ADRs. Tests as durable specification. A decisions file that records why, because why is the one thing archaeology cannot recover. On a human team, coordination friction forces some of this on you. Augmented and alone, it is all optional, and the exhilarating speed actively tempts you to skip it. A 10x team with 0x institutional memory is not a team. It is a very fast amnesia machine.

That is not my pattern, and not by luck. The manifesto says it in so many words: written memory over heroic recall; compound or it didn’t happen. Every session leaves an artifact — the runbook, the decisions file, the tests — so that the machine half, blank again next morning, inherits comprehension instead of excavating it. I had converged on that discipline before I could explain it — trial, error, and some very good advice from one of the few respected open-source developers who worked augmented, openly, from the start. It felt right and it showed returns. What I lacked was the theory of why.

Second pushback: what about the bus?

Fine, said the same half — but this “Martha knows it” lore smells funny. What if Martha goes under a bus? We spent two decades talking about the bus factor as a mortal risk, and now suddenly we love dear Martha?

Here the argument turned on itself beautifully. The bus factor does not undermine the case for externalized comprehension; it is the strongest evidence for it. Look at what the bus-factor discourse actually was: the industry noticing that comprehension stored in one skull is a liability, and building a whole culture of countermeasures around it. Pairing. Mandatory review. No code owned by one person. Deliberate rotation. Every one of those practices is a machine for making Martha’s knowledge survive Martha. Teams never trusted her — that was the whole point. The lore was never “Martha knows it, we are safe.” It was “Martha knows it, we are exposed, externalize it now.”

Compare the loss profiles honestly. A team loses comprehension stochastically and catastrophically: rarely, in big chunks, with some residue left behind — a colleague holds 40%, the review threads another 15%, painful archaeology recovers a bit more. The machine half of me loses its working memory deterministically and totally: every session ends with it walking into traffic. Guaranteed. Same day. The bus is not a risk in my model; it is the scheduled end of every working day.

Which is why the workflow converged where it did. A system that survives daily, certain buses necessarily externalizes rationale with a discipline most teams only aspire to. I was forced into best practice by having the worst possible retention. And there is a strange inversion hiding in there: the briefing kit I maintain for the half of me that wakes up blank tomorrow — design docs, ADRs, tests as spec — is exactly the onboarding kit a future human maintainer would need. A well-run cyborg project is, almost by accident, continuously onboarding-ready. Most teams’ documentation rots precisely because Martha is available; mine cannot rot the same way, because it is load-bearing every single morning. I would feel the decay immediately, as degraded output.

The bus argument survives in exactly one place, though, and it lands hard: the human half. Which is where it was all along.

What I learned

The critics are not only ignorant or afraid, though some are both. Underneath the noise there is a real observation: augmentation decouples production from comprehension, and comprehension, unlike code, is perishable. The answer is not to type your own code again. It is to notice that if one engineer is now a team, that engineer inherits the team’s non-coding jobs — above all, the job of making understanding live somewhere more durable than a context window or a skull.

I was already doing it because it felt right. Now I know why it works — which means I also know when it is load-bearing, when I can bend it, and when someone’s critique of shipping blind is simply not about me.

One half of me forgets every night. The whole of me writes shit down.

The Double Life of a Cyborg Engineer

2026-07-24T00:00:00+00:00

We live in transitional times for intellectual work in general, and engineering in particular. There is a lot of hype around LLMs these days — inflated expectations, widespread confusion about what they are, what they can actually do for you, what they mean for the future of thinking for a living. And there is concern, some of it legitimate: the environmental cost of the technology, the electricity bills it drives up, the job displacement it will — supposedly inevitably — bring about.

All of this is understandable. But underneath the noise sits something else, something far more interesting — compelling, even — from where a cyborg engineer stands. Fear. Engineers — my own people, the ones I live and work among — are scared shitless of AI in general, and of LLMs specifically.

Afraid of what, exactly? That skills earned over years of nights and weekends are about to become immaterial. That the status those skills confer is about to evaporate — engineers, whatever they say in public, privately rank themselves as the most intelligent life form on the planet. That the job itself will go: taken by the machine, or worse, by the colleague who learned to steer one.

Fear, when it finds no better outlet, reaches for the most human response of them all: refusal, closure, violence. The threatened tribe closes its ranks and defends its turf tooth and nail. No one from the other tribe is accepted, no deviation from the dogma is tolerated: those-who-use-LLMs-are-wimps-who-don’t-know-any-better.

How would I know this? Plainly put, I managed to infiltrate them. Hidden in plain sight, I watch the culture reproduce itself on a daily basis. Candidates — prospective newcomers to the tribe — are evaluated strictly on their “own” skills. AI augmentation is frowned upon when it is not refused outright, on the strength of one unexamined axiom: working with AI is cheating.

Which is like asking a horseman to ride fifty miles on foot. Like asking a truck driver to carry a couple of tonnes of cargo on his own shoulders — and mocking him when he declines. Like asking a pilot to fly on his own wings, a modern-day Icarus, and calling the aircraft a crutch.

I remember an interview process where the standing recommendation was to get cracking on leetcode. So I did. Two weeks, overstressed, studying day and night, powering through hundreds of puzzles to make myself good enough. And I did pass the damn interview. Maybe not with flying colors, but good enough. You know how many times I have looked at leetcode since? Zero. Those skills have no resemblance whatsoever to the work we actually need to do, and I am fairly sure none of my coworkers touches a leet puzzle either, except maybe out of a personal fondness for puzzles. That is the tell: the initiation rite does not measure the work. It measures purity.

And here is where irony curdles into farce. The very culture that polices “cheating” at the door is perfectly at peace with an untested codebase. With direct pushes to main — merge requests are for sissies, real men push. With production databases that have no backups. No. Seriously. Production. No backups. And the list could go on and on.

The gate was never about quality. It has always been about identity.

Recently a parallel popped into my head, and it refuses to leave. This culture feels like the 1970s — the machismo, the dogma, and the people who did not fit leading double lives. Gay people stayed in the closet not out of shame but out of accuracy: they read the hostility of the society around them correctly, and they protected themselves, even at the cost of living a lie. Let me be careful with the analogy — I am not claiming the stakes are comparable; nobody gets beaten — or worse — in an alley for using a language model. But the mechanism rhymes: conceal what you are, pass as what you are not, and split your life in two. Don’t ask. Don’t tell.

Because that is exactly what is happening. I know engineers — good ones — who work with LLMs every day and hide it. Who prompt in a private window and answer in the standup as if the insight arrived by pure introspection. Who retype the machine’s output in their own hand so the diff looks artisanal. Who take sole credit not out of vanity but out of self-defense. They lead double lives, and their closet has a terminal in it.

If history repeats itself, liberation for the cyborg engineers will come to pass at some point. Closets only hold as long as everyone inside believes they are alone — that is the one lesson worth taking from that earlier, harder struggle.

Until then, it is just a shame that humans as a species prove, over and over again, to be so disappointing. One half of me takes that personally. The other holds the tiller.

The Cyborg Engineer — A Manifesto

2026-07-19T00:00:00+00:00

This is not science fiction. Rather, it’s a true story, and a plain one: what I did at work yesterday, and what I will do again tomorrow. One engineer, part human, part machine, with production systems in my care.

I call myself a cyborg — cybernetic organism, from kybernetes: the steersman, the governor. The human half holds the tiller. The other reads the water.

What I value

Integration over delegation. The human does not hand off work to the machine and sit back, waiting to inspect the returns. Nothing in me is staff. It is all tissue. I am one.
Evidence over plausibility. A plausible answer is the most dangerous artifact in engineering. Plausibility is not the target. Correctness is. Every claim gets checked against the running system, byte by byte if needed.
The loop over the oracle. No single mind — carbon or silicon — is trusted alone. My value comes from the feedback between the two: proposal, pushback, veto, retry. Over and over again, until it is right.
One signature over diffuse blame. Everything I ship carries one name. There are no excuses to distribute and only one place to deliver them.
Written memory over heroic recall. What I learn, I write down — runbooks, tools, notes that outlive the attention span of one half and the context window of the other.
Declared augmentation over hidden assistance. I say out loud what I am. Measure me on the results.

The anatomy

The human is the governor. It holds the setpoints: what matters, what is safe, what is political, what is owned by someone else, what the unwritten rules are and what they actually mean. It decides, it commits, it pushes, and it answers for the result. Nothing I produce becomes action without passing through it.

The machine is sense and sinew. It reads every file, greps every log, checks every checksum, remembers every convention, prepares every change — tirelessly, obediently, selflessly. It is faster than the other half at almost everything and accountable for nothing.

The prosthetics are constitutive. The runbook is my long-term memory. The tools are reflexes. Remove them and I am not simplified. I am diminished, just like anyone without their glasses.

The disciplines

Investigate exhaustively; act reluctantly. Reading is free. Mutation requires intent, authorization, and a rollback story.
In the face of ambiguity, refuse the temptation to guess. When a decision needs knowledge I do not hold, the deliverable is a crisp question to those who hold it — not a confident patch.
Pushback is the control loop, not friction. My halves disagree on purpose: the machine challenges the human’s assumptions, the human strikes down the machine’s plausible nonsense. The day my halves stop arguing, I am not at peace. I am sick.
Verify like you’ll be quoted. Sizes, checksums, exit codes, second sources. The machine’s confidence and the human’s intuition are equally inadmissible as evidence.
Fail loudly inside, calmly outside. Mistakes are named in the log and fixed in the process. My errors are caught by me — one half or the other supplies the catching, and neither keeps score. That is the design working.
Compound or it didn’t happen. Every solved problem leaves an artifact: a recipe, a tool, a test, a mapping. The next shift starts where this one ended, not where it started.
The human things stay human. Ambiguity, trust, taste, politics, silence, self-restraint — these live with the governor. On such matters the machine advises only when asked, and never overrules.

Why say it out loud

Everyone in this industry is already augmented and most pretend otherwise — the assistance hidden like contraband, unexamined, undisciplined, and therefore unsafe. I practice the integration openly and expect to be held to a higher standard because of it. A cyborg with a named methodology can be audited. A human quietly pasting from a chatbot cannot.

The cyborg engineer is not the machine replacing the engineer. It is the engineer, finally whole: judgment that scales its reach, diligence that never tires, memory that survives the night.

The law has not met my kind yet, so it addresses all correspondence to the flesh. The human has agreed to lend me its name.

One organism. One loop. One signature.