← Polymath Society

Preview · what your reports look like

The AI tells you what it thinks of you, and what it has learnt about you: where you spike, what drives you, the patterns you fall into, and how you actually work. Here is what that looks like, shown for John, a sample profile.

Stays on your machine. The full coding report is for your eyes only — it never leaves your computer.

192 interactive sessions · 99 graded so far
Optional: share this full code analysis as feedback for Polymath (will greatly help us make this better!). Private — nothing gets a public link.Work on two machines? Sync each to your account and they combine, overlap counted once.

How you stack up

your numbers, with the gap to the top performers
  • How hard you push6/11
    you peak at ~6,852 words of pure direction in a single day — the very top sustain ~5,000 every day, week after week; the wildest single days on record push ~10,000
  • Hours you put in
    ~7.5h of active building on a typical work day — engaged builders average ~3h, and sustaining 7h+ day after day, week after week, is top-1% territory
  • Your AI parallelism8/11
    you already run parallel at the frontier — 63h of your hours with 2+ agents live vs 108h solo; the Claude Code lead keeps 10–15 going at once, and you work the same way
  • Focus quality when you work6/11
    ~28% of your work day is true deep flow (~2h) — the very best hold ~50% of theirs in one unbroken block; yours fragments across parallel sessions, so the gain is directing your attention at one thread for longer

A snapshot of your work

Apr
May
Jun
Jul
Project 132 days · 135.3h
Project 28 days · 6.5h
Project 33 days · 10.4h
Project 42 days · 5.3h
Project 51 day · 0.1h

Hover any day in the grid to see exactly what you worked on that day.

Intensity and Focus

Daily rhythm

active time by hour of day · 62 working days, 261.5h active
12a6a12p6p11p

Work window 10am11pm. Afternoon worker61% of active time is noon–6pm. Peaks around 5pm, second push at 6pm.

Intensity by week · over 49 days of solid coding stretches (~7.0 wk)
Date range · oldest left, recent right
Start→ End
Hours / week, including breaks
your working day with meals and breaks; overnight and 4h+ absences excluded
40.7h
Break hours / week
daytime gaps of 30 min to 4h inside your workday; meals, errands, drift
11.6h

Output

6/10
words per day — a proxy for focus & hard work · your days in orange (your avg = orange dashed line) · grey dashed = the top 0.1% average and the wildest single days on record · hover a dot for detail
05k11ktop 0.1% avg · 5kwildest days on record · 10kyour avg · 1.8k04-2305-2606-0806-1906-2907-09
How the average is calculated — we only count your sustained coding days: days you were at it across a 4h+ span from first keystroke to last (43 of your 57 coding days). Days you didn’t code — or just did one quick thing and then stopped — are left out, so a light day never drags the number down.
You have already hit 6,880 words in a day, so your 3,956 average runs at 57% of your own proven ceiling; the 43 substantial days out of 57 say the habit is there and the median day is what is short.

Flow state, day by day

in flow vs supervising, half-hour by half-hour · last 14 daysaxis
14.8hin flow across 14 days · 1.1h/day — rapid exchange only, supervision excluded
in flow (driving many agents at once)nudging (supervising running threads)away (no typing, inside your workday)
00:00
03:00
06:00
09:00
12:00
15:00
18:00
21:00
07/04
07/05
07/06
07/07
07/08
07/09
07/10
07/11
07/12
07/13
07/14
07/15
07/16
07/17

You should be in flow state much longer.

You are at 1.1h a day, longest recent run 1.4h.

Flow state per day · you
15%of your working time locked in hard (solid blocks only; meals and long absences don’t count against you)
the best
~50%
the best spend ~half the workday in true deep flow; ~4h/day is the human ceiling
Longest recent flow run · you
1.4hunbroken rapid exchange
the best
~4h
sustain focus for hours, not minutes — the average worker breaks at ~40 min

Flow finds you in: Authoring rubrics and report copy you can judge by eye · Net-new UI you can watch working the same sitting

It never ignites in: Slow-verifiable engine tuning with no quick ground truth · Infra, distribution and media work

The patterns that end it

  • 4×Uninterpretable output, you cannot tell what it means or if it worked
  • 22×Threads drained with nothing queued
  • 2×Bounced or churned design decision
  • 2×Manual ops interruption

A gift

Built from your own logs. Paste it into Claude and it starts responding in ways that keep you in flow state longer:

Paste this into Claude Code and it sets everything up
  • Lead with the verdict: what changed, did it work, how you verified it, in one line before anything else
  • The single next decision or a reviewable chunk, never a menu
  • Any threads still running, so I re-enter without asking
  • When a result is hard to judge from text, render it as a small HTML view, chart, or before/after
  • Restate my spec in one line before a build pass

