The System Underneath

Every system has a system underneath it.

The firewall has a rule engine. The rule engine has an evaluation order. The evaluation order has an implicit assumption about traffic timing that nobody wrote down, and the reason nobody wrote it down is that the person who understood it left in 2019 and the documentation was aspirational.

I have spent twenty years finding the system underneath systems. It turns out that is a skill, and skills come from somewhere.

The pattern-recognition machine

Late-diagnosed ADHD and autism are the operational reality of this brain. I am not writing this for sympathy. I am writing it because it explains the show, and because most of the technical people I know who work the way I work are running the same operating system and don’t have a name for it yet.

The brain that cannot let go of a problem until it finds the underlying pattern is the brain that is good at this work. The same brain that hyperfocused through a twelve-hour debugging session is the brain that can’t remember whether it ate lunch, or where the car keys went (the freezer, it was the freezer). These are not separate features. They are the same feature, observed under different load.

That is what “wired” means as a pillar here. Not the hardware in the rack. The actual wiring.

What it looks like in practice

In a security context: I will keep pulling on a thread after everyone else has moved on, because the fact that the obvious exploit doesn’t work implies something more interesting about the architecture. That is not diligence. It is closer to compulsion. It happens to produce results.

In a building context: I will spend three days on the data model before writing a line of application code, because the data model is the application, and getting it wrong means rewriting everything later. Colleagues find this maddening in the moment. My future self finds it correct.

For most of my career, that was the whole story. The wiring was a thing I felt, and a thing other people occasionally complained about. It was not a thing I could see.

Then I built something to look at it

This year a lot of my work moved into the terminal. Not chat windows: coding agents running on the command line, Claude Code and Codex CLI, handed a repo and a task and a long leash. The interesting shift was not speed. It was that the whole collaboration became a transcript. Every plan, every correction, every time I caught the agent heading down a wrong path and pulled it back, written to a session log on disk.

So I did the obvious thing for someone with my wiring. I built a system to find the pattern in it.

It is called Kairos-Orbit. It reads my local AI session exports and scores how I actually collaborate with these systems over time, across six dimensions: how well I ground the model in context, how clearly I design the agent’s goals and scope, whether I instrument the work with real tools and verification, whether I catch my own errors and the model’s, whether I turn the result into something durable, and the tone I take while doing it.

(I open-sourced the framework with synthetic examples and no private transcripts in the repo. The instinct to put a hard wall between the public method and the private data is, itself, the security wiring showing up. I could not not do it.)

Two of those dimensions turned out to be my brain with a clinical-sounding label on it.

“Reflexive calibration” is the score for correction, fact-checking, and noticing missing context. It is the thread-pulling compulsion, quantified. The framework rewards the move where you refuse the model’s first confident answer, push back, and verify before you build on it. I did not design that dimension to flatter myself. I designed it because it is what separates good operators from people who paste and pray. Only afterward did I notice I had written a portrait.

“Instrumented execution” is the data-model-before-code instinct: do you set the work up with structure and a way to check it, or do you just start typing. Same brain. Now with a subscore.

The number

The report gives an Operator Index. Mine, the night I got it running, read 36.1. I do not fully trust the number yet. It is exploratory, not a validated instrument, and I built it, which is its own kind of bias. But I trust the trend, and the trend told me something I did not want to hear.

A companion dashboard scores the same signals every day. The comparison is me against me, not me against anyone else. My thirty-day average had slipped under my ninety-day. Same tools open. Same access. The dimension that had decayed was the calibration one: when I am depleted, I stop pulling the thread. I accept the first answer. The hyperfocus brain, run past its limit, quietly turns into the brain that leaves the keys in the freezer, except now it is leaving them in production.

That is the part the wiring does not advertise. The pattern-recognition machine is not always on. It runs hot and it runs cold, and the difference is not effort, it is fuel. For twenty years I felt that without being able to point at it. Now there is a line on a chart.

The cost of all this lives elsewhere, and it earns its own essay. This one is just the observation that I finally built an instrument sensitive enough to watch my own wiring work, and the first thing it showed me was both halves at once: the part that finds the system underneath the system, and the part that cannot find the keys.

Same feature. Different load.