Claude Code usage insights
3,143 messages · 248 analyzed sessions (319 total) | 2026-04-14 to 2026-05-17
Where the time went. Lecture production led by a wide margin, with logging and observability close behind. Career development rounded out the top three. See work areas
Biggest payoff. Building runnable teaching demos with Claude cut lecture prep time by roughly 60%. See big wins
Easiest fix. Most repeated messages were re-explaining project context. A CLAUDE.md file would reclaim them. See suggestions
Work areas
Sessions grouped by what you were actually working on, biggest first.
The single largest area. Building slide decks, code walkthroughs, and example projects for a teaching workload - turning rough outlines into runnable demos and clean, narratable code.
Wiring up structured logging, tracing, and log aggregation across services. A lot of back-and-forth on log levels, redaction, and making noisy output actually readable.
Resume and portfolio passes, interview prep, system-design rehearsals, and drafting talks. Claude as a sparring partner more than a code generator here.
One-off automations: data munging, repo cleanup, CI tweaks, and small CLIs that smooth out the day-to-day.
Quick lookups, debugging odd errors, and the occasional rabbit hole that didn't fit anywhere cleanly.
What happened over the month
The month opened in lecture mode. Most early sessions were about turning teaching outlines into small, runnable demos - the kind of code that reads well on a slide and still actually runs. Once the pattern clicked, demo prep stopped being a slog and became a quick review pass.
By the second week the center of gravity shifted to logging. Five services had drifted into three different logging styles, and the work was consolidating them onto one shared helper with a real redaction policy. This is where the longest sessions lived, mostly because the desired output wasn't stated up front.
Career development threaded through the whole stretch: resume passes, a portfolio cleanup, and a run of mock system-design interviews where Claude played the skeptic. Those rehearsals were the highest-signal non-coding sessions of the month.
Big wins
The places where Claude clearly moved the needle.
Generating a working example app, then iterating on it live, cut prep time for each session by roughly 60%. The teaching materials got more concrete because building a real demo stopped being the bottleneck.
A shared logging helper plus a redaction policy got applied across five services in one focused week, replacing three different ad-hoc styles. Production incidents are noticeably faster to triage now.
Mock system-design sessions where Claude pushed back on hand-wavy answers surfaced weak spots that solo prep never did. Two of those rehearsals mapped almost one-to-one onto real interview questions.
Where things got stuck
Recurring friction worth designing around - none of it fatal, all of it fixable.
A large share of early-session messages were spent restating stack, conventions, and folder layout. This is exactly what a CLAUDE.md file is for.
- Pasting the same "we use structured JSON logs, never console.log" reminder into many sessions.
- Describing the monorepo layout from scratch before every refactor.
- Repeating which slide framework the lectures use.
Several sessions stalled trying to tame verbose third-party logs because the goal was stated vaguely. Naming the target output up front would have saved cycles.
- Asking "why is this so noisy" instead of "suppress library X below WARN".
- Iterating on log format without a sample of the desired final line.
A handful of requests bundled three or four tasks into one message, which produced sprawling diffs that were hard to review and partially undone later.
- "Refactor logging, add tracing, and write tests" in one shot.
- Combining a resume rewrite with a portfolio redesign in a single ask.
Suggested CLAUDE.md additions
Drop these into a CLAUDE.md at your repo root so Claude carries the context you kept retyping.
Project memory
Removes the most-repeated reminder across logging sessions.
Stops re-describing the teaching setup every session.
Cuts the over-scoped, sprawling-diff problem at the source.
Short-circuits the vague debugging loops.
Features worth trying
Picked for how you actually work, with a prompt you can run today.
Hand off independent chunks so the main thread stays focused.
Your lecture work often had a build task and a writing task running in your head at once. Subagents let you split those cleanly instead of context-switching in one conversation.
Spin up a demo while you draft the slide narrative.
Use a subagent to scaffold the /demos/streams example, then summarize what it built so I can write the slide notes around it.Get a written plan you can approve before any edits land.
The over-scoped prompts that produced messy diffs would have been caught here. You review the plan, trim it, then let it run.
Plan the cross-service logging migration first.
Plan the migration to the shared log helper across all services. List files and the order of changes. Do not edit yet.Bottle your repeated prompts into one keystroke.
You ran near-identical 'make a teaching demo' and 'add structured logging' prompts dozens of times. A saved command makes them one line.
A reusable demo scaffolder command.
/demo streams - scaffold a minimal Vite + TS example for the given topic with short, narratable code.Prompt patterns that worked
Distilled from your fastest sessions - copy a starting point.
Lead with a sample of the output you want before describing the task.
Your fastest sessions started with a concrete example - a desired log line, a slide outline, a sample diff. The slowest started with an open-ended 'can you help with'.
Here is the log line I want in production:
{"level":"warn","svc":"api","msg":"..."}
Make the logger emit exactly this shape. Suppress library X below WARN.Split bundled asks into a short, ordered sequence.
Single-concern prompts produced diffs you actually merged. Multi-concern prompts produced diffs you partly reverted.
Step 1 only: add the shared log helper to the api service. Don't touch tracing or tests yet - I'll ask for those next.Ask Claude to challenge your reasoning, not just produce an answer.
Your best interview prep came from telling Claude to act as a skeptical interviewer. The same trick sharpens design docs.
Act as a skeptical staff engineer reviewing this design. Push on the weakest assumptions and ask the questions a real interviewer would.By the numbers
On the horizon
Where this could go next, given how you already work.
Feed Claude a topic outline and have it produce both the demo repo and matching slide notes in one pass, so prep collapses to review-and-tweak.
Tip: Start by saving your demo scaffolder as a slash command, then layer the outline-to-deck step on top.
A small custom check that flags console.log, unredacted fields, and inconsistent log levels before they ship - turning your hard-won conventions into enforcement.
Tip: Encode the rules in CLAUDE.md first; once they're explicit, asking Claude to write the lint rule is straightforward.
A saved 'skeptical interviewer' command seeded with the role you're targeting, so each rehearsal starts in character without re-priming.
Tip: Keep a short log of questions that stumped you and feed it back in to focus the next session.
Feedback to send upstream
Patterns worth passing to the people building the tools and the model.
For the product team
The clearest theme: a lot of effort went into re-establishing context. Stronger persistent project memory would remove the single biggest source of repeated messages.
Evidence: Seen across lecture, logging, and tooling work alike.
Sessions anchored on a concrete example moved fastest. A first-class way to attach a desired-output sample would nudge more sessions into that lane.
Evidence: Strongest signal in the logging work.
For the model
When a prompt bundled several tasks, a brief 'want me to do all of this now, or step through it?' would have prevented the sprawling diffs that got partly reverted.
Evidence: Tied to the over-scoped-prompt friction above.
Tuesdays were your peak - 31% above an average day - and not a single session went by without a logging question. Here's to fewer console.logs next month.