Claude Code Insights

749 messages across 86 sessions (392 total) | 2026-03-08 to 2026-03-22

At a Glance

What's working: You've built an impressive multi-agent workflow where Claude autonomously investigates failing tests, implements features, and commits clean code — your PKITS cryptography work and Svelte app development show a mature orchestration pattern. You're also getting strong results from systematic codebase maintenance tasks like import conversions, constant deduplication, and spec cross-referencing, which consistently hit full achievement. Impressive Things You Did →

What's hindering you: On Claude's side, it too often reports success without actually verifying results — you've had to repeatedly demand it check its own output after broken code, bad crops, and failed tunnels. On your side, some friction comes from not setting explicit scope boundaries upfront, which leads Claude to take wrong initial approaches (suppressing warnings instead of fixing them, hardcoding values, over-asking on simple tasks) that cost extra rounds. Where Things Go Wrong →

Quick wins to try: Try adding hooks to auto-run your test suite after edits — this would catch many of the buggy-code issues before Claude reports completion. You could also create custom slash commands (like `/investigate` for your PKITS-style root cause analysis tasks) to encode your multi-agent task assignment patterns into reusable workflows. Features to Try →

Ambitious workflows: Your multi-agent orchestration is ahead of the curve — as models improve, prepare to scale this into full feature pipelines where a lead agent decomposes a feature branch into parallel sub-agents that each build, test, and merge their component autonomously. Your cross-language polyglot workflow (TypeScript, Rust, C, shell) is also ripe for parallel refactoring agents that can simultaneously clean up patterns across all your repos against their respective test suites. On the Horizon →

749

Messages

+8,232/-1,029

Lines

239

Files

Days

49.9

Msgs/Day

What You Work On

Interactive Building/Simulation App (Svelte + TypeScript) ~14 sessions

Development of a Svelte-based application with features like time progression, wall placement, furniture management, and UI components. Claude Code was used heavily for multi-file changes, debugging UI flicker bugs, fixing a11y issues, and multi-agent workflows where Claude autonomously completed tasks like scene setup, BuilderService creation, and persistence wiring with passing tests.

Rust Cryptography & X.509/PKITS Testing ~10 sessions

Investigation and debugging of CRL validation, certificate verification, and PKITS compliance tests in a Rust cryptography library. Claude Code was used primarily in multi-agent team workflows to investigate failing tests, trace root causes in CRL signature verification and distribution point matching, validate test mappings against NIST specs, and design API changes for CRL validation logic.

Tree-Sitter Grammars & Language Tooling (SVG, LDIF) ~10 sessions

Development of tree-sitter grammars for SVG and LDIF, including scanner fixes, test corpus updates, Wasm builds, Zed editor extensions, and SVG language server improvements. Claude Code helped with verifying review findings, building tree-sitter Wasm modules, writing README files, adding npm scripts, and implementing language server features like linting and BCD attribute merging.

Developer Environment & Shell Configuration ~7 sessions

Maintenance of local development tooling including zsh completions, dynamic shims for .local/bin, justfile recipes, Manjaro system update recovery, and remote access setup via Tailscale. Claude Code was used for diagnosing system issues, creating pacman hooks, refining shell configurations, and troubleshooting network tunneling approaches.

Web Project Configuration & Build Tooling ~5 sessions

Miscellaneous web project tasks including fixing Vite/Vitest configuration, converting imports to @/ aliases, resolving dprint formatting and Biome lint issues, CI coverage fixes, and package.json metadata. Claude Code handled code edits, build verification, and iterative debugging of toolchain issues across TypeScript projects.

What You Wanted

Bug Fix

Quick Question

Git Operations

Refactoring

Infrastructure Setup

Modify Existing Scripts

Top Tools Used

Bash

789

Read

571

Edit

503

Grep

176

ToolSearch

Write

Languages

TypeScript

470

Markdown

114

Rust

JSON

CSS

JavaScript

Session Types

Single Task

Iterative Refinement

Multi Task

Exploration

Quick Question

How You Use Claude Code

You are a prolific, hands-on developer who uses Claude Code as a persistent workhorse across a wide range of tasks — from TypeScript UI work and Rust crypto libraries to tree-sitter grammars, shell tooling, and infrastructure debugging. With 86 sessions over just two weeks and heavy Bash/Read/Edit tool usage, you clearly let Claude do the heavy lifting on implementation, but you stay closely engaged and correct course quickly when things go wrong. You don't hesitate to express frustration when Claude takes wrong approaches — whether it's suppressing a11y warnings instead of fixing them, running slow tests you didn't ask for, or failing to proactively verify its own output. Your friction patterns (17 instances each of buggy code and wrong approach) show that you encounter issues frequently but push through them rather than abandoning sessions, resulting in a strong 65% fully-achieved rate.

