Measuring the human, not just the model.

The asymmetry

In the last eighteen months, more than $200M has gone into knowing whether the model is good: evaluation harnesses, observability, hallucination detection, agent memory. Braintrust, Galileo, Patronus, Judgment Labs, Mem0, Humanloop. Every funded company in the category measures the model. When the first version of this document was written, I could find nothing that measured the human sitting next to it. In July 2026 the first platform instrument arrived — Anthropic's Reflect, taken up near the end of this document — and it measures usage, not judgment. The asymmetry has not closed. It has narrowed to its sharp core.

This is a strange thing to leave unmeasured, because the human is the half that can't be re-run. You can audit an agent's every step. You cannot audit your own. The model side has a complete observability stack. The human side has nothing equivalent.

That gap is the subject of this document. Not whether the AI is good, which is well funded and well studied, but whether the person directing it is still doing the thing they think they're doing.

Why outputs can't answer this

The reflex is to look at the work. If the output is good, the collaboration must have been good. As AI output becomes statistically indistinguishable from human output, that inference breaks: the artefact tells you less and less about how it was made, or who was thinking while it was made.

Two distinct questions fall out of that, and they are not the same:

• Provenance — was this work genuinely human-led, and can that be shown to someone else? A question of trust and attestation, with an adversary. Tools are now arriving to answer it — cryptographically sealed process records that can prove how a piece of work was made. That lane matters, and it certifies the past. It cannot tell you whether the person could do the work again tomorrow.
• Judgment — is the person directing the AI still exercising the judgment they believe they are? A question of self-knowledge, with no adversary but yourself. This is the question about the future, and no one is instrumenting it.

Crux takes the second. The distinction sets what the instrument can honestly be: something that convinces no one but you needs no cryptography and no proof, and falls apart the moment it pretends to be evidence for anyone else. This is measurement in the plain sense — an honest record of how you actually engaged, read back to you over time.

This is not new: forty years of automation research

The most important thing I can say about cognitive surrender is that it is not a 2025 discovery. The human-factors literature has been describing it since 1983, in cockpits, control rooms, and operating theatres, long before a language model wrote anyone's code.

Lisanne Bainbridge named it the irony of automation (Bainbridge, 1983): automate the easy parts of a task and you leave the human with the harder residual job of monitoring, a job humans are poorly suited to, while their hands-on skill quietly decays from disuse. The result is a person least practised at exactly the moment a failure demands they take over. Her conclusion was the opposite of intuitive: the more capable the automation, the more skilled its human operator needs to be.

The empirical base under that idea is deep and consistent:

• Overreliance is a named failure mode, not a personal weakness. Parasuraman & Riley (1997) classify it as the "misuse" of automation, producing failures of monitoring and decision bias.
• Experts are not immune, and practice doesn't fix it. Parasuraman & Manzey's (2010) review finds automation complacency and bias "in both naive and expert participants," that complacency "cannot be overcome with simple practice," and that bias "cannot be prevented by training or instructions." The problem is attentional and structural, not a matter of trying harder.
• A good-but-imperfect aid can make you worse than no aid. Skitka et al. (1999) found people with a highly-but-not-perfectly reliable aid underperformed those with none, through both omission and commission errors. Training reduced commission errors but not omission errors.
• It happens to professionals, and disposition beats mandate. Experienced glass-cockpit pilots made the same errors, and even misremembered seeing cues they had never verified (Mosier et al., 1998). The ones who cross-checked had an internalised sense of accountability; externally imposed accountability changed nothing.
• The mechanism is lost situation awareness. Endsley (1996) calls it the "out-of-the-loop performance problem": move a person from active doer to passive monitor and they become slow to notice that something has gone wrong, and slow to grasp the system's state once they do.

The "artifact paradox," polished output suppressing scrutiny, is in this older vocabulary just automation complacency under a new name. The mechanism is well established; what's sobering is that it has already resisted forty years of awareness.

The same pattern, now in software

What's genuinely new is the domain and the speed. The recent evidence maps the old findings onto AI-assisted knowledge work almost point for point.

