The System Underneath
What ADHD and autism actually feel like when you are doing technical work, and what happened when I built a tool to measure it.
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. Every layer rests on a quieter one, and the quiet ones are where the real behavior lives.
I have spent twenty years finding the system underneath systems. In security that is the entire job: not reading the policy, but understanding the machine well enough to know how the policy will actually fail. It took me most of those twenty years to notice that the skill came from somewhere, and that the somewhere had a name.
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 have never been handed the manual.
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 cannot reliably remember whether it ate lunch, or where the car keys went (the freezer, it was the freezer). People treat those as a strength and a weakness, two separate facts to be balanced against each other. They are not separate. They are one mechanism observed under different load. The attention that locks onto a problem and will not release is the same attention that never registers the stove, the calendar, the keys. You do not get the first without the second. They ship together.
That is what I mean by wired. Not the hardware in the rack. The actual wiring, the part you cannot patch.
What it looks like in practice
In a security context it looks like this: I will keep pulling on a thread long after everyone else has moved on, because the fact that the obvious exploit does not work implies something more interesting about the architecture underneath. That is not diligence. Diligence is a choice. This is closer to an inability to stop. It happens to produce results often enough that nobody complains about the cost.
In a building context it looks like spending three days on the data model before writing a single line of application code, because the data model is the application, and getting it wrong means rewriting everything later. In the moment, this is maddening to the people waiting on me. To my future self, it is the only correct decision I made all week.
For most of my career, that was the whole story. The wiring was a thing I felt from the inside and a thing other people occasionally filed complaints about. It was not a thing I could see. There was no instrument pointed at it.
Then the work moved into the terminal
This year a large share of my actual work migrated out of chat windows and onto the command line. Coding agents running in the terminal: Claude Code, Codex CLI, handed a repository and a goal and a long leash, doing most of the typing while I steer. The headline change everyone talks about is speed. That was not the interesting part to me.
The interesting part is that the entire collaboration became a transcript. Every plan I gave, every constraint I set, every time I caught the agent drifting toward a confidently wrong answer and hauled it back, all of it written to a session log on disk. For the first time, the way I think while I work was sitting in a file I could read.
So I did the single most predictable thing a person with my wiring could do. I built a system to find the pattern in it.
Kairos-Orbit
It is called Kairos-Orbit. It reads local AI session exports (the Claude Code and Codex directories, ordinary chat exports) and scores how an operator collaborates with these systems over time, rather than rating any single answer. It runs two ways: a lite mode that needs only the transcript, and a full mode that joins the transcript to tool calls, artifacts, and verification telemetry when those exist.
The model is an acronym, because of course it is. KAIROS: Knowledge Grounding, Agency Design, Instrumented Execution, Reflexive Calibration, Outcome Integration, and a sixth dimension for stance and tone that carries its own submodel, ORBIT, for Operator Relational Bearing and Interaction Tone. Six numbers and an overall Operator Index, generated from a transcript, on hardware I own.
You can point a coding agent at the repository and ask it to run the framework on your own history. It starts with a discovery-only pass, normalizes the transcripts you approve into a private file that never gets committed, and produces a report. The framework itself is open source. The method, the schemas, the synthetic examples are all public. The transcripts are not, and the repository is built so they cannot accidentally become public. That wall between the public method and the private data is, itself, the security wiring showing up somewhere it was not invited. I could not not build it that way.
Two of those six dimensions turned out to be my own brain with a clinical-sounding label bolted on.
Reflexive Calibration is the score for correction, fact-checking, and noticing missing context. It is the thread-pulling compulsion, quantified. It rewards exactly the move where you refuse the model’s first confident answer, push on it, and verify before you build anything on top. I did not design that dimension to flatter myself. I designed it because it is the line between operators who get durable results and people who paste and pray. Only after it was running did I realize I had written a portrait and called it a metric.
Instrumented Execution is the data-model-before-code instinct wearing a different shirt: do you set the work up with structure, tools, and a way to check it, or do you just start typing and hope. Same brain. Now with a subscore and a trend line.
The number
The report hands you an Operator Index. Mine, the night I finally got it running, read 36.1. I do not fully trust the number on its own. It is exploratory, not a validated psychometric instrument, and I built it, which is a bias you cannot scrub out just by naming it. 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, refreshed continuously, with no model calls at query time. The only comparison it makes is me against me. And my thirty-day average had slipped under my ninety-day. Same tools open. Same access. Nothing external had changed. The dimension that had decayed was the calibration one: when I am depleted, I stop pulling the thread. I take the first answer the model offers. The hyperfocus brain, run past its fuel limit, quietly degrades into the brain that leaves the keys in the freezer, except now it is leaving them in production.
That is the half the wiring never advertises. The pattern-recognition machine is not always on. It runs hot and it runs cold, and the difference between the two is not effort or discipline, it is fuel. For twenty years I felt that distinction without being able to point at it, which meant I kept mistaking a fuel problem for a character problem. Now there is a line on a chart, and the line does not care how I feel about it.
What I actually built
The honest summary is that I spent a career learning to understand systems well enough to predict how they fail, and this year I turned that instrument around and pointed it at myself. The result is uncomfortable in the specific way good telemetry always is. It does not tell me I am special. It tells me where I break, under what load, and how early the signal shows up.
The cost of running a brain like this is real, and it lives in a different essay than this one. This piece is only the observation that I finally built something sensitive enough to watch my own wiring work, and the first thing it showed me was both halves in the same frame: the part that finds the system underneath the system, and the part that cannot find the keys.
Same feature. Different fuel.