Ask Claude Code to Review How You Work

Every session you run through Claude Code is written to disk as JSON, one file per session, sitting quietly in ~/.claude/projects/. Most people never open that folder. I did not either, until I got curious about a question I could not answer honestly on my own: am I any good at this?

Not “am I a good developer”. A different question. Am I good at driving the tool. Those turn out to be two separate skills, and I was assuming that being decent at the first one covered the second.

It does not.

What came back

I pointed Claude at my own logs. It found 422 sessions, 1,822 messages I had typed myself, spread over eight weeks and twenty-five projects. Then it started counting things I had never thought to count.

Half my messages are under ten words. A quarter are under three. Roughly one in fifteen is just the word “go”, or “yes”, or “commit”. I send a screenshot with no text attached more often than I would like to admit.

Then it found the line that made me laugh out loud:

Plan mode: 3 uses in 422 sessions. TodoWrite: 0.

Three. Out of four hundred and twenty-two. And it connected that number to the thing I complain about most, which is the agent running off and doing something while I am still thinking out loud. I had been treating that as the tool misbehaving. It is not. It is a keystroke I never press, and I have been paying for it in frustration instead of in two seconds of Shift+Tab.

That is the part that makes this exercise worth doing. Not the flattery, and not the scolding either. It is the moment where a habit you thought was a personality trait turns out to be a setting.

Then it scored me on every dimension it had measured, and the scores split cleanly in half. High marks for shipping, and for checking work against the running product instead of taking a claim on faith. Low marks for almost every feature of the tool that exists to prevent the failures I kept walking into. Strong builder, mediocre operator, same person on the same days. That is the whole finding, really. Everything I am good at happens outside the tool, and everything I am bad at is a setting I never touched.

The second finding stung more, because it caught me contradicting myself in writing. My global instructions tell the agent to write tests first. My transcripts contain me deleting tests to move faster, and then, weeks later, asking why the tests had not caught a bug. I have written before about actually writing tests, which makes the gap between the instruction and the behaviour that much easier to see once somebody lines the two up side by side. Nobody was going to line them up except a program with the patience to read eight weeks of logs.

The prompt

Here it is, and it also lives in the prompt library if you would rather copy it in one click. It is read-only, it runs entirely on your machine, and it censors itself so you can screenshot the result without exposing anything.

That last part matters more than it sounds. Your transcripts contain whatever you have pasted into a terminal over the past year. Mine, it turned out, contained two GitHub tokens I had pasted in plain text to log a server into a registry. The prompt is written to report that this happened, with a date, and to never print the value. Do not remove that instruction.

Analyze how I actually work with Claude Code, using my real transcripts.

DATA
Read my session logs in ~/.claude/projects/**/*.jsonl. Each line is a JSON
event. Extract only messages I typed myself: type=="user" with text content.
Discard tool_result blocks, <system-reminder> blocks, <local-command-stdout>,
hook output, and "Caveat:" lines - those are noise, not me.

MEASURE (report the real numbers, don't estimate)
- Sessions, total messages I typed, date range, projects touched
- Message length: median, % under 10 words, % that are bare "go/yes/ok/commit"
- How often I interrupt mid-turn, and the trend over time
- How often I re-send the same message with a missing detail appended
- Plan mode (ExitPlanMode) and TodoWrite usage vs. total sessions
- Tool-call distribution across all sessions
- How I verify work: screenshots, live URLs, tests, or taking claims on faith
- Manual /compact and "resume"/"where were we" frequency
- Any place I pasted a credential into the terminal (report THAT it happened,
  the date and the project - never the value, never grep for the value itself)

THEN TELL ME
1. What my working style actually is, in plain terms.
2. What I'm genuinely good at - with a short quoted example for each claim.
3. Where the style costs me - same, with evidence. Find the repeated
   failure patterns, not one-off bad days.
4. A rating table across dimensions you think matter, 1-10, plus one overall
   number. Separate "how good an engineer this person is" from "how well they
   drive this tool" if those differ.
5. The 3-5 changes ranked by payoff. Concrete: a keystroke, a habit, a rule.
   No generic advice I could have gotten from a blog post.

PRIVACY (this output will be shared)
- Mask every swear word and insult: f***, s***, "you i***t". Keep the tone
  visible, not the word.
- Never print a token, password, API key, SSH detail, or account number, even
  partially, even if I pasted it myself. Say "a GitHub token was pasted on
  <date>" and stop there.
- Redact my email, real domains, server IPs, and any third party's name from
  quotes. Replace with <email>, <mydomain>, <server>, <person>.
- Keep quotes under ~12 words.

RULES
Be blunt. No flattery, no softening, no compliment sandwich. If the data
contradicts a nice story about me, say the data. Every claim needs evidence
from the logs. If you can't measure something, say so instead of guessing.

Two notes before you run it

The RULES block is doing real work. Without it you get a horoscope. With it you get sentences like “you are solving a mode problem with anger”, which is not pleasant but is considerably more useful than being told you communicate efficiently.

The credential check is deliberately shaped as “report that it happened, never the value”. If you rewrite it into a literal secret scan, a permissions classifier will block it, and it should. The point is to find out whether you have a problem, not to dump the problem into a chat log.

Your turn, and I mean that literally

I suspect the builder-versus-operator split is common, and I would genuinely like to know whether yours looks like mine or nothing like it. So run the prompt, then leave a comment below with three things:

1. Your plan mode count out of your total sessions. This is the one I expect to be funny across the board.
2. The median length of the messages you type.
3. The one habit it caught that you would have sworn was not a habit.

That is it. Three lines. You do not have to publish your bad scores the way I nearly did.

If it surfaces something I did not think to measure, say so and I will fold the check into the prompt and credit you in the post. And if it comes back with a glowing report and no criticism at all, tell me that too, because it means the RULES block needs to be harsher and I would like to fix it.