A local, private tool that mirrors your judgment vs autopilot when coding with AI agents, then helps you exercise what you still hold. Built for developers wary of AI over-reliance, cognitive offloading, and the slow erosion of critical thinking.
Offload the work, never the judgment.
atrophy reads your own Claude Code transcripts (aggregates only) and shows, in one glanceable report, whether you are exercising judgment or running on autopilot with AI coding agents. It does not think for you: you decide.
Mirror, not judge. There is no score to optimize, no streak, no coach. The moment a measure becomes a target it stops measuring anything (Goodhart), so atrophy refuses to be a target. It shows you your own behavior and stays out of the way.
One glanceable report, aggregates only. Project names below are placeholders (core-api, billing, dotfiles), the numbers are illustrative:
Renders in your terminal from your own data: no dashboard, no upload.
Show the same report as text
Atrophy · 2026-07-03
────────────────────────────────────────────────
judgment today 77% ███████████████░░░░░
trend 7d 76% 30d 74% ▅▆▆▇▆▆▆ → holding the line
active time 4h03 across 3 project(s)
mental window 09:02 → 19:40 (10h38)
monitoring 12% ██░░░░░░░░░░░░░░░░░░ 22min / 3h05 runtime
value 93% ███████████████████░ business · 9 commits
review 4 of 6 large outputs got review time · 2 under skim time (in-terminal)
steering 7 acts 4 interrupts · 2 rejections · 1 plan refused
active judgment 23% █████░░░░░░░░░░░░░░░ 11/47 prompts challenge
exposure 86% auto-approved · 5 queued while running · 7.4x delegated volume
projects judgment active focus commits
────────────────────────────────────────────────
billing biz 69% ████████████░░░░░ 1h05 46% 3
core-api biz 78% █████████████░░░░ 2h40 64% 6
dotfiles perso 88% ███████████████░░ 18min 100% 0
capacity check available: atrophy.py recall (5 min, optional)
How it works, in three lines. atrophy reads ~/.claude/projects/*/*.jsonl locally, computes aggregates only (counts, durations, ratios: never a prompt, a diff, or a file name, save file basenames behind the opt-in recall --show-paths flag, display only), and renders in your terminal. It makes zero network calls, and CI enforces that with a test that fails the build if any network primitive appears in the code (tests/test_no_network.py).
What it is, and what it is not.
| ✅ atrophy is | ❌ atrophy is not |
|---|---|
| a private mirror of your judgment | a productivity score to maximize |
| local, aggregates only | a tracker that uploads your prompts or code |
| a silent nightly signal | a time tracker or always-on dashboard (RescueTime, WakaTime, ActivityWatch) |
| an indicator you interpret | a verdict, or a moralizing nag |
| a way to exercise what you hold | a coach gamifying your behavior |
| meant to be outgrown | a crutch to optimize and keep forever |
Same data, different question. Other tools read the same ~/.claude/projects transcripts to track your token spend (ccusage, Claude-Code-Usage-Monitor) or your session stats (agentsview). atrophy reads them to track your judgment instead.
Jump to: Try it · Install · What it measures · Training, not just watching · Design principles · Why judgment atrophies · Privacy
- What you'll see
- Try it in 30 seconds
- Requirements
- Install
- Daily use
- What it measures, exactly
- Training, not just watching
- Design principles
- Why judgment atrophies
- Config
- Optional LLM
- Privacy
- Uninstall
- Limitations
- Contributing
- Further reading
The analyzer is a single stdlib-only file: if you already use Claude Code, you can see your own mirror right now, with nothing installed and nothing sent anywhere:
uv run https://raw.githubusercontent.com/michel-is-coding/atrophy/main/atrophy.py --no-log(or git clone and python3 atrophy.py --no-log, same thing.) The report runs on the transcripts already sitting on your disk.
- Python 3.9+ (system Python is fine). The report, week view and practice commands run on macOS, Linux and Windows.
- The background agents (presence sampling, nightly report at 23:30, hourly guardrail) are macOS only for now: they use launchd. Linux users get everything on demand; native scheduling is a good first issue.
The installer touches only your own machine: it creates ~/.atrophy/ and registers 3 launchd agents under your user account, nothing more. Read install.sh first if you want to see exactly what it does.
git clone https://github.com/michel-is-coding/atrophy.git ~/code/atrophy
cd ~/code/atrophy && ./install.shNext step: just work as usual. Your first report appears tonight at 23:30, or run it now with python3 ~/code/atrophy/atrophy.py.
- Report on demand:
python3 atrophy.py(orcat ~/.atrophy/last.txtfor last night's). - In the evening, a 1-to-5 rating "judgment exercised today?", a single integer:
bin/atrophy-rate.sh 4(the nightly report also asks). This is the ground truth your metrics are checked against. - Weekly, when you feel like it:
python3 atrophy.py week(the 7-day view) andpython3 atrophy.py recall(5 minutes, see below). - Silent except alert: you are only notified when a threshold is crossed relative to your own baseline (judgment dropping vs your own 30-day distribution, boundary-less day, more than ~10h active).
- Something looks empty?
python3 atrophy.py doctorchecks your setup. - Scripting:
python3 atrophy.py --json(alsoweek --json) emits the aggregates as JSON.
Every number is a proxy, named honestly, so you can judge the judge. Behavioral facts (recorded events) weigh more than lexical guesses (word matching), because you cannot accidentally perform an ESC press.
| Signal | What it counts | Kind | Why it matters |
|---|---|---|---|
| judgment / fordism | share of prompts that are pure acceptance, delegation of choice, or closure ("ok", "go", "you decide") | lexical proxy | low-judgment prompting is the assembly-line mode the fordism essay describes |
| steering | interrupts (ESC), tool rejections, plan approvals/refusals, hand-edits of agent-written files | recorded fact | each one is you actively overriding the machine; the strongest judgment evidence in the data |
| review | large agent outputs that got review time vs accepted faster than a human can skim (threshold scales with output size) | timing proxy | accepting without checking is the empirical core of over-reliance (Buçinça 2021; Mozannar 2024) |
| active judgment | prompts that verify, contest, or ask for proof | lexical proxy | verification is where critical thinking now lives (Lee et al., CHI 2025) |
| exposure | share of prompts under auto-approval modes, prompts queued while the agent ran, delegated volume | descriptive fact | context for everything above: zero rejections under full auto-approval means something different |
| monitoring | active presence while the agent runs (macOS) | presence sampling | attention allocation is the automation-complacency mechanism (Parasuraman 2010) |
| value | commits + business share of active time | output proxy | 18h of agent runtime is not revenue; feeling productive is not producing |
| ground truth | your nightly 1-5 rating correlated with the measured judgment (only shown once 15+ days are rated: less is statistical noise) | self-report | if the felt sense and the measure diverge, the metric is theater and must be fixed. This guard is part of the tool |
None of these is a score to push. Days differ legitimately: a boilerplate day should be delegated heavily. The mirror shows the pattern; you decide what it means.
Observation is layer one. What fades without use does not come back by being watched, so atrophy v0.2 adds a practice layer: opt-in, rare, self-graded, never notified, never scored. It applies the two intervention mechanisms with the strongest meta-analytic support (retrieval practice, g around .5-.6; self-explanation, g around .55) to the moments your own transcripts show you delegated the most and examined the least.
python3 atrophy.py recall(5 minutes, suggested weekly). Picks the week's most-delegated, least-examined moments (heaviest agent output that you never interrupted, rejected, or challenged) and asks you to answer from memory: what did that session change? why that approach? where would it break first? You self-grade each moment held / fuzzy / gone. Only the three counts are stored. The point is not the grade: it is the felt experience of discovering what is no longer in your head, while you can still do something about it.python3 atrophy.py audit(suggested monthly). Proposes one unassisted rep: a small real task in your most-delegated project, done without the agent.audit --done Nrecords the date and how it felt (1-5), nothing else. Unassisted performance is precisely what degrades under assistance (Liu et al. 2026, N=1,222) and precisely what no passive metric can see.
No streaks, no badges, no reminders beyond one dim line in the report, at most weekly, when a check is stale. Gaming these means actually knowing your codebase or actually doing a task by hand, which is the goal itself, so there is nothing to game.
- Mirror, not judge. Goodhart's law: "when a measure becomes a target, it ceases to be a good measure." The tool stays silent and celebrates judgment exercised.
- Facts over words. Recorded behavior (ESC, rejections, plan verdicts, hand-edits) counts more than word-matching, and cannot be performed by changing your vocabulary.
- Your baseline, not a universal one. Alerts compare you to your own 30-day distribution, not to an arbitrary constant.
- The scarce asset is judgment, not time. Delegating execution is healthy; delegating strategic judgment sells off the asset that actually creates value.
- Feeling productive is not producing. Hence the value axis (business %, commits): 18 hours of agent runtime is not revenue.
- Closing beats accumulating (the Zeigarnik effect: an open loop keeps running in your head). One closed session beats a 14-hour open one.
- Show uncertainty or show nothing. No correlation verdict under 15 rated days; no steering line on a day with zero acts (a quiet day is not a failure).
- The goal is to be able to throw the tool away: internalize the reflex, not a crutch.
Something is quietly changing in how we think. As we hand more of our reasoning to AI agents, a trade slips by unnoticed: the work still gets done, the output still ships, but the faculty that used to produce it, judgment, is exercised less and less, and what isn't exercised fades.
The research is starting to measure it. In a randomized trial of 1,222 people, those helped by AI did better while assisted, then did sharply worse the moment the tool was taken away, and gave up faster on their own (Liu et al., 2026). A study of 666 people tied heavy AI use to lower critical-thinking scores, mediated by cognitive offloading (Gerlich, 2025). An EEG study reported weaker brain connectivity during AI-assisted writing, and participants who could not quote their own essays minutes after writing them (Kosmyna et al., 2025). In the first real-world clinical evidence of AI deskilling, experienced endoscopists' unassisted detection rates dropped measurably within months of AI-assisted practice (Budzyń et al., Lancet Gastro Hep 2025). And in the METR randomized trial, experienced developers using AI believed they were 20% faster while actually being 19% slower: the gap between felt and real is itself the phenomenon.
Here is the trap of a great "productivity session" with the machine: the deliverable looks the same, the dopamine of watching little digital workers ship for you is real, and nothing tells you your own capacity just dropped a notch. The cost never shows up in the output. It shows up only in what you can still do without the tool, which is exactly what you stop testing. atrophy tests it, gently, on your own data.
AI is commoditizing production itself, in code first, then writing, analysis, design, decisions. The one thing that stays scarce is judgment. atrophy exists to preserve it, and to make it measurable and usable, before it too is commoditized.
- Your repos are not under
~/code?export ATROPHY_REPO_BASE=~/your-dir(otherwise the value axis shows 0 commits / 0% business). - Business vs personal tagging:
cp atrophy-projects.tsv.example ~/.atrophy/projects.tsvthen edit it. - Data lives in
~/.atrophy/(override with$ATROPHY_HOME): the aggregate log, ratings, recall/audit counts. Plain text files you can read, edit, or delete anytime.
Run python3 atrophy.py --llm to classify your substantive prompts into strategic / technical / creative via a local model (llama.cpp, OFFLINE). With no model installed, the rest still works and this lens disables cleanly. Model: --llm-model <path.gguf>.
Everything is local: aggregates / labels only, never a prompt, code, or client name persisted, nothing leaves the machine (the LLM included). Your data lives in ~/.atrophy/ (outside the repo). One explicit carve-out, documented here and in the code: the practice commands (recall, --llm) read transcript text in memory at question time, like every command reads the transcripts; what they display is project names, dates and sizes (file names only behind the recall --show-paths flag); what they persist is counts. Nothing raw is ever written or transmitted.
cd ~/code/atrophy && ./uninstall.sh- An indicator, not a verdict. This is an honest mirror, never a moral score. The numbers inform your own judgment, they do not replace it.
- Not a target to optimize (anti-Goodhart). The tool is silent on purpose. Gaming a judgment percentage just degrades the measure, and the thing it stands for.
- Review is measured in-terminal only. If you review diffs in your editor or
git diffin another pane and then type "ok", the review line cannot see it and will call the accept fast. Read the review line with that in mind. - Proxies, not ground truth. Lexical signals can be fooled, especially by someone who knows the lexicon; that is why the behavioral facts (steering, exposure) exist and weigh more. "Delegated volume" is context, not a judgment measure: the research says volume mostly reflects the task, not the thinking.
- Local and aggregates only. Nothing leaves the machine. No prompt, code, or client name is ever persisted, which is the direct answer to "isn't this self-surveillance?".
- macOS gets the full experience (presence, nightly report); other platforms get everything on demand. See #6.
- Bilingual detection (FR + EN), calibrated mostly on real French. The English token set is younger and still being calibrated (see
ROADMAP.md). - Claude Code transcripts have ~30-day retention by default: atrophy snapshots your daily aggregates into
~/.atrophy/atrophy.mdso the trend survives the source expiring.
See CONTRIBUTING.md. The "prompt fordism" framing comes from Jad1908's essay, Prompting is the New Fordism (see CREDITS.md); atrophy measures what that essay describes. See ROADMAP.md for where help is most wanted, and docs/design-v2.md for the full evidence base behind every metric.
- AI Assistance Reduces Persistence and Hurts Independent Performance (Liu et al., 2026), the N=1,222 RCT
- Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity (METR, 2025), the perceived-vs-real gap
- Offloading Score: Measuring AI Reliance Through Counterfactual Workflows (2026), why volume metrics are insensitive
- The Impact of Generative AI on Critical Thinking (Lee et al., CHI 2025), verification as the new locus of judgment
- AI Tools in Society: Impacts on Cognitive Offloading and the Future of Critical Thinking (Gerlich, 2025)
- Your Brain on ChatGPT: Accumulation of Cognitive Debt when Using an AI Assistant for Essay Writing (Kosmyna et al., 2025), the EEG study
- Endoscopist deskilling risk after exposure to AI in colonoscopy (Budzyń et al., 2025), deskilling measured in the field
- To Trust or to Think: Cognitive Forcing Functions Can Reduce Overreliance on AI (Buçinça et al., 2021), the intervention evidence