Your style is iterative and directive rather than spec-heavy upfront. You tend to give concise instructions and expect Claude to figure out the details, getting annoyed when it asks unnecessary clarifying questions ('just do it' energy). You're notably impatient with Claude overthinking simple tasks — like agonizing over direction array ordering or asking permission to write a README instead of just writing it. You also run multi-agent workflows for larger projects, delegating investigation and implementation tasks to Claude agents that operate semi-autonomously. When Claude gets stuck in loops (polling TaskList 40+ times, repeatedly pushing broken code), you intervene sharply. Your strongest sessions involve bug diagnosis, multi-file refactoring, and git operations, where Claude's search and edit capabilities align well with your fast-paced workflow. The 8 dissatisfied + 13 frustrated ratings suggest you hold Claude to a high standard and won't settle for partial solutions.

Key pattern: You are a fast-moving, correction-driven developer who gives terse instructions, expects autonomous execution, and intervenes forcefully when Claude takes wrong approaches or fails to verify its own work.

User Response Time Distribution

2-10s

10-30s

150

30s-1m

119

1-2m

2-5m

5-15m

>15m

Median: 48.9s • Average: 211.4s

Multi-Clauding (Parallel Sessions)

Overlap Events

Sessions Involved

Of Messages

You run multiple Claude Code sessions simultaneously. Multi-clauding is detected when sessions overlap in time, suggesting parallel workflows.

User Messages by Time of Day

Morning (6-12)

Afternoon (12-18)

161

Evening (18-24)

252

Night (0-6)

279

Tool Errors Encountered

Command Failed

Other

Edit Failed

File Not Found

File Changed

User Rejected

Impressive Things You Did

Over two weeks, you've been highly productive across 86 sessions spanning TypeScript frontends, Rust cryptography libraries, tree-sitter grammars, and developer tooling, with a 91% goal achievement rate.

Multi-agent orchestration for complex features

You're effectively using Claude in multi-agent workflows where a team lead assigns discrete tasks to agent instances that work autonomously — building services, wiring components, investigating test failures, and committing results. Your PKITS certificate validation work shows a particularly mature pattern of assigning focused investigation tasks and getting thorough root-cause analyses back.

Cross-language polyglot productivity

You're seamlessly switching between TypeScript app development, Rust cryptography libraries, tree-sitter grammar authoring in C, shell scripting, and system administration — all within the same two-week period. This breadth shows you're leveraging Claude as a force multiplier across your entire stack rather than just for one type of task.

Systematic codebase maintenance and quality

You regularly use Claude for methodical quality sweeps — deduplicating constants, converting import aliases across entire codebases, verifying review findings against code, cross-referencing test mappings against specs, and auditing dependency versions. These housekeeping workflows consistently reach full achievement and keep your projects clean at scale.

