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.
How you stack up
- How hard you push6/11you 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/11you 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
←Hover any day in the grid to see exactly what you worked on that day.
Intensity and Focus
Daily rhythm
Work window 10am–11pm. Afternoon worker — 61% of active time is noon–6pm. Peaks around 5pm, second push at 6pm.
Output
6/10Flow state, day by day
in flow vs supervising, half-hour by half-hour · last 14 daysaxis→You should be in flow state much longer.
You are at 1.1h a day, longest recent run 1.4h.
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:
- 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
33.9h worked · 9.3h away — for every hour you worked, you were gone 17 minutes.
- 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- Diff viewer 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.
- 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→How you use AI
What you’re doing with AI
- 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.
- 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 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.'
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- Running agents in parallel — 6 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 context — 7 fork/resume copies in the recent window — you're already branching off warmed-up sessions instead of rebuilding context from scratch.
- Automating whole browser tasks — Heavy 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 skills — 30 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 dictation — Your 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”.
The qualitatives
Our best read, with the specific chats behind it. Coding logs are a narrow window, so thin evidence reads as a range: your real level can sit above or below what shows up here.
Judgement
10On 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.
▸ see 5 more examples
Agency
9· estimatedOn 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.
Taste
9On 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.
▸ see 5 more examples
Growth
How you've gotten better at this: discovered arcs of real change, each checked against a measured monthly series. Declared intentions that never stuck are dropped, and counted honestly.
Growth
10He treats his own way of working as an engineering problem: across three independent arcs he diagnoses his own bottleneck, engineers a specific fix that sticks, and turns failures into standing rules so they can't recur, and all three monthly reads move with the story. The workflow in July, front-loaded specs, encoded principles, and unattended overnight fleets, is measurably different from the reactive single-laptop loop of spring.
▸ Show concrete examples▾ Hide concrete examples
Before (2026-06): He under-briefed handoffs and fixed them in the moment; the full spec often arrived only after several correction rounds, and he steered by interrupting rather than by setting the task up right.
Now (2026-07): He front-loads what matters, gates the build behind a plan he approves, and delegates the how in a single terse line.
- He named his own shoot-and-correct habit as the bottleneck, not the AI. · 2026-06-25Retrospective on the 'making things look kind' session: 'The markers are that I was repeatedly unhappy with what the AI was responding with. This is maybe a bit of a giveaway that I should be driving it better, instead of having it shoot and me telling it if it's good or not.'
- He identified never using plan mode as the cause of the endless check-ins and switched to converting his asks into one front-loaded, ticked-off punch list before any build. · 2026-06-29'The plan mode thing is extremely important. I literally never do that. It's very stupid of me. I should definitely use plan mode.', in the same stretch he starts dumping the whole spec at once: 'make todos out of all of these and talk to me about it.'
The numbers agree: The monthly read on how well-briefed his handoffs are climbs from 5.5 in May to 6.2 in June to 7.2 in July, its steepest jump landing exactly where the front-loading habit sticks.
Before (2026-06): When the AI went off course he interrupted and redirected, but the workflow that produced the miss stayed the same; he fixed the instance, never the loop.
Now (2026-07): He now treats a slow loop as a bug: he spots the bottleneck mid-session and restructures around it on the spot.
- He stopped grading AI outputs one at a time through chat and had a local human-in-the-loop labeling tool built to relabel the whole corpus at once. · 2026-06-21He recognizes the one-at-a-time chat loop is wrong and proposes the tool; the AI builds 'a small local feedback labeling tool', and the running artifact shows in-session as its own UI: '0 labeled · 76 shown / 76 total'.
- He converted a repeated breakage into a standing written rule so the same failure can never recur. · 2026-06-29After the dev-server duplicate-instance breakage kept biting, '>> Can you please add these instructions to the claude.md for this project?', which became the '⛔ ONE dev server only' rule pinned at the top of CLAUDE.md.
- He stopped patching one report's output and instead encoded the principles upstream so every future generation inherits them. · 2026-07-08'Please encode it based on everything you learned... encode it into some files, and ensure that when this report is being generated, SONNET or OPUS or whatever is actually generating this looks at that. It looks at a few short examples based on what we created together... and run experiments with generating it with SONNET and ensure it works.'
The numbers agree: The monthly read on how often he restructures his own way of working rather than just reacting rises from 6.4 in June to 7 in July, after sitting flat at 6 through the thin spring.
Before (2026-05): He ran one machine, queued the next prompt while the AI worked, and checked results with preview screenshots; nothing ran on its own.
Now (2026-07): Unattended overnight pipelines are routine now, wired to re-trigger themselves past usage limits.
- He pushed the work onto a wide parallel subagent fleet, driving the concurrency ceiling himself. · 2026-06-14'Is it possible to parallelize it even more heavily? Because this is literally not even sequential, it's all parallel tasks.', which drove a 96-wide claude-p subprocess pipeline with self-relaunching ScheduleWakeup re-arm loops.
- He stood up an always-on EC2 box so runs keep going while he is away from the laptop. · 2026-06-20'I want you to set up an EC2 instance on my AWS... so that even when I am away from my computer, I can keep it running... I'm going to sleep now, so just finish all of this here' (plus 'please don't remove anything from my local machine').
- He batched slow verification into unattended overnight runs, keeping the machine awake with caffeinate and scheduling wake-checks across the night. · 2026-07-07'ok now with our updated thing pls set our system running overnight... i will ensure i keep laptop to charge' then 'im sleeping now bro pls ensure it works dont fuck it up see you in the morning.'
The numbers agree: The monthly read on how ambitiously he operates the tooling climbs 5.3 to 5.7 to 6 to 6.5, and subagents per session go from none in spring to about one and a half in June, exactly when the fleet habit lands.
The next rung's record would show the improvement loop turned on itself: a ledger or dashboard tracking his own workflow changes rather than the product's pipeline, a workflow habit that regressed and got caught and reversed within days, and upgrades that visibly make the next upgrade land faster.
Declared but never stuck: Queuing the next prompt while the AI works was already a standing habit before this window (157 queued items in a single May session), so its heavy presence is not growth inside the period; the per-session rate actually eases from about 22…
Declared but never stuck: Flow share and active hours per day jumped once, when he went full-time on the project in late spring, then held flat. That is ramping into the work, not a change in method, so it is not an arc.
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.
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
- Protect their time — in deep flow ~40% of the day — you're at 28%, so your attention scatters
- Sustain focus longer — multi-hour unbroken sessions — your average stretch is just 20m before a break
- Run agents in parallel — several sessions at once — you mostly drive one (×1)
- Invest in your CLAUDE.md — You re-teach Claude the same anti-fluff, no-jargon, 'feel seen' copy rubric by hand almost every session.
- Start every complex task in Plan mode — Only 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 longer — You 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 transcripts never leave your machine; only what you approve is ever shared.
Get your report