The Work Looks Like Nothing
The top of the IC ladder is well traveled and still unmapped. Pattern recognition fails there, and even the best AI models can't do it reliably.
No two of these people have the same story. They're very often deeply technical. Many can break through political theater without raising their voice, and most can talk upward or downward depending on the audience. They can be innovators and creative geniuses while also being your best defense against an irreversible mistake. Some are wired this way and some learned to be. Both work.
They're hard to find, and the usual explanation is that the work is invisible - that judgment leaves no trace, that you can't measure it, that you take it on faith and hope the interview was good enough to catch it. That overstates it. Plenty of the work shows up, and we aren't paid badly for it. But roughly half of the judgment never reaches the balance sheet, and that half was never impossible to see. It was hidden by the way it used to travel. That has changed, and once it has, staying invisible becomes a choice. The strange part is who ends up holding the switch.
A Measurement Problem, Not a Psychology One
Start with the half that never gets a price: the waste you avoided. A vendor trap that doesn't close, a migration that gets scoped down before it becomes a decade-long burden, a platform purchase the room walks back from before the check is written. None of these show up neatly in a retrospective. The decision that prevented them may have happened in a forty-minute meeting and produced nothing beyond a different direction.
The organization pays a fair salary for the seat, and the salary quietly covers two different things: the work that produced a commit, and the work that produced an absence. Only the first half has a price tag. The second doesn't always become a ticket or a dashboard. It's the absence itself - of rework, escalation, outage, cleanup, regret - and an absence is easy to take without ever paying for it.
To the person doing it, the work feels like noticing things, and pattern recognition doesn't feel like labor. That's where impostor syndrome comes from for this kind of person. It's a measurement problem you end up carrying around inside, as much as a psychology one. If no system records the work, eventually some part of me starts to wonder whether the work happened at all.
Why the Trail Disappeared
Judgment still can't be measured, and I'm not trying to change that. You can't put a number on the decision not to build something. But measuring was never the only way to make the work real. The work could always have been seen. It just had nowhere to be seen.
For most of a career at this level, the way to make judgment matter at scale is to stop typing and start influencing. Staying on the keyboard actually lowers your value, because the keyboard is a bottleneck. If you can influence other engineers, your worth compounds - through "do this" and "not this," through the mistake talked out of the room, through the design that quietly gets a second pass. It doesn't feel like working while you do it. The day you're most useful is often the day you typed the least, and some part of you files that as a day you got away with something. That feeling is what a missing record feels like from the inside.
But influence that travels through people is exactly what erased the trail. A human hears "not this," does a drifting, lossy version of it, and ships something downstream. By the time the contribution lands it's been laundered - rephrased, credited to someone else, softened, absorbed into someone else's commit. The judgment was real, and the record of it was deniable. That's less a sad story about recognition than a transmission problem: the work was invisible because it passed through a medium that doesn't keep fingerprints.
The Mirror
The medium changed.
Now there's an executor that follows my instructions as well as I can write them and doesn't drift unless I cause the drift. The laundering step is gone. What comes out the other end is my judgment run forward, not a colleague's interpretation of it. The output is the mirror.
And the session that produced it is a record of how I reason, not just what I shipped. A git history shows the destination. The session shows the thinking - what I checked before I touched anything, how I cut the problem apart, what I refused to do and why. That record didn't exist in any work artifact before. It does now, as a byproduct of doing the work at all.
So I can say something that used to be impossible to say: the log preserves judgment. I can look at a person's Claude Code logs and know exactly how they go about reasoning about a build.
I want to be precise about what I read for, because it isn't what people assume. I read for reasoning, and in my frame the quality of the output is irrelevant - the two can go hand in hand, but they aren't the same axis. The log is the truth, and the score is a lens I lay over it afterward. A clean result built on lucky guesses reads differently in the trace than a rough result built on sound moves, and it's the moves I'm after.
The Bookshelf
For me there's little mystery to where the moves come from. I read the kind of books that train you to see systems under stress: Perrow on normal accidents, Langewiesche on aviation, Therac-25, fire command, mining disasters. When a system meets a force it was never designed to absorb, I want to know what failed first.
People at this level got their foundation from different places: operations, regulation, a decade inside a critical legacy system. Where it came from matters less than the fact that there is one - earned, hardened, and not something a certification or an onboarding doc can replace.
I don't have to vouch for that foundation separately, like a credential. It's the shape of the reasoning itself. The books I've read let me see the shape of a problem and then build bottom up, safely and quickly, with almost no guardrails, because the guardrails are already in place between my ears. I think bottom-up, and that's completely visible in my logs, in the moves I make and the moves I never make. Chat history is downstream of the bookshelf.
Private Telemetry
The first build sounds unimpressive when stated plainly: a Python script that mines my own Claude Code session logs into a local SQLite database, runs weekly, and produces a markdown report of what I've actually been working on, how fast I did it, and what I picked up along the way. I didn't build it to manufacture evidence. The record is a byproduct. The session is the artifact, and the codebase is the valuable leftover.
That distinction matters more than it might seem. A record you sit down to produce on purpose - a design doc written to be pointed at later, a status update composed for an audience - is performance. I was never going to produce that, and not because I couldn't. Making the artifact for its own sake is exactly what this kind of mind refuses, and until now that refusal cost something. It doesn't anymore. What I have instead is the exhaust of the work, captured because the work now leaves exhaust. The part of the job that used to evaporate now writes itself down.
The same tools that made the record possible also made more of the work possible. A prototype that used to look like nothing now looks close to complete. A weekend project that wouldn't have happened becomes a public OSS repo. The argument made in a meeting still leaves no commit at all. The keyboard used to be the bottleneck. For me, it isn't anymore.
What the Market Cannot See
The market says it wants Principal ICs. What it usually means is people who can ship, lead without theater, spot failure modes before committing, write down the risks they accepted, define early warning signals, and keep building artifacts when the official record is too thin to hold the truth.
It pays for the half it can see and takes the other half for free, because that half had no price tag. The log is the price tag it never had. And it filters cleanly in a way a resume never could, because you can't perform your way through a session trace. The trace rewards how you reason, not how you package it. The people who are worst at the performance - who won't craft a resume full of the right nouns, who go quiet in the part of the interview that rewards confidence over correctness - are often the ones whose logs are strongest. That's the match I'm trying to make: employers to the engineers who won't destroy their systems and are invisible to the job market precisely because they refuse to perform.
These people are buried inside regulated industries - platform teams, compliance-heavy domains, infrastructure groups, health care, insurance, finance, government, manufacturing. They prevent six-figure remediations in environments where the cost of being right can become invisibility. They aren't always easy employees, or easy candidates. They can be allergic to vague authority, process for show, and design choices that push today's ambiguity onto whoever comes next.
That's the whole point, and it isn't irony. The profile most likely to read its own work as "just thinking carefully," most allergic to performing it, most certain it isn't worth what it costs - that's the profile screening for resemblance was built to miss. It's also the profile that would rather build the measurement than sit for the interview. So the instrument that ends the invisibility gets built by the one person the old system was set up not to see. That's no coincidence. The same wiring does both.
It's engineering applied one layer earlier, by people the record was never built to see.
They still doubt they're worth what the market would pay them, but the doubt is running out of road. The moat doesn't evaporate on its own - it never has - but it doesn't hold against the person who builds the switch, and the switch is theirs now.
-- Justin Higgins. Software Engineer, Midwest. Two decades in regulated systems. Built the instrument that finally records what the work was.
Companion pieces: The Principal IC Moat - the diagnosis this instrument was built against. Everything Looks Like Everything - the instrument turned on a corpus that refuses to disambiguate itself.
Reactions, disagreements, war stories: jchigg2000.dev@gmail.com