• Confidence in the AI predicts less critical thinking. Across 319 knowledge workers and 936 real GenAI work examples, higher confidence in the tool tracked with less critical thinking; higher confidence in oneself tracked with more (Lee et al., 2025). The work doesn't vanish; it shifts from doing to verifying, the exact monitoring role Bainbridge warned about.
• Frictionless generation leaves less behind. An EEG study (Kosmyna et al., 2025, preprint) found LLM essay-writers had the weakest neural connectivity of three groups, and 83% could not quote a sentence from the essay they had just written (versus ~11% of the others), with the lowest sense of ownership. Small sample, single task, not yet peer-reviewed, but directionally striking.
• Delegation lowers comprehension; comprehension-first preserves it. An Anthropic trial (Shen & Tamkin, 2026) had people learn an unfamiliar library by hand or with AI. The AI group scored 50% on a comprehension quiz versus 67% for hand-coders (Cohen's d = 0.74), for a time saving that wasn't significant. The largest gap was debugging. But people who generated code and then asked questions to understand it scored higher. How you use it is the whole variable.
• The craft signal in the artefact is degrading. Across 211M changed lines (GitClear, 2025; vendor, correlational), copy-pasted code rose from 8.3% to 12.3% (2021–2024), refactoring fell from ~25% to under 10%, and duplicated blocks grew several-fold. Output up, maintainability down.
• Adoption rises while trust falls. Stack Overflow's 2025 survey (49,000+ developers) found AI use near 80% even as trust in its accuracy fell from 40% to 29%; the top frustration (45%) was "almost right, but not quite," and 66% spend more time fixing AI code. People rely increasingly on output they themselves distrust.

The same split appears across professions. In automated cockpits it is the cognitive skills that erode with disuse while stick-and-rudder skills are largely retained (Casner et al., 2014) — judgment goes before fluency, the exact distinction this project is built on. Habitual GPS use predicts steeper decline in hippocampal-dependent spatial memory (Dahmani & Bohbot, 2020). Radiologists given a wrong AI suggestion saw accuracy fall across every experience level (Dratsch et al., 2023), though that is real-time automation bias, not proven long-term deskilling.

Why now — the judgment moments are vanishing

Three things are happening to AI at once, and all three make pushing back harder. It is becoming relational (a face is harder to argue with), persistent (it remembers your concessions), and accurate about you specifically (it increasingly sounds like what you'd have said if you'd been smarter for longer).

Together they shrink the human's contact with the work to a handful of seams. In June 2026, three of the most-read voices in the field described the same shift within days of each other:

The work has moved from process to outcome. What's left of the human's contact is three moments: the brief, the mid-flight redirect, and the sign-off. And the loop-engineering stack instruments every part of itself (maker/checker splits, verifier models, adversarial review) except the human who designs it and signs off. Osmani's line assumes the human knows the difference between using the loop to go faster and using it to avoid understanding. The evidence below says the human is the last to know.

The ownership account

The studies above measure capability: comprehension scores, error rates, neural connectivity. Through mid-2026 a second account has been accumulating in practitioner writing — essays, forum threads with thousands of working engineers in them — and it is consistent enough to treat as data. Its subject is not whether the skill is decaying but whether the work still belongs to the person who shipped it. The same account comes up in private, whenever engineers are asked how the year has actually felt.

The reports share a shape, and each element has a study standing behind it:

• Decisions that don't embed. Engineers describe finishing AI-heavy projects faster and knowing them less. A decision you make lodges; a decision made mid-flight by the loop and presented for approval afterward does not. This is Kosmyna's 83%-can't-quote finding narrated from the inside — and it is what Shen & Tamkin's debugging gap predicts it should feel like six months on, when the code needs changing and the person who shipped it reads it like a stranger.
• The defendability test. The practitioner version of a comprehension quiz is social: someone asks why was this done? and the person who shipped it can narrate the outcome but not the decisions under it. Rozenblit & Keil showed people discover the illusion of explanatory depth only when forced to explain; an AI-heavy workflow arranges for that discovery to happen out loud, in front of whoever asked.
• Verification as the residual job — and as tax. Lee et al. measured the shift from doing to verifying. The practitioner accounts supply the texture: reading confident prose for the buried wrong assumption, task-switching in the minutes while the agent runs, never quite trusting what comes back. Deedy Das (Menlo Ventures, June 2026), on the split inside teams pushed to adopt: "The craftsmen are tired. Very tired. The entire burden of review falls on the craftsman. The burden of understanding." The verification lands hardest on the most expert, because they are the ones still able to do it. Anthropic's own analysis of ~400,000 Claude Code sessions found persistent returns to expertise — the tool compounds the advantage of people who already know what they're doing. The practitioner accounts show where the sign flips: expertise compounds when you direct your own agent, and becomes tax when you are accountable for everyone else's.
• The reward loop, stranded. An engineering manager, in the 8,000-upvote thread that followed Das's remarks: normal coding cycles through problem-solving and the reward of solving; AI-assisted coding parks you in "the solution validation phase" where you "barely get any reward. It becomes very mechanical and takes away what a lot of devs love about their job." That is loss of felt reward — distinct from loss of skill, and untouched by status or pay.
• The inversion, lived. From the same thread: "I am no developer anymore. I am the Product Owner with the technical skill they wish they had… plus QA engineer." Mollick's patron shift, reported in the past tense from the floor.

Two features of this account matter for the instrument.

It is bimodal. The same tool, deployed the same way, lands as liberation for the outcome-oriented and as bereavement for the craft-oriented — the threads carry both voices, and the split doesn't track seniority. Population statistics will average the phenomenon away. The unit that can register it is one person, over months, which is the unit this instrument measures.

And every report is, mechanically, a missing-record problem. The decisions existed. They were made in flight — by the person, the model, or the two of them — and left no trace the person can retrieve at the moment of challenge. Organisations are starting to answer the identity half of this with ownership: give people a problem and an outcome, not tickets. Right instinct, and it doesn't touch this. Owning an outcome without a record of the decisions underneath it is stewardship of a black box; you can only defend what you can reconstruct, and the workflow that produced the artefact is exactly the workflow that leaves no reconstruction behind.

That sharpens what the digest in this project is for. Not only a mirror for judgment drift — a record of title: the contemporaneous account of what you steered, checked, and let slide, written while it was warm, retrievable at the moment someone asks why. The literature's question is whether you're still thinking. The practitioners' question is whether the work is still yours. The same record answers both.

Method — how I captured it

I build AI in education, where accuracy and pedagogy are the product rather than a feature, so this question isn't abstract for me. I built the smallest instrument that could answer it on real data and ran it on myself before claiming anyone else has the problem.

Capture is local and passive. A session-end hook reads each session when it ends and writes a structured digest — what I steered, what I checked, what I let go. Nothing identifiable leaves the machine; the measurement can't change the behaviour it measures.

Classification uses a controlled vocabulary — a stable, versioned taxonomy of collaboration patterns grouped by fluency dimension (delegation, description, discernment, diligence), so patterns are comparable across months and a trend is visible rather than a snapshot.

Two altitudes. Session level (per-session digests, classified over four months) and command level (a log-only pass over my full local transcript corpus of 192 sessions, 2,668 shell commands, 22 active days, flagging the rare moments that are hard or impossible to undo). Nothing is reconstructed after the fact: digests were written contemporaneously, the command pass was run log-only, and the full match detail stays local.

One scope note up front. This watches a single channel — my own coding sessions, and only what shows up in the transcript. It does not see the verification real work runs on: code review, automated tests, red-teaming, staged rollout, and domain checks for accuracy before anything reaches a user. A thin in-session signal is a finding about that channel, not a verdict on anyone's total diligence.

Results — run on myself

I built the tool half-expecting to come out looking fine. I didn't.

The headline. Across more than two hundred real coding sessions and the nine hundred-odd messages inside them, four moves account for almost everything that shows up in the record. About one time in four, I visibly push back on whether it's right. I steer how it reads about as often. A third of the time I'm handing over the next task. And roughly one in seven leaves no visible check at all, with one honest caveat: a transcript only sees what I say out loud, so it can't separate a silent, careful read from a genuine wave-through.

The shape is specific. The pushback that surfaces is mostly about how the AI writes, the voice and the approach, and less often, on the record, about whether it's true. That visible-judgment gap is the thing worth watching. At session level, diligence is the structural outlier: weak in roughly 65% of sessions while the other dimensions hold up, and "accepts polish uncritically" is a top-three pattern with no improving trend across four months. The lesson never stuck at the system level — I caught a habit, escalated it to a process fix, and the same fix slipped the next month.

Command level is worse, where it matters most. The hard-to-undo moments are rare, under half a percent of commands, and they were the moments I deliberated over least. So the highest-stakes actions ran with less deliberation than trivial ones, not more.

I take this seriously: I build with guardrails and care about using AI safely, and the substantive checks in my professional work happen off the transcript, in review and testing. Even so, my own in-session record of judgment came out thinner than I'd assumed. Call any single number an estimate; measure it a few ways and it shifts a point or two. But the shape doesn't move.

You can't see it from the inside

The strongest argument for an external record is that introspection demonstrably fails here, and fails worst for the people most affected.

The cleanest evidence is the METR randomised trial (Becker et al., 2025): 16 experienced open-source developers, working on 246 real issues in repositories they knew well, were 19% slower with AI, while forecasting a 24% speed-up beforehand and still estimating a 20% speed-up afterward. A roughly 39-point gap between felt and actual, in experts, on their own code. (Small sample on mature repos; the transferable finding is the perception gap, not a universal slowdown. METR's 2026 follow-up couldn't cleanly re-measure productivity because 30–50% of developers refused to do tasks without AI, which is its own kind of finding.)

This sits on decades of work on miscalibrated self-assessment. Poor performers overrate themselves because the skill needed to do well is the same skill needed to notice you're doing badly (Kruger & Dunning, 1999); the gap survives real exams and even a cash incentive for accuracy (Ehrlinger et al., 2008). People rate their understanding of how things work far higher than they can actually explain, and only find the gap when forced to spell it out (Rozenblit & Keil, 2002). And specifically with AI: people solving reasoning problems with a chatbot scored higher but overestimated themselves more — with higher AI-literacy predicting worse calibration, not better (Fernandes et al., 2025).

The feeling of competence is not a readout of competence, the AI inflates the feeling, and experience doesn't protect you. That is the case for externalising the record instead of trusting the gut.

The leading indicator

Here is the part that is new. Everything else measures surrender after it shows up in the work, once quality degrades or a confident wrong answer ships. That is a lagging indicator.

There is an earlier signal. Dependency erodes two things in sequence: first the capability, then the wanting to exercise it. Skill atrophy is the loss of the ability to check. Appetite atrophy is the loss of the desire to, and it comes first. A person who can still challenge the AI but no longer bothers is the early case, not the late one.

That is measurable, descriptively: the rate at which justification is left blank, or "ship it" is typed, at a one-way door, on tasks plainly still within your ability, read over time. The question isn't whether you're a compliant reviewer; it's whether the wanting-to-own has started to fade. Extended to the patron era, the same read becomes the contest rate at sign-off: when an autonomous run completes, do you genuinely contest even one of its decisions, or accept the whole thing whole?

Why awareness isn't enough

The uncomfortable corollary of the automation literature is that knowing about this changes very little. Complacency and bias persist in trained experts (Parasuraman & Manzey, 2010); training fixed commission but not omission errors (Skitka et al., 1999); my own awareness, on its own, produced no behaviour change.

What has worked, where it has worked, is a structural forcing function rather than exhortation. Croskerry (2003) argued that in medicine, knowing a bias exists is insufficient — clinicians need pre-committed "cognitive forcing strategies" that force a check before acting. Surgical and ICU checklists cut deaths and infections sharply when they genuinely changed the cognitive process (Pronovost et al., 2006; Haynes et al., 2009), and did nothing when rolled out as box-ticking without engagement (Urbach et al., 2014). A recent synthesis names this for AI directly: "scaffolded cognitive friction," repurposing the machinery as a forcing function rather than a frictionless answer-dispenser (Xu et al., 2026, preprint).

This is also why the historical record is unforgiving for tools defended only by individual willpower. Capacities preserved at scale were rescued by codified curriculum, professional standard, or provider infrastructure, never by people resolving to try harder. Aviation rescued manual flying after Air France 447 not with a memo but with mandatory Upset Prevention and Recovery Training written into recurrent checks (BEA, 2012; FAA, 2013). A London cab driver's posterior hippocampus is measurably enlarged by The Knowledge, a multi-year curriculum, not good intentions (Maguire et al., 2000). Spelling, GPS-era spatial memory, and sustained attention, defended by no one, eroded.

The implication for a tool like this is honest and limiting: a personal practice tool genuinely helps the person who runs it, and will not, on its own, preserve a capacity across a population. It demonstrates the shape of the missing measurement. Someone with curriculum, standard, or platform power ships it at scale.

The honest objection

A document that only confirms itself is advocacy. The strongest counter-evidence is real, and it sharpens the thesis rather than sinking it.

AI can deepen learning, not just offload it. A randomised crossover trial at Harvard found students with a carefully designed AI tutor learned roughly twice as much as in active-learning class, in less time (Kestin et al., 2025). Intelligent tutoring systems have matched human tutors for years (VanLehn, 2011). Customer-support agents, especially novices, got 14–34% more productive and appeared to learn faster (Brynjolfsson et al., 2025). And cognitive offloading is, in general, a rational cost-benefit move, not a pathology (Risko & Gilbert, 2016).

Alarm about new tools has a poor track record. Orben (2020) documents a recurring "Sisyphean cycle" of technology panics in which fear outruns evidence and effect sizes prove far smaller than the headlines. Any claim that AI is rotting our judgment has to clear that bar, not assume it.

Two things rescue the argument, and both come from inside the counter-evidence. First, the wins are conditional on how the tool is used. Kestin's tutor was engineered to keep the learner active and refuse to hand over answers; VanLehn's effective systems were "step-based," not "answer-based"; Risko & Gilbert's own caveat is that offloaded capacities atrophy with disuse and that people are miscalibrated about what to offload. The decisive variable is active engagement versus passive consumption, which is exactly what this instrument tries to make visible. Second, even Dell'Acqua et al.'s (2025) celebrated BCG result cuts both ways: inside the "jagged frontier" of AI-suitable tasks, 758 consultants did ~12% more work, ~25% faster, at higher quality; but on a task placed just outside the frontier, AI users were 19 percentage points less likely to get it right, and the authors documented over-reliance, "falling asleep at the wheel." Knowing which side of the frontier you're on is judgment. Nobody is measuring it.

And the one reflex the optimistic case most needs, trusting how good the collaboration felt, is the exact reflex the evidence says to distrust. Students in active learning reliably feel they learned less while learning more (Deslauriers et al., 2019). Fluency is not understanding, and feeling is not fact.

What this deliberately is not

Each constraint is load-bearing; removing it breaks the thing.

• No score. A single number re-instates the worth-by-output logic the project rejects and hands the user something to game. The readout surfaces what you steered, checked, and let slide. Never a grade.
• No cross-user comparison. The unit of analysis is this person, over months, not a leaderboard.
• Stays on your machine. Privacy is the precondition for measuring honest behaviour at all; an instrument you'd perform for measures the performance.
• No cryptographic attestation, by choice. It can prove a file wasn't altered, but not that the words were the human's, nor that capture was complete. A verification that can't establish what it asserts is worse than none. This answers only to the person running it.
• No real-time nagging by default. Off until installed; the one exception is reserved for the user's own highest cut-lines. And per the checklist evidence, a forcing function only works if it changes the actual cognitive process, not if it becomes another box to tick.

What this implies

The same capture-and-synthesis substrate serves different readers as different things, not separate products, different readings of one record.

• For individuals — the Mirror. Patterns over time, the surrender signatures surfaced, at the one moment the loop can't watch itself: sign-off.
• For teams — the Retro. Teams rebuilt how they deliver around AI in months, and mostly never retro the collaboration itself — there is no record to retro over. Workflows live in individual dotfiles and habit; loops rot when nobody owns them; the actual ways-of-working exist nowhere except transcripts nobody reads. A period of digests, shared by choice for one conversation, is the retro pack: which workflows actually ran, what got steered, what got waved through, where ownership sits. Shared reading of self-owned records, never a dashboard of anyone else.
• For enterprises — the Trail. The audit trail you actually need is not the AI's logs of what it did, but the human's record of what they engaged with, challenged, and let through. AI-side-only observability is a one-sided accountability picture.
• For professional bodies. The AI-collaboration audit trail will become part of professional competence within five years. The fields that codify what "competent AI use" means will define it; the rest will have it defined for them.
• For providers. Ship the human-side counterpart to the model-side memory and observability you already build. The full case is the memo below — tier one of which shipped in July 2026.

The labor question

Everything above frames the missing measurement as self-knowledge. Held at arm's length, it is a labour-market problem, and I think it is the most underpriced one in the current argument about AI and work.

The displacement debate asks whether AI takes jobs. This document is about the quieter scenario that arrives first: people keep the job and lose the capability. Employment continues; the judgment the role depends on erodes inside it, undetected — because every proxy we use to detect capability is an output proxy, and output is now the part the AI supplies.

Hiring signals break first. A portfolio, a commit history, a take-home: each now evidences access to tooling, not judgment. The market has noticed — developer hiring is shifting hard toward live aptitude assessment — but an interview samples fluency, and fluency is teachable, table stakes, and rising fast enough to stop differentiating. What differentiates is whether the candidate still contests the machine when it is confidently wrong, and no CV, repo, or interview shows that.

I am inside this one from both sides. I went through the transition as a builder, measured myself doing it, and I now hire for roles whose day-to-day is directing loops. What I actually need to know about a candidate is their contest rate. The honest answer is that I cannot see it — mine included, until I built the instrument.

And the job converges on exactly the capability that is eroding. The best current explanation for why software engineers have not been displaced is that requirements, verification, and accountability resist automation: someone must own the outcome, organisationally (Narayanan & Kapoor, 2026). The empirical trace is striking — in the first year of New York's WARN Act disclosure rule, more than 160 companies filed layoff notices and not one ticked the AI-displacement box. Shipper (2026) makes the same point from the demand side: more automation raises the need for human judgment, not less, because the cognitive overhead of directing machines scales with what they can do. Put those together and the scissor closes. Employment is consolidating around sign-off. Sign-off runs on judgment. Judgment is the capability this document shows quietly draining, unmeasured, while every dashboard reports the throughput going up.

Erosion inside employment is a lagged cost. Ford leaned hard on automated quality systems, took billions in quality failures, and ended up rehiring 350+ veteran engineers to hunt the failure points the automation missed (reported by Bloomberg, 2026; the rehiring coincided with Ford's first J.D. Power initial-quality lead in 16 years). Capability written off in year one gets bought back at year-three prices. Delegation's productivity gains are banked only if the judgment directing the delegation is maintained; otherwise they are borrowed against a balance nobody is watching.

And the baseline is dissolving. METR's 2026 follow-up could not cleanly re-run its own productivity experiment because 30–50% of developers refused to do tasks without AI. The control group is disappearing. Whatever unassisted baseline erosion might have been measured against is dissolving while the field argues about whether erosion is real.

The population-scale version of this is a gap in the measurement layer itself. The best public data on AI and work — Anthropic's Economic Index, now longitudinal — is a usage panel: what people do with the model, by occupation and task, automation versus augmentation. It is the right instrument for its question. There is no counterpart for the other half: whether the humans directing all that usage are getting stronger or quietly losing the capacity the whole arrangement depends on. Usage data without capability data is how an economy comes to look more productive right up until it has to do something unassisted.

The memo to the platform layer

This document has been honest that a personal tool cannot preserve a capacity across a population — that has always taken a curriculum, a professional standard, or a platform. So it should end the way it means: as a memo to whoever holds platform power, published in public because the argument only wins if someone with scale runs it.

A provider that ships the human-side counterpart to its model-side stack gets three things no one else can build:

1. The instrument, native. Session-end reflection built into the tool itself: a digest of what the human steered, checked, and let slide, generated where the transcript already lives. The reference implementation exists in this repo — hook, taxonomy, renderer, MIT-licensed. At the platform layer this is a feature, not a product.
2. The disclosure moment. At sign-off of an autonomous run, surface the handful of decisions the human would most plausibly contest, and ask for one genuine contest before acceptance. The checklist evidence says a forcing function works when it changes the cognitive act; the contest rate it produces is the leading indicator this document proposes — appetite, measured before capability shows the damage.
3. The panel. Opt-in and donated: the first longitudinal, individual-level dataset on how human judgment changes with sustained AI use — the missing counterpart to population usage indices. Fluency curricula teach the floor. The panel is how anyone finds out whether the floor holds.

The constraint carries over from everything above and is not negotiable: the record belongs to the user. The moment the same data feeds a manager's dashboard, the instrument measures the performance instead of the person, and the dataset corrupts itself. Whoever builds this at scale has to want the measurement more than the surveillance. That is a cultural test before it is a technical one, which is why the memo is addressed to the platform layer and not to the enterprise-tooling market.

Why a memo and not a pitch: there are no patents here, deliberately. I have carried this as far as one person, one instrument, and four months of data go. The next altitude needs a curriculum, a standard, or a platform. The head start is sitting in this repository.

Postscript: tier one arrived the same week this memo went live. Next section.

The platform answered (July 2026)

On 9 July 2026 Anthropic shipped Reflect, in beta: a dashboard on Claude web and desktop that summarises how you use Claude — topics, patterns, when and what — organised by the 4D fluency framework, descriptive with no score, individual-only, private by design. It periodically asks the user questions like "What's one thing you want to keep doing yourself, even if Claude could do it faster?", and it ships wellbeing levers: quiet hours, break nudges, built with the MIT Media Lab's AHA program, the Digital Wellness Lab at Boston Children's Hospital, and the Family Online Safety Institute.

This document has argued since June that the provider should ship the human-side counterpart to its model-side stack; the memo above made the ask explicit, and Reflect shipped the same week it went live. That is convergence, not causation — and the convergence is the point. Same framework, same no-score constraint, same privacy precondition, same reflective move. The platform has independently concluded that the human side needs an instrument. Tier one exists.

What Reflect measures and what this document is about are still different things, three ways:

• The object. Reflect measures usage: what you did, when, on which topics. The open question is judgment: whether you were still thinking while you did it. The contest rate at sign-off remains measured by no one.
• The surface. Reflect watches the chat surface. The stakes in this document live on the working surface — the coding sessions, the agent runs, the one-way doors — where the artefact ships and the capability erodes.
• The frame. Reflect is framed as wellbeing; its partners are digital-wellness and child-safety labs, its levers are quiet hours and break reminders. The labor question above is a different genre: professional capability, hiring, the record of title. Wellbeing asks whether you are using it too much. This asks whether the work is still yours.

I expect the gap to close. Extending reflection from the chat surface to the working surface, and from usage signals to judgment signals, is the obvious next tier, and nothing here is a moat against a platform that decides to build it. That is the intended failure mode: this is research, not a product. The instrument in this repository is a reference implementation and a replication path; the document is the map. If the platform ships the territory, the map's job is done — and the record will show the map came first: the ask is dated June, the vocabulary is timestamped, and the study ran before the feature existed. Until then, the judgment half stays open, and this document keeps measuring it.

Open questions

The answerable ones have moved into the argument above (whether you can self-assess: no; whether awareness alone fixes it: no). These remain genuinely open.

1. Does the gap compound, or self-correct? Does the drift worsen over months, or do people correct once they can see it? Answering needs far more longitudinal history than one person over four months.
2. Does seeing your own mix change behaviour, or just hand you a number to game? The intervention literature says forcing functions can change behaviour, but only when they alter the real cognitive process, not when they're performed.
3. What's the right altitude — individual, team curriculum, or platform? And how do you surface it without becoming the tool people switch off on day one?
4. What does hiring for judgment look like once output stops evidencing it? Fluency can be interviewed for; the contest rate can't, yet. Whoever solves assessment for the post-output era sets the labour market's terms.

Limitations and honest status

This is one person's data: a small corpus (tens of classified sessions, 192 transcripts, four months, a single tool surface, maybe a fifth of even my own AI use). The headline numbers are estimates that move a point or two. Silent checking is invisible to the method, as is the structured verification real work runs on (review, tests, red-teaming, staged deployment), so the in-session signal may flatter or damn me unfairly; it is one channel, not the whole of anyone's diligence. Several supporting studies are preprints (Kosmyna; Xu) or vendor/correlational work (GitClear) and are flagged as such; some are real-time bias rather than proven long-term deskilling (Dratsch); and genuine counter-evidence exists, above. The leading indicator has a real failure mode: if the modal answer at a one-way door is "ship it," the field is noise and the signal flatlines, in which case the artefact is theatre and the right move is to stop. I am holding that kill criterion.

What this is, then, is not a finished result. It is the form of the argument clear enough to attack and improve, with a forty-year evidence base behind the mechanism and real, if undersized, data behind the personal claim. It is a living document; it will be revised as the corpus grows and the open questions close. The repo is public and MIT-licensed; there are no patents, because a measurement instrument for your own judgment only works if it is inspectable. If this is your question too, I'd like to swap notes.