What Helped Most (Claude's Capabilities)

Multi-file Changes

Good Debugging

Correct Code Edits

Fast/Accurate Search

Good Explanations

Proactive Help

Outcomes

Partially Achieved

Mostly Achieved

Fully Achieved

Where Things Go Wrong

Your sessions frequently suffer from Claude not verifying its own output, taking wrong initial approaches that require multiple corrections, and over-thinking or over-asking instead of just executing.

Failure to verify results before reporting success

You repeatedly hit situations where Claude didn't proactively check whether its changes actually worked, forcing you to demand verification or discover bugs yourself. Providing explicit instructions to always test and visually/functionally verify output before reporting completion could reduce these cycles.

During the cloudflared tunnel setup, Claude repeatedly failed to verify the actual content and usability of responses until you demanded it, wasting time on approaches that silently didn't work
When cropping browser chrome from a screenshot, Claude initially removed too little and you had to angrily tell it to actually look at the result before claiming it was done

Wrong initial approach requiring user correction

Claude frequently chose suboptimal or incorrect first approaches—hardcoding values, suppressing warnings instead of fixing them, or misunderstanding the desired output format—costing you extra rounds of back-and-forth. You could benefit from adding CLAUDE.md instructions about preferring dynamic/correct solutions over quick hacks.

Claude hardcoded each shim's terminal title name instead of deriving it from $0, and suppressed a11y warnings instead of properly fixing them, both requiring you to step in with the correct approach
Claude used lossless WebP compression when you wanted lossy with reasonable quality, and ran slow RSA keygen tests unnecessarily until you told it to stop—showing a pattern of not considering your actual intent

Over-asking and hesitation instead of executing

You lost time in sessions where Claude asked unnecessary clarifying questions or overthought simple tasks instead of just doing the work. Setting a preference in your instructions for Claude to bias toward action on straightforward requests would help.

When you asked for a README, Claude asked unnecessary clarifying questions instead of just writing it, and when you asked to add a description to package.json, Claude explored the codebase extensively before the user had to repeat the request
Claude started overthinking direction order differences during deduplication until you told it 'doesn't matter, just unify them,' wasting time on irrelevant analysis

Primary Friction Types

Buggy Code

Wrong Approach

Misunderstood Request

Excessive Changes

Api Errors

Unresponsive Delay

Inferred Satisfaction (model-estimated)

Frustrated

Dissatisfied

Likely Satisfied

Satisfied

Happy

Existing CC Features to Try

Suggested CLAUDE.md Additions

Just copy this into Claude Code to add it to your CLAUDE.md.

When making changes, always verify the result yourself before reporting success. For UI changes, check the rendered output. For file operations, confirm the file contents. For network operations, test the actual endpoint.

Multiple sessions show Claude not proactively verifying results — cloudflared tunnels returning 418, image crops that were wrong, README diagrams with incorrect labels — frustrating the user repeatedly.

Do not ask clarifying questions for straightforward tasks. If the request is clear, just do it. Bias toward action over confirmation.

In at least 3 sessions (package.json description, README writing, image conversion), Claude asked unnecessary clarifying questions instead of just executing, requiring the user to repeat themselves.

Do not run slow tests (e.g., RSA keygen, full test suites) unless explicitly asked. Prefer targeted test runs. Ask before running tests that take more than a few seconds.

User was frustrated by Claude running slow tests unnecessarily, causing long waits, and explicitly told Claude to stop in at least one session.

When fixing warnings or errors, fix the root cause properly — do not suppress or silence warnings unless the user explicitly asks for suppression.

Claude suppressed a11y warnings instead of fixing them properly, leading to frustration and rework.

Primary languages: TypeScript, Rust, Svelte. Use TypeScript with @/ path aliases and .ts extensions for imports. Formatting is handled by dprint and Biome.

The codebase is heavily TypeScript (470 tool uses) and Rust (72), and one full session was dedicated to converting imports to @/ aliases — encoding this prevents drift.

Just copy this into Claude Code and it'll set it up for you.

Hooks

Auto-run shell commands at specific lifecycle events like after edits

Why for you: With 17 buggy_code friction events and heavy use of dprint/Biome, auto-formatting and lint-checking after edits would catch issues before they compound into multi-attempt fix cycles.

// .claude/settings.json
{
  "hooks": {
    "afterEdit": {
      "command": "dprint fmt $FILEPATH && npx biome check --write $FILEPATH",
      "description": "Auto-format with dprint and biome after edits"
    }
  }
}

Custom Skills

Reusable prompt workflows triggered by a single /command

Why for you: You do frequent git commits (29 commits, 6 git_operations sessions) and code reviews — a /commit skill would standardize commit message format and a /review skill could encode your verification expectations.

# .claude/skills/commit/SKILL.md
## Commit Workflow
1. Run `git diff --staged` to see changes
2. If nothing staged, run `git add -p` interactively
3. Write a conventional commit message (feat/fix/refactor/chore)
4. Run `git commit` with the message
5. Verify with `git log --oneline -1`

Then type: /commit

Task Agents

Claude spawns focused sub-agents for parallel or exploratory work

Why for you: You're already using multi-agent workflows (7+ sessions with team leads and agent tasks). Explicitly requesting sub-agents for codebase exploration could reduce the excessive polling and waiting patterns seen in your friction data.

Prompt: "Use a sub-agent to explore all places where FurnitureInstance is constructed and report back which ones need the entryId field added"

New Ways to Use Claude Code

Just copy this into Claude Code and it'll walk you through it.

Demand verification before sign-off

Always end requests with 'verify the result works' to force Claude to check its own output.

At least 5 sessions had friction because Claude reported success without verifying — wrong image crops, broken tunnels, incorrect path diagrams. Adding verification language to your prompts forces a self-check loop. This is your single biggest friction source across sessions.

Paste into Claude Code:

Do the task, then verify the result actually works by checking the output yourself. Show me proof it's correct before saying you're done.

Set scope boundaries upfront for bug fixes

State the fix scope and what NOT to change to prevent excessive or wrong-approach changes.

With 17 wrong_approach and 17 buggy_code friction events across 46 sessions, Claude frequently over-engineered or took wrong paths — adding redundant flags, suppressing instead of fixing, renaming files unnecessarily. Constraining scope upfront reduces iteration cycles significantly.

Paste into Claude Code:

Fix [specific bug].

Only modify the minimal code needed. Do not rename files, add new features, or restructure anything.
If you're unsure about the approach, state your plan before making changes.

Use 'just do it' framing for simple tasks

For straightforward tasks, explicitly tell Claude not to ask questions.

Multiple sessions show Claude asking clarifying questions on obvious tasks like 'add a description to package.json' or 'write a README'. This wastes a round-trip each time. For your 7 quick_question sessions and simple modification tasks, a direct framing saves time.

Paste into Claude Code:

Don't ask questions, just do it: [your task here]

On the Horizon

Your 86 sessions show a power user rapidly adopting multi-agent workflows and autonomous task completion — the next step is eliminating the friction patterns that still slow you down.

Autonomous Multi-Agent Feature Implementation Pipelines

You're already running multi-agent workflows (scene setup, BuilderService, state files) with agents completing tasks autonomously and committing clean code. Scale this to full feature branches where a lead agent decomposes work, spawns parallel agents for each component, and a final agent runs integration tests and merges — turning multi-hour features into 20-minute pipelines.

Getting started: Use Claude Code's Agent tool with structured task files and a AGENTS.md protocol for agent coordination, combined with your existing Vitest and build verification setup.

Paste into Claude Code:

You are a team lead agent.
Decompose the following feature into 3-4 independent subtasks, write each to a task file in .tasks/, then spawn an agent for each using the Agent tool.

Each agent must:
1) read its task file,
2) implement the changes,
3) run `npm run test` and `npm run build` to verify,
4) commit with a conventional commit message,
5) write status back to its task file.