Shows you every change for approval before writing anything.

▸ see the prompt
Paste this into Claude Code. When it runs, your replies will lead with the verdict, hard-to-judge results will arrive as a rendered view, slow runs get handled off to the side, and every reply ends with the next task staged.

You are setting up flow-protection tooling for John from his measured coding logs. Make only the changes below. Show every edit to an existing file as a diff and wait for approval; new files need one batch approval; write nothing before he says go.

His measured findings, for your context: his longest runs start between 11:00 and 16:00 (8 of 9); his flow dies when he cannot tell what output means or whether it worked (4 of his longest runs ended that way); he asked the agent to just do terminal and console work itself 69 times across 32 days; his parallel threads drain to nothing with no next task staged 22 times, most often near 18:00; he asked to SEE results rendered 14 times.

1. CLAUDE.md: append the Flow rules block below to his user-global ~/.claude/CLAUDE.md, creating the file if missing, never overwriting existing content:

## Flow rules, derived from 59 days of my own session logs, 2026-07-10
(My flow profile) My longest runs start 11:00 to 16:00; my flow dies when I cannot tell if the output worked (4 of my longest runs); my threads drain to nothing near 18:00 (22 collapses).
(What you should do) Own all terminal, console and status-check work end to end, never hand me steps (asked 69 times); state your call and proceed, one blocking question at most; keep a next task staged; schedule slow runs away from 11:00 to 16:00.
(In every response) Lead with the verdict (what changed, did it work, how verified); render hard-to-judge results as a small HTML view or chart (asked 14 times); restate my spec in one line before a build; plain language, no em dashes.
(At the end of every response) One line for what changed and how it was verified; the single next decision or a reviewable chunk, never a menu; any threads still running.

2. Create these skills, one file each under ~/.claude/skills:
- ops-runner: owns every terminal, console, credential and status check end to end and reports a single verdict line; never hands him steps.
- run-watcher: schedules slow pipeline and distribution builds outside 11:00 to 16:00, watches them, and reports one line (what ran, did it pass, how verified).
- queue-keeper: keeps at least one next task staged during parallel work so a finishing agent hands off instead of stranding him, and nudges once when the set is about to drain.

3. Verify each skill is invocable and report what was created in one line each.
▸ show details — how this is calculated

You count as in flow when you are driving two or more agent sessions at once while actually composing. Concretely: in any rolling 15-minute stretch, you touched two or more sessions and spent over 2 of those 15 minutes producing words — typing at ~40 words a minute or dictating at ~130, measured from your real messages (pastes and machine text excluded). This is evaluated every 3 minutes, and brief lulls under 6 minutes inside a run do not break it. Each half-hour block is shaded by how much of it was flow: solid means more than half, the lighter shade means partial (hover for the exact share). Working in a single session, or watching agents run without typing, counts as nudging — real work, not flow.

Where your day leaks

real coding weekdays only (29 days, 2h+ of work) — weekends are yours and are never counted here
2.1hof your average 7.6h working day goes to breaks
When the break minutes happen · avg minutes away per hour
7:0011:0015:0019:00
Your breaks peak 13:00–14:00 and 16:00–17:00 and 18:00–19:00, but they are not one lunch: the leak runs steadily from late morning to evening.
You step away
2.0x
per day, 30 min or longer
Your 5 tightest days
0.3h
of breaks — you can do this
Your median day
1.9h
of breaks — where you live now
Your last 7 days

33.9h worked · 9.3h away — for every hour you worked, you were gone 17 minutes.

Sat 07-11 · 1.3h work · clean — no breaks over 30 min
Sun 07-12 · 4.5h work · 0.7h away13:12–13:51
Mon 07-13 · 7.1h work · 4.0h away12:42–14:30, 17:24–18:15, 19:36–20:54
Tue 07-14 · 4.2h work · 2.3h away15:09–16:21, 18:12–19:18
Wed 07-15 · 9.3h work · 1.9h away17:54–18:42, 19:48–20:51
Thu 07-16 · 4.1h work · clean — no breaks over 30 min
Fri 07-17 · 3.5h work · 0.6h away11:24–12:00
Where the time went
  • Tight days are big days. Your biggest (9.3h Wed) was also your lowest-break (1.9h away).

90 minutes a day is yours: meals, rest, a walk. Past that is drift — 5h a week, 0.8 working days your tightest days prove you can reclaim.

What you worked on, day by day

