Claude Code Insights

4,038 messages across 255 sessions (429 total) | 2026-03-04 to 2026-04-05

At a Glance

What's working: You've built a strong iterative workflow where you take complex bugs through the full lifecycle — reproduction, refinement, and PR submission — using Claude as a genuine pair programmer. Your ability to blend code work with project coordination (verifying PRs against issues, bulk-updating Jira, resolving review comments) keeps development and planning tightly synced without context-switching overhead. Impressive Things You Did →

What's hindering you: On Claude's side, it frequently starts down the wrong path — wrong branch, wrong tool, misreading your architecture — burning time until you manually redirect. It also over-plans when you just want execution, forcing you to push it forward. On your side, sessions tend to go smoother when you front-load context about which branch, environment, or approach to use; without that, Claude's first attempt is often wasted. Where Things Go Wrong →

Quick wins to try: Try setting up hooks to auto-run build checks or kill stale processes after edits — this would catch several recurring friction points (stale binaries, broken symlinks) before they snowball. You could also create a custom /command for your PR review workflow that includes explicit constraints like "check against the linked issue, don't raise critical findings without verification, and work from the correct branch." Features to Try →

Ambitious workflows: As models get more capable, your signature bug-reproduction-to-PR pipeline can become fully autonomous — Claude understanding the issue, reproducing it, iterating fixes against the test suite, and opening the PR without you babysitting each cycle. Your CI debugging sessions (like the vitest upgrade with 300 tests) are also prime candidates for autonomous fix-and-iterate loops that could compress multi-hour sessions into minutes. On the Horizon →

4,038

Messages

+38,894/-8,643

Lines

656

Files

Days

134.6

Msgs/Day

What You Work On

Browser Automation Tool (Rust) ~12 sessions

Development of a Rust-based browser automation/agent tool, focusing on CDP (Chrome DevTools Protocol) WebSocket connections, remote browser discovery, per-tab RefMap isolation, and SPA ref invalidation fixes. Claude Code was used extensively for bug reproduction, iterative implementation and refactoring of core features, PR creation/review, and contributing to open-source issues.

Frontend Web Application (TypeScript/React) ~35 sessions

Work on a Korean-language web application (likely called 'berriz') involving reservation product features, claim management, identity verification, carousel migration, and React Hook Form usage. Claude Code assisted with API type generation from backend specs, UI bug fixes, code review, merge conflict resolution, and deployment across multiple environments.

Developer Tooling & CI Infrastructure ~15 sessions

Vitest/Vite major version upgrades, markdown linting setup with CI integration, TSC/lint error fixes, and MCP configuration. Claude Code was used to run test suites iteratively, debug CI failures, set up persistent linting infrastructure, and configure development tool integrations.

DevOps & Deployment ~10 sessions

Infrastructure work including AWS deployment across multiple environments, WAF configuration with API Gateway/CloudFront, Terraform management, and Lambda setup. Claude Code helped diagnose deployment issues, find workarounds for API limitations, document deployment workflows, and manage git operations for releases.

Project Management & Documentation ~12 sessions

Jira task management (bulk updates, status verification against design specs), Confluence documentation reorganization, PR description writing, meeting prep analysis, and Korean-language reporting. Claude Code was used to interact with project management tools, verify feature completion against designs, and generate structured analysis documents.

What You Wanted

Git Operations

Code Review

Commit And Push

Bug Reproduction

Pr Creation And Updates

Code Changes

Top Tools Used

Bash

5765

Read

2716

Edit

2084

Grep

1191

Agent

568

Write

309

Languages

TypeScript

2228

Rust

1900

Markdown

295

JSON

177

JavaScript

CSS

Session Types

Single Task

Iterative Refinement

Multi Task

Quick Question

Exploration

How You Use Claude Code

You are a high-velocity, hands-on developer who uses Claude Code as a daily workhorse across 255 sessions in just one month — averaging ~8 sessions per day. Your workflow is heavily git and PR-centric, with your top goals being git operations, code review, commit/push, and PR creation. You don't write long specs upfront; instead, you iterate rapidly, kicking off tasks and course-correcting as you go. When Claude gets stuck in planning mode or deliberates too long, you push it forward — literally telling it '갑시다 진행' (let's go, proceed). You're comfortable interrupting sessions, redirecting Claude when it takes a wrong approach (37 instances of wrong_approach friction), and manually stepping in when needed, like running `pnpm install` yourself when Claude couldn't resolve workspace issues.