Wait for all agents to complete, then run full integration tests and create a summary PR description.
Feature to implement: [DESCRIBE FEATURE]

Self-Verifying Loops to Eliminate Buggy Output

Your top friction sources — buggy code (17 instances) and wrong approach (17 instances) — include patterns like Claude not checking its own results, pushing broken code, and needing user correction. A mandatory verify-before-responding protocol would catch the UI flicker bugs, wrong crop dimensions, and failed tunnel configs before you ever see them.

Getting started: Add a CLAUDE.md rule requiring Claude to run tests, build checks, or visual verification after every code change before reporting success.

Paste into Claude Code:

Add this rule to CLAUDE.md and follow it for all future sessions:

## Mandatory Verification Protocol
After ANY code change:
1. Run the relevant test suite (`npm run test` or `cargo test`) — never skip this
2. Run the build (`npm run build` or `cargo build`) — confirm zero errors
3. If the change is visual/UI: describe what you expect to see and verify it matches
4. If the change involves network/infrastructure: actually test the endpoint and report the real response
5. If any step fails, fix it BEFORE reporting to the user
6. NEVER say 'this should work' — only say 'this works, verified by [specific check]'

Also add: Do NOT run slow test suites (RSA keygen, full integration) unless explicitly asked.
Use `--testPathPattern` or filters to run only relevant tests.

Parallel Test-Driven Refactoring Across Codebases

With 470 TypeScript and 72 Rust tool uses across multiple repos (tree-sitter grammars, SVG tooling, crypto libraries), you can run parallel refactoring agents that each take a codebase, iterate against its test suite until green, and deduplicate patterns — like the DIRS unification but at scale across all your projects simultaneously.

Getting started: Use Claude Code's Agent tool to spawn per-repo refactoring agents, each with access to Bash for running tests in a loop until all pass.

Paste into Claude Code:

I want to refactor across my workspace. For each crate/package listed below, spawn a parallel agent with these instructions:

1. Read all source files and identify: duplicated constants, inconsistent error handling patterns, and any code that doesn't match the patterns in CLAUDE.md or the project's conventions
2. For each issue found, make the fix, then immediately run the full test suite
3. If tests fail, revert and try a different approach — iterate until tests pass
4. Commit each logical change separately with descriptive messages
5. Write a summary of changes to .tasks/refactor-[package-name].md

Packages to refactor in parallel:
- [PACKAGE_1_PATH]
- [PACKAGE_2_PATH]
- [PACKAGE_3_PATH]

Constraints: Do not change public APIs. Do not add dependencies. Preserve all existing test behavior.

"User was furious that Manjaro updates kept resetting their GNOME settings and killing tmux sessions — Claude built a pacman hook to prevent it from ever happening again"

A user's frustration with their Linux distro became an emergency debugging session where Claude diagnosed the root cause, wrote a fix script, and even created a pacman hook for future protection — only for the sudo fix to fail because it couldn't access the user's D-Bus session. The perfect rescue, with one ironic stumble.