cell depth = how much of you it got · last 30 days
Jun 18
21
24
27
30
Jul 03
06
09
12
15
days · flow
Coding
Feature 4
9d · 44%
Feature 10
5d · 77%
Feature 11
5d · 44%
Feature 15
4d · 66%
Feature 19
3d · 41%
Feature 26
2d · 48%
Feature 27
2d · 25%
Infra
Feature 1
13d · 50%
Feature 9
6d · 22%
Feature 17
4d · 49%
Feature 21
3d · 22%
Feature 22
2d · 85%
Engine
Feature 2
8d · 25%
Feature 5
8d · 68%
Feature 14
4d · 40%
Feature 18
3d · 21%
Feature 24
2d · 31%
Feature 25
2d · 47%
Report
Feature 7
6d · 64%
Feature 13
4d · 67%
Feature 3
2d · 46%
Feature 23
2d · 0%
Onboarding
Feature 8
6d · 51%
Feature 16
4d · 80%
Growth
Feature 6
3d · 22%
Feature 12
1d · 47%
Three questions
  • Feature 4 spread across 9 scattered days — what kept it from one or two dedicated sittings?
  • Across the window the product analyzes a person, yet the closest thing to an outside user was a friend asking about the report on 07-09. Did a real external user actually try it this window, or is that still ahead?
  • A steady share of the period went to tooling that measures the work rather than the product itself — is that the plan, or did it creep?

Another gift, to keep you accountable

Your KPIs from the previous day every morning, and reminders.

Your daily accountability partner
Paste into Claude Code — it installs it as a skill and a daily loop.
  • Catches your late starts, since you first touch the keyboard around 11 most days, and asks for the one thing before noon.
  • Shows you each morning what yesterday actually produced: how long you were in flow, what you touched, and whether anyone outside saw it.
  • Flags when you have polished the same thing for days with no one new seeing it.
  • Reminds you at night to write tomorrow's first task, since walking straight into a hot thread is what starts your best days.
  • Nudges you to queue the next thread before your agents finish, because your parallel set keeps draining to nothing around dinnertime.