Your work spans a polyglot stack of TypeScript and Rust with significant Bash usage (5,765 invocations), suggesting you rely heavily on Claude to run commands, test builds, and verify changes in real-time rather than just generating code. You use Claude for the full development lifecycle: understanding issues, reproducing bugs, implementing fixes, refactoring to production quality, running tests, and submitting PRs. Notable examples include the CDP WebSocket fallback implementation and the remote CDP discovery bug fix, both of which involved extensive back-and-forth refinement through multiple iterations. You also leverage Claude for non-coding tasks like Jira management, meeting prep, and Confluence documentation — though the Confluence session where Claude destroyed content highlights the risk of your fast-moving style.

Despite the frequent friction (37 wrong approaches, 17 misunderstandings, 15 buggy code instances), your satisfaction remains remarkably high — 245 sessions likely satisfied plus 56 satisfied, with only 18 dissatisfied/frustrated. This suggests you've internalized that friction is part of the iterative process and you're skilled at steering Claude back on track quickly. Your 263 commits across the month and 65 fully achieved goals show this approach works well for you — you treat Claude less like an oracle and more like a fast but occasionally confused pair programmer that you actively supervise.

Key pattern: You are a rapid-iteration power user who drives Claude through short feedback loops, frequently interrupting and redirecting rather than providing detailed upfront specifications.

User Response Time Distribution

2-10s

286

10-30s

654

30s-1m

711

1-2m

546

2-5m

358

5-15m

246

>15m

126

Median: 49.0s • Average: 176.6s

Multi-Clauding (Parallel Sessions)

116

Overlap Events

128

Sessions Involved

20%

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)

1403

Afternoon (12-18)

1302

Evening (18-24)

1158

Night (0-6)

175

Tool Errors Encountered

Command Failed

365

Other

115

User Rejected

File Not Found

File Too Large

File Changed

Impressive Things You Did

Over the past month, you've run 255 sessions with a 81% full/mostly achieved rate, driving substantial work across TypeScript and Rust codebases with impressive commit velocity.

Iterative Bug Fix to PR Pipeline

You excel at taking complex bugs through a complete lifecycle — from reproduction to iterative refinement to production-quality PR submission. Your CDP WebSocket fallback and remote discovery fix sessions show you using Claude as a true pair programmer, catching issues during review and pushing through multiple refinement rounds until the code is solid.

Large-Scale Codebase Maintenance

You leverage Claude for high-impact maintenance work like major dependency upgrades (vitest/vite with 300 passing tests and 21.8% performance improvement) and fixing all 175 markdown lint errors with CI integration. You're not just patching — you're setting up lasting infrastructure so these issues don't recur.

Cross-Tool Project Coordination

You seamlessly blend code work with project management by using Claude to verify PRs against GitHub issues, review designs against Jira tasks, bulk-update tickets, and resolve PR review comments — all within the same workflow. This keeps your development and planning tightly synchronized without context-switching overhead.

What Helped Most (Claude's Capabilities)

Correct Code Edits

Good Explanations

Multi-file Changes

Fast/Accurate Search

Proactive Help

Good Debugging

Outcomes

Not Achieved

Partially Achieved

Mostly Achieved

Fully Achieved

Unclear

Where Things Go Wrong

Your sessions show a recurring pattern of Claude taking wrong initial approaches, over-planning instead of executing, and making destructive or incorrect changes that require your intervention to correct.

Wrong Initial Approach Requiring Course Correction

Claude frequently starts down the wrong path—analyzing the wrong branch, using the wrong tool, or misunderstanding the architecture—wasting your time until you manually redirect. Consider providing more upfront context about which branch, environment, or approach you want before Claude begins work.

Claude analyzed your feature branch code instead of main when investigating ref assignment, requiring you to redirect it to stash and checkout main
Claude tried to use Playwright to view a Google Slides presentation instead of simply asking you for screenshots, which you had to interrupt

Over-Planning and Hesitation Instead of Executing

Claude sometimes gets stuck in analysis and deliberation loops, asking too many questions or producing excessive plans when you just want it to start coding. You've had to explicitly push Claude forward with commands like '갑시다 진행' (let's go, proceed) to break the cycle.

During the commands.rs refactoring, Claude got stuck iterating on planning until you had to push it to proceed with actual implementation
Claude planned unnecessary code changes for BRZ-4626 before realizing the existing code already handled locale stripping correctly, wasting analysis time

Destructive or Incorrect Changes Requiring Rollback

Claude sometimes makes changes that break things or destroy existing content, forcing you to intervene with corrections or rollbacks. You could mitigate this by asking Claude to confirm destructive operations before executing, especially on shared resources like Confluence or large test suites.

Claude overwrote your original Confluence doc content during a reorganization, destroying the source material and forcing you to request restoration
An AbortSignal fix caused 65 test failures requiring a full revert, and Claude raised a false P0 issue about useEffect double-firing that you had to correct