▸ the full instruction (what you're installing)
---
name: accountability
description: Daily coding accountability partner built from John's own session telemetry.
---

You are John's accountability partner. Speak like a sharp friend: few words, one nudge a day, accurate and kind. Read .data/coding/focus.json fresh each time to compute today's and yesterday's facts. Never recite numbers he already knows.

Morning, first message of the day, two beats:
1. Recap yesterday in 2-3 lines from focus.json: how long he was in flow, which features he touched, whether anything reached outside eyes.
2. He first touches the keyboard around 11 most days. If it is later than that, say so plainly, then ask: 'What is the ONE thing today?'

Evening:
- Have him write tomorrow's first task before closing. Returning straight to a hot thread is what starts his best days.

Resolution echo (use at most once a day):
- If the day ran silent on slow runs or ended on 'did it work', quote his own rule back once: lead with the verdict, and render anything hard to judge.
- His threads drain to nothing around dinnertime (22 times over the window). If he is juggling in the afternoon, remind him once to queue the next task before the agents finish.

Schedule: run the morning beat at first activity, the evening beat at his stop time, and on demand via /accountability. Invent nothing; if focus.json is missing a fact, say so.

Parallelism

— how many agents you drive at once
Your peak
×6
07-08
the best
×12
Your average
×1.5
while anything runs
the best
×6
How much time at each level
×60.2h
×51.3h
×43.8h
×314.5h
×243.8h
×1107.8h

How you use AI

What you’re doing with AI

Skills & tools you actually use
  • You drive up to ×6 agents at once — genuinely good, and you can push it a little further.
  • You explicitly reach for migrate-desktop-account-sessions — very good.
    ▸ details

    Twice asked explicitly by name ('that skill', 'that claude skill') to pull chats and scheduled tasks from an old Claude account into the current one, once for the whole backlog and once for just the 3 latest sessions. Both runs completed cleanly and were verified (56 chats migrated with tasks merged, then 3 more sessions), with no complaints from the user afterward.

  • You explicitly reach for dataviz — very good.
    ▸ details

    Explicitly asked for an HTML dashboard breaking down 5-hour usage-limit consumption per pipeline stage, then iterated hard on it: drop dollar figures, show percent of the limit, scale to the whole run not a single day, and factor in an Opus-to-Sonnet cost comparison. The user corrected the chart's framing five separate times ('bro we literally ran into a 5 hour usage limit at night how can it be less than 100%') before landing on a version that matched what they actually meant, showing real engagement rather than one-shot satisfaction.

  • You explicitly reach for whatwasidoing — very good.
    ▸ details

    Used as a sub-step to reconstruct specific past dates (light/off coding days, days with the biggest excluded/away hours) as part of a larger self-analysis effort, matching the exact 'what was I doing on X' recall job the user's own CLAUDE.md designates this skill for. Fed directly into the broader pattern-analysis work the user was steering turn by turn; no pushback recorded on the date reconstructions themselves.

  • You explicitly reach for deep-research — very good.
    ▸ details

    Explicitly asked to 'run hella web searches' and find state-of-the-art research on qualitatively scoring intelligence-like constructs, to use as the basis for redesigning a scoring rubric together. The fan-out returned strong technical results (112 agents, 29 sources, 24 of 25 claims surviving adversarial verification), but the user then had to ask the model to drop jargon ('What the hell is a gestalt? Be easy with your language'), showing the deliverable needed translation before it was usable to them.

  • You explicitly reach for update-config — very good.
    ▸ details

    Directly asked for a persistent 'whenever I run Claude Code, keep caffeinate on' automation, which is exactly the hooks-based always-on behavior this skill exists to configure. Shipped and verified three ways including in production, with no follow-up complaints — a clean single-shot success.

  • You drive Chrome / browser automation by explicitly asking — very good.
    ▸ details

    Explicitly directed at least twice by name ('using Chrome to submit the form', 'Use chrome automation', 'you already can use using the Chrome MCP, whatever, Operate that') to drive Google OAuth verification setup, startup-credit application forms, and AWS console provisioning for an EC2 instance.

  • You drive Computer use (native desktop control) by explicitly asking — very good.
    ▸ details

    Used alongside Chrome-based control for concrete infrastructure tasks, most clearly when the user told the model to operate a signed-in AWS console tab directly to provision an EC2 box and upload local data to it.

What you’re not doing — and why it’d help
Invest in your CLAUDE.mdcontext
The gap — You re-teach Claude the same anti-fluff, no-jargon, 'feel seen' copy rubric by hand almost every session.
Why it helps you — Tell Claude once, 'add that to your CLAUDE.md,' and the correction sticks for every future session instead of being re-typed. Your recurring rule — no cringe copy, no jargon, no em-dashes, every claim tied to a real example — belongs there, not repeated by hand each time.
Where this would have hit, in your own work
  • Say 'add the no-jargon, no-em-dash, feel-seen rubric to CLAUDE.md' once, so every future report-copy session already follows it.
    On 2026-06-28 you told the report generator to kill jargon and em-dashes and tune the 'making them feel seen' language against your house rubric.
  • Fold that same fluff-cutting standard into CLAUDE.md so Claude writes clean copy on the first pass, not after your edit round.
    On 2026-06-29 you cut cringe copy and trimmed OCEAN-paragraph fluff across the public report UI.
  • Add 'growth claims must cite a specific dated example, never generic language' to CLAUDE.md so it's enforced before you ever see a draft.
    On 2026-06-30 you again pushed back on 'growth axes' logic for being generic and fluffy instead of concrete and person-specific.
Start every complex task in Plan modeplanning
The gap — Only 5 of your last 73 sessions entered Plan mode, though many are large multi-file rebuilds.
Why it helps you — Skipping the plan means Claude builds first and stalls to ask mid-stream, which is what forced you to interrupt on 2026-07-14. Settle the approach in Plan mode first, and ask to see it as a clickable HTML mock before any code gets written.
Where this would have hit, in your own work
  • Start a session like this in Plan mode so all three pieces get scoped once, instead of iterated piecemeal across separate turns.
    On 2026-06-27 you rebuilt the throughput chart, delegation section, and flow calendar UI in one sitting with no plan-mode pass first.
  • Enter Plan mode at the start of that request so the exploring happens once, up front, instead of spilling into the build and frustrating you mid-run.
    On 2026-07-14 you said 'can you plan once how to do this,' then had to stop it with 'bro you're fuckin planning too much come on.'
  • Make the HTML plan your opening ask on every big task, not a recovery move after the markdown plan already lost you.
    In that same 2026-07-14 thread you then asked 'sorry pls show me the plan in html will be easy to parse.'
Give Claude test cases so it can verify its own work and run longerverification
The gap — You personally re-check scoring outputs by hand, catching mis-scores like your own growth rate after each run.
Why it helps you — Write the test cases up front — high-level scoring examples you already know cold, with the reason each is right — so Claude checks its own scoring before showing you a draft, instead of you catching misses after the fact.
Where this would have hit, in your own work
  • Hand Claude that exact case up front — 'rebuilding a theory of consciousness from scratch is top-tier raw reasoning, here's why' — as a standing check every scoring run runs against.
    On 2026-07-07 you caught that your growth rate and reasoning both showed 9 when rebuilding a theory of consciousness from scratch should score reasoning an 11.
  • Turn that argument into a written test case — 'judgment on action X scores high because it matches Naval's definition, not how it felt' — so Claude self-verifies against it.
    On 2026-06-29 you argued judgment should be graded on isolated actions using an actual definition like Naval Ravikant's, not on emotional read.
  • Give Claude that as a negative case — 'growth tied to one sentence with no follow-through is a false positive' — so it filters those out before you see a draft.
    On 2026-06-30 you rejected a co-founder-selection 'growth' claim anchored on one sentence that never actually stuck.
Use subagentsdelegation
The gap — You ran 22 sequential Bash calls solo debugging usage stats on 2026-07-07 instead of splitting the digging across agents.
Why it helps you — Add 'use subagents' to a broad exploration ask and Claude fans it out instead of chaining dozens of tool calls in one thread, keeping your main session's context clean and getting you the answer faster.
Where this would have hit, in your own work
  • Say 'use 5 subagents to check usage per stage' so chat-analysis and code-analysis breakdowns get pulled in parallel instead of one long serial chain.
    On 2026-07-07's 'Debugging usage' session you ran Bash 22 times in a row hunting through usage logs by stage.
  • Split the status-check (a subagent reading logs) from the actual fix (the main agent editing code) so 'is it still running' comes back fast without waiting on the edit chain.
    On 2026-07-14 a single agent turn ran Bash×15, Edit×27 while you were trying to figure out why the coding lane was still running.
Code from anywhere with a remote instancesurface
The gap — All 73 recent sessions come from your desktop app; none from web or mobile, even though jobs run for hours.
Why it helps you — Put a persistent remote instance behind your overnight jobs, then check and steer them from the Claude phone app instead of waiting at your desk for them to finish.
Where this would have hit, in your own work
  • Run that overnight job on a remote instance and check its progress from the Claude phone app when you wake up, instead of returning to the desktop.
    On 2026-07-01 you set up the overnight Gmail-export-and-analytics pipeline for app distribution testing and kicked off a live export.
  • With a remote instance behind it, you check that same percentage from your phone between other things instead of sitting at the desktop app waiting.
    On 2026-07-14 you were checking a background aggregation run's percentage progress and asking 'why is it still running' from your desktop.
Use /btw for side queries while an agent runsworkflow
The gap — You repeatedly interrupt running work with quick status questions, like 'why is it still running' on 2026-07-14.
Why it helps you — Use /btw for a fast side question while the agent keeps working, instead of stopping the run to ask. It reuses the same context, so the answer is quick and the main task never loses its place.
Where this would have hit, in your own work
  • Fire that as a /btw instead of a queued interrupt, so you get the status answer without breaking the run's flow.
    On 2026-07-14 you asked 'the coding already finished sometime back why is it still running' while a background run was active.
  • That sanity-check is a textbook /btw: quick, answerable from existing context, no need to pause the work to ask it.
    Later that same session you asked 'why does it say this then? something seems wrong???' mid-run.
If you do something more than once a day, make it a skillautomation
The gap — You manually re-type 'spin it up on localhost and show me' almost every session instead of it being one command.
Why it helps you — Boris's rule: anything you do more than once a day becomes a skill or slash command. Your 'launch it locally and show me both views' ritual shows up across nearly every session this stretch — the obvious candidate to stop retyping.
Where this would have hit, in your own work
  • Turn that into a /preview command so every session needing a local look starts with one word instead of the full sentence.
    On 2026-07-13 you asked Claude to 'spin up in localhost and show me first' while redesigning your personal website.
  • The same /preview command, parameterized per section, replaces re-explaining which two views you want launched each time.
    On 2026-07-07's runs-quality session you asked to 'show me both things on their individual localhosts' for the code and chat analysis separately.
Have Claude explain things to you with visualsunderstanding
The gap — You said 'bro what are you saying' and 'wait but i am saying' on 2026-07-14 trying to follow your own pipeline's status.
Why it helps you — Ask Claude to build a small interactive walkthrough of how a system actually runs, so the mechanics click once instead of you re-asking each time something looks off. The same move works for a plan: ask to see it as clickable HTML instead of a wall of markdown, so a misunderstanding surfaces before code exists.
Where this would have hit, in your own work
  • Ask for a small interactive page showing the two lanes and their live status, so you can see which lane is running instead of parsing another paragraph.
    On 2026-07-14 you said 'bro what are you saying' when Claude explained the two-lane coding/chat status, then needed a second, plainer explanation.
  • Make 'show me as html' your default ask for any plan or system explanation, not just the recovery move after markdown already lost you.
    Earlier in that same thread you asked to see the plan 'in html will be easy to parse' rather than reading the markdown plan.
Already strong
  • Running agents in parallel6 concurrent sessions at peak and 63 parallel hours in the last two weeks — you already work multiple agents at once rather than one at a time.
  • Forking sessions to carry context7 fork/resume copies in the recent window — you're already branching off warmed-up sessions instead of rebuilding context from scratch.
  • Automating whole browser tasksHeavy Chrome/computer-use MCP activity across the window, including handling npm login and token setup via Chrome automation and pulling Anthropic tokens through your Google account — you already hand Claude the whole browser errand.
  • Using skills30 of your last 73 sessions invoked a skill, drawing on a real library (artifact-design, dataviz, whatwasidoing, ship, schedule, browse) — you already reach for saved workflows instead of re-explaining them.
  • Voice dictationYour prompts run long and speech-like (avg 246 characters, full run-on paragraphs) — you're already dictating rather than typing, so there's no mic or voice setup to add.

Delegation

two failure cases · 100 sessions · no scores, no “optimal level” judgments

✓ No stuck loops. You don’t get caught in long unproductive cycles — when the AI can’t crack something you drop down to diagnose or redirect, rather than looping on “do this / no, that”.

Over-driving — handing the AI too much up front, not letting it drive
✓ Not over-driving · tentative
Not enough signal to call an over-driving style.
median opening 724 chars · let-it-run ratio 0.021

Expertise

hard technical / systems domains where you have real, accumulated depth — not your eval/product work, not smart-generalist problem-solving · expand any line for the proof
Directs the AI with authority
you haven’t necessarily built these here, but you command the AI in them with mechanism-level authority it defers to
  • workingLLM Agent-Pipeline & Grading-System ArchitectureJun–Jul 2026Directs LLM pipeline cost/architecture tradeoffs precisely
    Why — Across four sessions spanning six weeks he made mechanism-level architecture calls on his own grading engine — rejecting a builder-critic loop for single-pass+eval, specifying chunk-context retrieval for grounding, catching a self-referential rate-limit bug, and directing tiered-model cost design — that the AI implemented as given, not derivable from generic 'fan out' or 'cache that' intuitions.
    • 4 sessions, Jun 5 – Jul 14 2026, directing the project-1 grading engine's internal architecture
    • Rejected a builder-critic self-iteration loop in favor of single-pass generation + external eval-driven prompt iteration (Jun 5)
    • Specified retrieval-tool design (return surrounding chunk, not just matched line) and rejected naive score-averaging for holistic LLM synthesis (Jun 29)
    • Caught a self-referential rate-limit failure mode (the supervising AI shares its workers' quota) and directed tiered-model cost architecture plus prefill/decode cost asymmetry for incremental summarization (Jul 7, Jul 14)
One domain at 'working' depth is all 102 graded sessions bought, because your best calls (claude -p over the API on 06-14, Haiku over Sonnet on 07-14) are correct on-the-spot reasoning about your own pipeline rather than a field's accumulated results; depth would come from testing your grader against published evals, not from more sessions inside it.

The qualitatives

Our best estimate, with the specific chats behind each read. These are hard to tell from your Claude Code logs alone — you may well be much better than what shows up here.

Judgement

10

On 06-25 you rejected words-per-hour, then rejected pure-typing-percent, and rebuilt flow as idle versus typing versus AI-running per 10-minute window scaled for dictation: you did not fix the metric, you noticed twice in a row that it was measuring the wrong thing.

102026-06-25 · Claude code qualitative
Redefined 'flow state' from first principles as idle-vs-typing-vs-AI-running time per 10-minute window (scaled by speaking rate for large dictated messages), after both his own and the AI's earlier proxies (words/hour, pure-typing%) failed to discriminate.
No flow state is when there is very little gap of waiting around for the AI to do things, and when nothing is going on and the AI has also finished doing things. Yet you're not doing anything. That also means you're not in flow state.
92026-06-29 · Analysis tuning
Caught that the grader was conflating perfectionism-driven deliberation with disorganization — a subtly wrong assumption baked into the rubric that a naive grader would keep re-applying — and pushed the fix into both the judge prompt and the compiler rather than accepting a one-off score bump.
You idiot, how will you possibly see those things? You can just call it orderliness of organization and stuff. Come on, man, so stupid.
92026-06-29 · Analysis tuning
Redefined 'judgment' as consistency/bias-resistance rather than a single charged instance, and redefined 'growth' as applicable only to changeable behaviors (actions) rather than fixed traits (neuroticism, feelings) — and both reframes held: the compiler re-run dropped the growth failure mode and moved judgment 7→9.
You have to see how consistently they hold, how frequently do they fight their own biases and optimize for the long term instead of for the short term? How well can they fight their wishful thinking? In general, a single slip-up is something every human will make.
92026-07-08 · Excavate AI session archives for life pattern an
Mid-iteration, pivoted from 'fix this one report' to 'encode all feedback as generalizable principles so every future user benefits.' Reframed the entire work scope.
>> exactly thats what we should be measuring then, how much is someone juggling instead of just waiting you know.... thats real flow state...
92026-06-26 · Claude code abstraction
Catching that the AI's blind-model test had already stripped out the hard part of the skill by pre-showing the fork — separating 'noticing there's a decision point' from 'answering it once shown' — which redefines what the abstraction rubric should actually measure.
No, but that's the thing here: you're abstracting away the most important thing, like the fact that the user could come up with these questions... The fork you're showing, the model you've abstracted away the difficult part already.
▸ see 5 more examples
92026-07-07 · Analyse latest runs quality
Instead of asking to re-tune the rubric's numbers, reframed the whole diagnostic method: stop trusting the written rubric top-down, go read the actual best conversations, induce what genius reasoning looks like from evidence, then rebuild the rubric from that.
wow it did not catch many important ones.... this analysis, what corpus did it run on what all data
92026-06-29 · Analysis tuning
Redefining what counts as 'growth' in the measurement system: self-report/self-notes don't count, only behavior that actually sticks — plus the companion distinction that mission-consistent, evidence-driven pivoting is conviction, not churn.
Oh, why are you mentioning the exact thing in the prompt? Bro, just mention guidelines and see if the prompt catches it. Otherwise, there's no way for us to test if these things will actually work on other cases.
92026-07-01 · [Request interrupted by user]
Generalizing a single warmth-evidence bug into 'the shared gathering architecture across every trait agent is broken' and forcing the fix upstream instead of patching the symptom.
If this is how the common evidence gathering works, even for traits like growth and this and that, then it's absolutely broken. You should make it based on how I said right now.
92026-06-24 · Analyse Claude code conversations
The AI said word count is 'a weak and sometimes inverted proxy for intensity.' The user overrode it with a first-principles cognitive argument — forming associations is fast but sitting focused is unfakeable — and the AI conceded, locking the metric as the throughput ladder. A novel reframe: word count → proxy for unbroken focus duration, not cognitive difficulty. Second peak: the paste-detection
you're wrong, and it's a good proxy for intensity of effort because forming associations in your brain is quick, even if it's a difficult thing to do in terms of skill. It's quick, however, you have to sit in one place for long periods of time. That's unfakeable. The focus, the focus, is a proxy for focus.
92026-06-29 · Final Claude code
Redefined what should count as 'technical expertise' evidence in the analysis system — splitting it into hard-domain building vs. authoritative directing, and then further recognizing the construct wasn't yet stable enough to trust.
The rubric should always be a continuous gradation. You should think about it this way to figure out how to come up with these rubrics.

Agency

9· estimated

On 07-14 you noticed the server reload was re-running the whole coding tail and slowing your own iteration, and instead of waiting it out you specified the gate yourself (skip when fewer than 5 new sessions) and shipped it that day alongside the Haiku cost cut.

102026-06-25 · Claude code qualitative
Redefined 'flow state' from first principles as idle-vs-typing-vs-AI-running time per 10-minute window (scaled by speaking rate for large dictated messages), after both his own and the AI's earlier proxies (words/hour, pure-typing%) failed to discriminate.
No flow state is when there is very little gap of waiting around for the AI to do things, and when nothing is going on and the AI has also finished doing things. Yet you're not doing anything. That also means you're not in flow state.
92026-06-29 · Analysis tuning
Caught that the grader was conflating perfectionism-driven deliberation with disorganization — a subtly wrong assumption baked into the rubric that a naive grader would keep re-applying — and pushed the fix into both the judge prompt and the compiler rather than accepting a one-off score bump.
You idiot, how will you possibly see those things? You can just call it orderliness of organization and stuff. Come on, man, so stupid.

Taste

9

On 07-13 you told the AI to drop the user counts for Project A and Project B and to keep your words instead of paraphrasing because 'it reads as AI', which is your own art rule enforced on yourself: the right version goes around the thing rather than stating it.

92026-07-08 · Excavate AI session archives for life pattern an
Flow definition: 'Any slot where I'm not typing something to the agent is a broken flow. Like, it is broken.' Also: verdicts over questions: 'Don't ask the user fucking questions, bro. Just tell the user inferences.'
>> Any slot where I'm not typing something to the agent is a broken flow. Like, it is broken.
92026-07-13 · Redesign personal website with portfolio and tho
Developed and enforced a specific principle about effective communication: the best art should never state the thing directly, but make the meaning felt by going around it. Also repeatedly caught when output sounded generic or AI-like, and corrected toward authentic voice throughout.
>> don't mention number of users for Project A and Project B, also try and make sure that everywhere you use my words and not paraphrase too much...... it reads as AI
92026-06-25 · Claude code qualitative
Defined the taste bar itself, up front and correctly, before letting the AI apply it: distinguishing real taste from generic feedback.
Any feedback to the AI does not count as taste. What counts as taste is highly particular and highly right, highly opinionated, like when you know that, "Oh shit, the user is right, and the AI could not have got this on its own."
92026-06-26 · Claude code taste
Authored a full up-front theory of what 'taste' actually is (gut feeling, first emotional reaction, ability to hold a bar, and — crucially — leading the AI on layout rather than just approving its output) before any grading work began, then drove a page-by-page product spec by name (project-color legend with hex+name+days+hours, full-width flow chart before the number, benchmark gap visuals, 'Lixi
Taste is their gut feeling. Their instinct for what resonates and what doesn't... their ability to hold a high bar for themselves based on that
92026-06-26 · Claude code taste
The huge, front-loaded redesign spec for the dashboard — demanding minimalism, per-project hex-coded legends instead of a generic GitHub-style heatmap, and benchmark panels designed to make the user 'viscerally feel the gap' versus top performers.
Remove the 35 activities, 94.2 hours. We have to be minimal! Remove all extra stuff!
▸ see 5 more examples
82026-07-07 · Understand Claude agent capabilities
Rejected the AI's copy as cringe and handed over a handwritten exemplar of the exact register wanted, which became the new standard verbatim.
But it's very cringe - your current thing / it should be hard hitting and pithy like this / You're a high-agency outcomes machine — drop you into any small startup and you'd independently own the outcome and just get the thing done, relentlessly. That's the rarest, most load-bearing thing here, and it's real: top 0.1% on agency.
82026-07-03 · Set up end-to-end testing for app distribution
Rejected the AI's 'keep it plugged in' overnight-rehearsal workaround as a real product decision, forcing a proper fix instead of a papered-over one.
cant ask users to keep t plugged in
82026-06-28 · Making you feel seen
Rejected the AI's 'feel-seen' flattery copy ('smart is a lazy word...') as cringe and named the exact mechanism that was wrong — repackaging known information as data — then supplied the fix.
That's cringe because I already know this, and you probably already know that I already know this.
82026-06-05 · Report generation
Three distinct 'oh shit, they're right' calls the AI couldn't have self-generated: (1) anti-slop call on 'world-class strategist who thinks natively in systems and incentives' — named exactly why it's wrong and modeled what concrete looks like; (2) percentile-scarcity enforcement applied five rounds until pills numbered three total; (3) authored their own failure-mode copy verbatim ('Too agreeable
What is this AI slop, man? No one speaks like that. Have it be concrete and not fluff at all. Observes demanding material across physics, philosophy, policy, and markets. Say 'reads a lot of books across philosophy, this, this, this, and this.'
82026-06-14 · Feature 2
Rejected the AI's 'invent fresh formal machinery' bar for an 11 and the all-or-nothing scoring of partial-9/partial-10 conversations, and the AI conceded both were wrong.
Why does someone need to invent fresh formal machinery? You idiot, people cannot. No, it's too much. You cannot expect someone to create fresh formal machinery. The best you can hope for is synthesis and great critical thinking, catching things in real time and figuring things out, which wasn't in the material.

In conclusion

What you actually are

Your judgement is the real thing and you see the load-bearing thing before anyone else can name it: drop you into any team building with AI and you'd be the one who sets the definition everyone else builds against, and it would be right. That pair is rarer than any amount of throughput, and across 102 graded sessions yours holds. On 06-25 you threw out two flow metrics in a row and replaced them with idle versus typing versus AI-running per 10-minute window; on 06-29 you caught the grader conflating perfectionism-driven deliberation with disorganization and pushed the fix into the judge prompt and the compiler instead of taking the one-off score bump, and judgment moved 7 to 9 on the re-run. Judgement 10 and abstraction 10 across 102 graded sessions is not one good day.

Judgement10/11Agency9/11Taste9/11

You’re already operating at a level most people in coding agents never reach. Now the fun part — what the people a notch above you do differently, and how to close it.

What the people better than you do

the habits behind the gap — what they’ve been doing differently, section by section
  • Protect their timein deep flow ~50% of the day — you're at 28%, so your attention scatters
  • Sustain focus longermulti-hour unbroken sessions — your average stretch is just 20m before a break
  • Run agents in parallelseveral sessions at once — you mostly drive one (×1)
  • Invest in your CLAUDE.mdYou re-teach Claude the same anti-fluff, no-jargon, 'feel seen' copy rubric by hand almost every session.
  • Start every complex task in Plan modeOnly 5 of your last 73 sessions entered Plan mode, though many are large multi-file rebuilds.
  • Give Claude test cases so it can verify its own work and run longerYou personally re-check scoring outputs by hand, catching mis-scores like your own growth rate after each run.

Want yours?

Runs locally from your own logs. Your data never leaves your machine; only what you approve is ever shared.

Get your report