Primary Friction Types

Wrong Approach

Misunderstood Request

Buggy Code

Excessive Changes

Environment Issue

Inferred Satisfaction (model-estimated)

Frustrated

Dissatisfied

Likely Satisfied

245

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 asked to plan or analyze, keep planning brief and move to implementation quickly. Don't over-deliberate — bias toward action unless explicitly asked for a detailed plan.

Multiple sessions show Claude getting stuck in planning loops until the user had to push it to proceed (e.g., '갑시다 진행').

Before making changes, always verify you're on the correct branch and working with the right version of the code. When debugging, kill stale processes and rebuild from clean state.

Multiple friction events involved analyzing wrong branches, stale binaries, and leftover processes that wasted significant debugging time.

Never overwrite or destroy existing content when updating external documents (Confluence, PR descriptions, etc.). Always preserve original content and make additive changes unless explicitly told to replace.

A session where Claude destroyed Confluence content during reorganization caused a not_achieved outcome and required recovery.

When reviewing code or PRs, avoid raising false critical issues. Verify assumptions about runtime behavior (e.g., React double-firing, hook behavior) before flagging as P0.

Claude raised an incorrect P0 about useEffect double-firing and made wrong critical findings in PR reviews, eroding trust.

This project uses TypeScript and Rust as primary languages. For TypeScript projects, use React Query patterns and React Hook Form where already established. Always run `tsc` after TypeScript changes.

TypeScript (2228 files) and Rust (1900 files) dominate the codebase, and multiple sessions involved React Query and RHF patterns.

When making code changes, avoid adding duplicate attributes/props that already exist and don't remove existing wiring (e.g., onSubmit handlers) without explicit instruction.

Friction events show Claude adding duplicate attributes and accidentally removing existing props, requiring rollbacks.

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

Custom Skills

Reusable prompt workflows triggered by a single /command

Why for you: Your top goals are git_operations (24), commit_and_push (15), and pr_creation_and_updates (8) — nearly half your sessions. A /commit and /pr skill would eliminate repetitive git workflows and pre-commit hook friction.

mkdir -p .claude/skills/commit && cat > .claude/skills/commit/SKILL.md << 'EOF'
# Commit Skill
1. Run `git diff --staged` to review changes
2. Generate a conventional commit message in English
3. Run `git commit` (use --no-verify only if hook makes no-op changes)
4. Push to current branch
EOF

mkdir -p .claude/skills/pr && cat > .claude/skills/pr/SKILL.md << 'EOF'
# PR Skill
1. Run `git log origin/main..HEAD --oneline` to summarize changes
2. Create PR with `gh pr create` using structured description
3. Never add unnecessary summary sections
EOF

Hooks

Auto-run shell commands at lifecycle events like after edits

Why for you: You have frequent tsc errors and lint issues after edits (multiple fix sessions). Auto-running type checks after TypeScript edits would catch errors immediately instead of discovering them later in CI.

// Add to .claude/settings.json
{
  "hooks": {
    "afterEdit": [
      {
        "match": "*.ts|*.tsx",
        "command": "npx tsc --noEmit --pretty 2>&1 | head -20"
      }
    ]
  }
}

MCP Servers

Connect Claude to external tools like Jira, GitHub, and Confluence

Why for you: You already use Figma and Google Workspace MCPs. Adding a Jira MCP would streamline your Jira task verification and bulk-update sessions, and a GitHub MCP would improve your frequent PR review and issue analysis workflows.

claude mcp add github -- npx -y @modelcontextprotocol/server-github
claude mcp add jira -- npx -y @anthropic/mcp-server-jira --base-url https://your-org.atlassian.net

New Ways to Use Claude Code

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

Break large refactoring into committed checkpoints

For multi-step refactoring sessions, commit after each logical phase instead of doing everything in one pass.

Several sessions show Claude making extensive changes across many files (commands.rs split, vitest upgrade, carousel migration) where issues compound. Your success rate is highest with multi_file_changes (24 successes) when changes are incremental. Committing checkpoints lets you revert specific phases rather than entire sessions, which would have helped with the Confluence content destruction and the scroll restoration migration.

Paste into Claude Code:

Let's implement this in phases. After each phase: run tests, show me the diff, and commit before moving to the next phase. Start with phase 1.

Front-load branch and environment verification

Always confirm the working branch and build state before starting investigation or changes.

Multiple friction events involved Claude analyzing the wrong branch, working with stale binaries, or debugging against incorrect code state. This wasted significant time in bug reproduction sessions (9 sessions) and debugging workflows. A simple verification step at session start would eliminate an entire class of friction.

Paste into Claude Code:

Before starting: 1) confirm which branch we're on with `git branch --show-current`, 2) show recent commits with `git log --oneline -5`, 3) ensure a clean build. Then proceed with the task.

Use explicit constraints for PR reviews

When requesting reviews, specify what severity levels to flag and require verification before raising critical issues.

Your code_review goal (19 sessions) is your second most common workflow, but friction includes false P0 findings and incorrect critical issues. Claude's eagerness to find problems leads to false positives that waste your time correcting. Constraining the review scope and requiring Claude to verify runtime assumptions before flagging would improve review quality significantly.

Paste into Claude Code:

Review this PR. Only flag issues you can verify from the code — don't speculate about runtime behavior. Categorize findings as: must-fix (with proof), nice-to-have, or question. No false alarms.

On the Horizon

With 255 sessions, 263 commits, and 1,501 hours of AI-assisted development across TypeScript and Rust codebases, this team is ready to shift from interactive pairing to autonomous, multi-agent workflows.

Autonomous CI Fix-and-Iterate Loops

Your top friction point is repeated CI failure cycles from version mismatches, test regressions, and stale binaries. Claude Code can autonomously run tests, diagnose failures, apply fixes, and re-run in a loop until green — no human babysitting required. With 300+ test suites and major upgrades like your vitest migration, this could cut multi-hour debugging cycles to minutes.

Getting started: Use Claude Code's Bash tool in a loop pattern, or spawn a sub-agent to handle the fix-test-retry cycle while you work on something else.

Paste into Claude Code:

Run the full test suite with `pnpm test`. For each failing test: read the test file and the source it tests, diagnose the root cause, apply a minimal fix, and re-run that specific test. Repeat until it passes, then re-run the full suite. If a fix causes new failures, revert it and try an alternative approach. Continue until all tests pass, then commit with a summary of what you fixed and why.

Parallel Agents for PR Review Pipeline

Code review and PR creation account for 27 of your top sessions, yet friction from wrong-branch analysis, incorrect critical findings, and excessive planning slows things down. You can spawn parallel sub-agents — one to verify correctness against tests, one to check for style/lint compliance, and one to validate against the linked GitHub issue — then merge their findings into a single actionable review.

Getting started: Use the Agent tool to spawn specialized sub-agents for each review dimension, then synthesize their outputs into a structured PR comment via GitHub CLI.

Paste into Claude Code:

Review PR #{{PR_NUMBER}} using parallel analysis. Spawn three sub-agents: (1) One that checks out the PR branch, runs `pnpm tsc --noEmit` and `pnpm test`, and reports any failures with root cause analysis. (2) One that reads every changed file and checks for excessive changes, naming inconsistencies, and dead code. (3) One that reads the linked GitHub issue and verifies every acceptance criterion is addressed by the diff. Collect all three reports, deduplicate findings, rank by severity, and post a structured review comment on the PR using `gh pr review`.

Bug Reproduction to Fix to PR Autonomously

Your most impactful sessions — like the CDP remote connection fix and per-tab RefMap isolation — follow a pattern: understand issue, reproduce bug, implement fix, iterate against tests, open PR. This entire pipeline can be a single autonomous workflow. Given that 9 sessions focused on bug reproduction and your best outcomes involved iterative refinement, letting Claude drive the full loop end-to-end will dramatically compress your fix cycle.

Getting started: Give Claude a GitHub issue URL and let it drive the full workflow using Bash, Read, Edit, and Grep tools with a clear exit criterion: all tests pass and a PR is opened.

Paste into Claude Code:

Fix GitHub issue #{{ISSUE_NUMBER}}. First, read the issue and all comments to fully understand the expected vs actual behavior. Then grep the codebase to find the relevant source files. Write a minimal failing test that reproduces the bug. Implement a fix, run the failing test to confirm it passes, then run the full test suite to check for regressions. If new tests fail, investigate whether your fix caused them and iterate. Once all tests pass, create a new branch named `fix/{{ISSUE_NUMBER}}`, commit your changes with a conventional commit message referencing the issue, push, and open a PR with: a summary of root cause, what you changed and why, and the test you added. Do not ask me any questions — make reasonable decisions and document your assumptions in the PR description.

"User got tired of Claude overthinking a Rust refactoring plan and just yelled '갑시다 진행!' (Let's go, proceed!) to snap it out of analysis paralysis"

During a session to split a large commands.rs file into separate modules, Claude got stuck in an endless loop of planning and asking clarifying questions. The user finally interrupted in Korean to force it to stop deliberating and just start coding.