Claude Code Insights

3,274 messages across 160 sessions (290 total) | 2026-02-25 to 2026-03-29

At a Glance

What's working: You've developed an impressive workflow where Claude functions as a full development partner — orchestrating parallel agents, managing GitFlow PRs with CI validation, and shipping real releases (v0.24 through v0.36) in single sessions. You also seamlessly blend deep systems engineering (subprocess migration, zombie process fixes) with polished content work (portfolio sites, resumes, blog posts), and you hold Claude accountable by verifying claims against actual source code. Impressive Things You Did →

What's hindering you: On Claude's side, first-pass outputs frequently contain bugs or inaccuracies — wrong file targets, misinterpreted project context, and data errors that pull you into lengthy correction loops. On your side, the heavy parallel agent workflows you favor regularly break down due to permission gaps, lost worktree changes, and merge conflicts, suggesting the setup needs more guardrails before launch rather than cleanup after. Where Things Go Wrong →

Quick wins to try: Try creating Custom Skills (slash commands) for your most repeated workflows — like a `/pr-flow` that handles branch creation, CI check, and merge in sequence, or a `/verify-metrics` that cross-references portfolio claims against source files. You could also set up Hooks to auto-run your test suite or linting before every commit, which would catch the buggy first drafts that currently dominate your friction. Features to Try →

Ambitious workflows: As models get more capable, your parallel agent pattern could evolve into a true agent swarm — a coordinator that partitions refactoring by module boundaries, assigns isolated branches to sub-agents, and handles conflict resolution and merge automatically. Your portfolio and resume sessions (often 20-50 revision rounds) are also prime candidates for an autonomous pipeline that reads your codebase metrics, validates every claim against source files, and self-reviews rendered output before presenting a final draft. On the Horizon →

3,274

Messages

+149,368/-15,435

Lines

1907

Files

Days

131

Msgs/Day

What You Work On

GEODE Agent Framework Development ~30 sessions

Core development of the GEODE agentic loop framework in Python, including major architectural refactors (thread-to-subprocess migration, SharedServices, ContextVars), scheduler bug fixes, sub-agent execution, prompt redesign, domain plugin architecture, and multi-phase release management (v0.24–v0.36). Claude Code was used heavily for multi-file refactoring, parallel agent workflows, CI-guarded GitFlow PRs, and running thousands of tests.

Portfolio & Resume Preparation ~20 sessions

Iterative creation and refinement of HTML resumes, cover letters, and a multi-section portfolio website targeting companies like Toss, Coupang, and NAVER. Claude Code was used for extensive HTML/CSS editing, content accuracy verification against source code, print optimization, deployment, and dozens of revision rounds with styling and factual corrections.

Technical Blog Writing & Research ~15 sessions

Writing blog posts on development scaling approaches, MoE architectures, Claude Code vs OpenClaw comparisons, and agent/RAG paradigm analysis, plus research on harness ecosystem trends, AI job postings, and academic papers like TurboQuant. Claude Code handled parallel research agents, LaTeX-to-unicode conversion, content drafting with iterative factual and stylistic corrections, and markdown file management.

Architecture Design & Planning ~8 sessions

Strategic planning sessions covering CLI/agent tooling best practices, 3-layer hybrid architecture with DAG-based task automation, ADR creation, migration roadmaps, and production-grade agent development plans. Claude Code was used for web research, document generation, comparative analysis, and structured planning artifacts.

DevOps & System Maintenance ~5 sessions

Infrastructure teardown of K8s/AWS via Terraform (destroying 109+ resources), disk cleanup recovering ~32GB from Cursor cache, OBS Studio installation, and storage management for video recording workflows. Claude Code handled Bash-heavy operations for system analysis, terraform destroy iterations, and tool installation.

What You Wanted

Bug Fix

Visualization Design

Content Editing And Refinement

Content Editing

Feature Implementation

Factual Correction

Top Tools Used

Bash

12517

Read

5235

Edit

4591

Grep

1673

Agent

1085

Write

882

Languages

Python

4447

Markdown

3447

HTML

1466

TypeScript

590

JSON

116

Shell

Session Types

Multi Task

Iterative Refinement

Single Task

Exploration

Quick Question

How You Use Claude Code

You are a power user who runs Claude Code as a continuous development engine, often across marathon sessions (some exceeding 15 hours) with heavy reliance on parallel agent workflows and multi-PR pipelines. Your interaction style is highly directive and iterative — you provide architectural plans, phased task lists, and kanban-style work queues, then let Claude execute across multiple files and branches simultaneously. With 12,500+ Bash calls and 1,085 Agent invocations across 160 sessions, you clearly prefer to orchestrate Claude as a fleet of sub-agents rather than doing granular work yourself. You commit aggressively (820 commits in ~30 days), treating Claude as a full CI/CD partner that handles everything from code refactoring to blog writing to resume polishing.

Your correction patterns reveal someone who trusts Claude to run but verifies ruthlessly. You frequently catch factual inaccuracies — wrong project attributions, hallucinated metrics, misplaced content between projects like GEODE and 이코에코 — and push back immediately. You've built a workflow where parallel inspection agents audit Claude's own output, and you use real API key verification to validate implementations rather than accepting test-only confirmation. When Claude goes off-track (investigating irrelevant 500 errors, editing the wrong file, using prohibited expressions like em-dashes or '수준의'), you redirect sharply. The 60 buggy-code friction events and 32 misunderstood-request incidents show you're willing to absorb significant rework cycles as the cost of moving fast with autonomous agents.

Your work spans two distinct modes: deep engineering sessions (subprocess refactoring, scheduler fixes, context compaction) where you drive multi-wave releases (v0.24→v0.36), and meticulous content refinement sessions (resumes, portfolios, blog posts) where you iterate 17-50+ versions with granular corrections. In both modes, you prefer Claude to act first and correct later rather than plan exhaustively upfront. You've also adopted Claude for non-coding tasks like storage cleanup, OBS setup, and infrastructure teardown — treating it as a general-purpose operations assistant across your entire workflow.

Key pattern: You operate Claude as an autonomous multi-agent development platform, dispatching parallel workstreams and verifying outputs through inspection agents and CI pipelines rather than reviewing individual steps.

User Response Time Distribution

2-10s

174

10-30s

331

30s-1m

392

1-2m

490

2-5m

489

5-15m

360

>15m

189

Median: 94.2s • Average: 277.1s

Multi-Clauding (Parallel Sessions)

238

Overlap Events

134

Sessions Involved

55%

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)

236

Afternoon (12-18)

1362

Evening (18-24)

1047

Night (0-6)

629

Tool Errors Encountered

Command Failed

1150

Other

362

File Not Found

File Changed

File Too Large

User Rejected

Impressive Things You Did

You're a power user running 160 sessions over one month with an impressive 92% goal achievement rate, leveraging Claude Code extensively for agent development, content creation, and job application preparation.

Parallel Agent Orchestration at Scale

You consistently deploy multiple parallel sub-agents for complex tasks — from running 3 simultaneous quality inspection agents to executing 5 parallel refactoring tracks across 9 PRs. This pattern lets you compress massive engineering efforts like full releases (v0.24.0 through v0.36.0) into single sessions with thousands of passing tests.

CI-Guarded GitFlow Development Pipeline

You've built a disciplined development workflow where every change goes through proper branching, PR creation, CI validation, and merge cycles — all orchestrated through Claude. Your 820 commits across 160 sessions show you're treating Claude as a full development partner with production-grade rigor, not just a code generator.

Cross-Domain Content and Code Integration

You seamlessly switch between deep systems work (subprocess-based sub-agent refactoring, async drain implementation, zombie process fixes) and polished content creation (portfolio sites, blog posts, resumes, cover letters). You verify technical claims against actual source code, ensuring your portfolio materials stay grounded in real metrics and architecture details.

What Helped Most (Claude's Capabilities)

Multi-file Changes

Good Debugging

Proactive Help

Good Explanations

Correct Code Edits

Fast/Accurate Search

Outcomes

Partially Achieved

Mostly Achieved

Fully Achieved

Where Things Go Wrong

Your high-volume workflow suffers most from buggy initial implementations requiring rework, Claude taking wrong approaches or misunderstanding your intent, and operational friction with sub-agents and tooling.

Buggy First Drafts Requiring Iterative Fixes

Your code and content frequently ships with bugs or inaccuracies on the first pass, forcing you into correction loops. You could reduce this by asking Claude to self-verify outputs against source data before presenting them, or by requesting explicit test runs before committing.

Initial scoring implementation had final_score/tier always returning 0.0/empty because it read from the wrong source — only caught by parallel inspection agents after the fact
Calibrator failed during real API testing due to markdown fence handling and wrong Claude model ID, meaning the code was never actually validated before being presented as complete

Misunderstood Requests and Wrong Targets

Claude frequently misinterprets which file, project, or concept you're referring to, leading to wasted edits. You could mitigate this by specifying exact file paths and project names upfront, or by asking Claude to confirm its understanding before making changes.

Claude applied GEODE corrections to cover letter .txt files instead of the resume HTML you intended, requiring a follow-up correction cycle
Claude misunderstood '화면 잘라서 쓰려면' as timeline cutting (Razor Tool) when you meant cropping/zooming, derailing the guidance you needed

Sub-Agent and Parallel Workflow Breakdowns

Your heavy use of parallel agents frequently hits permission issues, lost work, and merge conflicts that require manual intervention. You could improve reliability by pre-configuring sub-agent permissions in your workflow and adding post-merge verification steps before worktree cleanup.

Sub-agents consistently lacked git/bash permissions requiring manual intervention, and CI GitHub Actions quota was exhausted mid-session during sequential PR merges
Agent 1's worktree changes were silently lost and never merged into main, leaving runtime wiring incomplete — only discovered during a final plan audit

Primary Friction Types

Buggy Code

Wrong Approach

Misunderstood Request

Excessive Changes

Hallucinated Data

Subagent Permission Issues

Inferred Satisfaction (model-estimated)

Frustrated

Dissatisfied

Likely Satisfied

284

Satisfied

150

Existing CC Features to Try

Suggested CLAUDE.md Additions

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

When editing resume/portfolio HTML files, always confirm which specific file (HTML vs TXT vs cover letter) the user wants modified before making changes. Never apply edits to the wrong document type.

Multiple sessions show Claude editing the wrong file (e.g., cover letter instead of resume HTML, wrong project section), causing repeated friction.

Never use em-dashes (—), '수준의', or other expressions the user has previously rejected. Maintain a running list of prohibited expressions and check before outputting.

User repeatedly corrected Claude for using prohibited expressions and anti-patterns like double-colons and em-dashes across multiple resume/blog sessions.

When spawning sub-agents for parallel work, ensure they have git and bash permissions. Use `--allowedTools` flags proactively. After worktree-based parallel work, always verify changes were actually merged into the target branch before cleanup.

Sub-agent permission issues and lost worktree changes appeared in 5+ sessions, causing significant overhead and even lost work.

Always write output files to disk immediately after generating content. Do not wait for the user to ask 'did you save it?'

Multiple sessions show Claude forgetting to write files or missing files in commits, requiring user follow-up.

When editing portfolio/resume content, cross-reference all metrics, version numbers, and project descriptions against source code (SOT). Never fabricate metrics — if data isn't in SOT, ask the user.

Recurring friction with incorrect metrics, version numbers, and project details across portfolio and resume sessions required constant user correction.

Default to Korean for explanations and content unless explicitly asked for English. The user's primary working language for documents is Korean.

Claude defaulted to English when the user expected Korean, and most content work (resumes, blogs, cover letters) is in Korean.

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: You have highly repetitive workflows — resume refinement, blog post writing, portfolio deployment, and PR merge cycles. A /resume-check skill could enforce your style rules (no em-dashes, verify metrics against SOT) and a /pr-merge skill could automate your GitFlow merge+CI pattern.

mkdir -p .claude/skills/resume-check && cat > .claude/skills/resume-check/SKILL.md << 'EOF'
# Resume Check Skill
1. Identify the target HTML file - confirm with user before editing
2. Check all metrics against source code files
3. Verify no prohibited expressions: em-dashes, 수준의, double-colons
4. Ensure Korean language throughout
5. Run a final diff summary before committing
EOF

Hooks

Auto-run shell commands at lifecycle events like pre-commit

Why for you: You hit pre-commit hook failures (mypy/bandit cache artifacts) and missed-file-in-commit issues repeatedly. A post-edit hook that auto-runs linting and a pre-commit hook that checks for unstaged files would catch these automatically.

// Add to .claude/settings.json
{
  "hooks": {
    "postToolUse": [{
      "matcher": "Edit|Write",
      "command": "if [[ \"$CLAUDE_FILE\" == *.py ]]; then ruff check \"$CLAUDE_FILE\" --fix; fi"
    }],
    "preCommit": [{
      "command": "git status --porcelain | grep '??' && echo 'WARNING: untracked files detected' || true"
    }]
  }
}

Headless Mode

Run Claude non-interactively for batch tasks

Why for you: You run parallel quality inspection agents and batch translation tasks (69 files Korean→English). Headless mode would let you script these as batch jobs instead of managing them interactively.

claude -p "Translate all .md files in docs/ko/ from Korean to English, preserving formatting. Write outputs to docs/en/" --allowedTools "Read,Write,Bash,Grep" --output-format json

New Ways to Use Claude Code

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

Pre-flight file confirmation for content edits

Before any resume/portfolio edit, explicitly state which file you're about to modify and ask Claude to confirm.

Across your 25+ content editing sessions, a recurring friction point is Claude editing the wrong file — cover letter instead of resume HTML, or mixing up project sections. This wastes rounds of correction. Starting each content session with a clear file target eliminates this. Your 60 buggy_code and 32 misunderstood_request friction events are partly driven by this.

Paste into Claude Code:

I want to edit my resume. The target file is ONLY `portfolio/resume-toss.html`. Do NOT touch any .txt or cover letter files. Confirm you understand before proceeding.

Sub-agent permission pre-check

When launching parallel agents, include an explicit permissions and verification checklist.

You use Task Agents heavily (1085 Agent tool calls) but hit sub-agent permission issues in 5+ sessions and lost work from worktree cleanup. Adding a verification step after parallel work ensures nothing is lost. This is especially critical for your GitFlow multi-PR sessions where merge conflicts compound the problem.

Paste into Claude Code:

Launch 3 parallel agents for these tasks. IMPORTANT: Each agent MUST have git and bash access. After all agents complete, verify every agent's changes are merged into the target branch by running `git log --oneline -10` and checking for each agent's commits before any worktree cleanup.

Metrics verification against source of truth

Always require Claude to cite the exact file and line number when claiming a metric or version number.

Your portfolio and resume sessions frequently required correcting fabricated or outdated metrics (test counts, version numbers, TPM values). With 7 hallucinated_data events and extensive factual correction sessions, requiring source citations would catch errors before they reach the final document. This applies to your GEODE portfolio, blog posts, and cover letters.

Paste into Claude Code:

Update the metrics in my portfolio page. For EVERY number you write (test count, version, lines of code, etc.), show me the exact file path and command you used to verify it. If you can't find it in the codebase, flag it and ask me.

On the Horizon

With 1,552 hours across 160 sessions and heavy use of parallel agents, this workflow is ready to evolve from human-directed orchestration to fully autonomous development pipelines.

Self-Healing CI with Autonomous Bug Fix Loops

Your top friction source is buggy code (60 incidents), yet your parallel inspection agents already catch issues effectively. An autonomous loop could run tests, diagnose failures, apply fixes, and re-validate without human intervention — turning your 32-session bug fix pattern into a zero-touch pipeline that self-corrects until CI is green.

Getting started: Use Claude Code's sub-agent spawning with a bash loop that runs pytest, feeds failures back to Claude, and iterates until all tests pass.

Paste into Claude Code:

You are an autonomous bug-fix agent. Run the full test suite with `pytest --tb=short`. For each failure: 1) Read the failing test and source file, 2) Diagnose the root cause, 3) Apply the minimal fix via Edit, 4) Re-run only the affected test to confirm. Repeat until the full suite passes with 0 failures. Do NOT ask for permission — auto-accept all changes. After all tests pass, run the full suite one final time and report a summary of every fix applied with file paths and one-line descriptions.

Parallel Agent Swarm for Multi-PR Refactors

You already run parallel agents (1,085 Agent tool calls) but hit merge conflicts and lost worktree changes. A structured swarm pattern — where a coordinator agent partitions work by module boundaries, each sub-agent works on an isolated branch, and a final agent resolves conflicts and merges — could eliminate the friction that cost you hours across sessions like your 9-PR Wave 1 release.

Getting started: Use Claude Code's Agent tool with git worktrees, assigning each sub-agent a specific directory scope and branch naming convention to prevent conflicts.

Paste into Claude Code:

You are a refactoring coordinator. The goal is: [DESCRIBE REFACTOR]. Step 1: Analyze the codebase and partition the work into N independent tracks, each scoped to non-overlapping directories. Step 2: For each track, spawn a sub-agent with these instructions: 'Work ONLY in [directory scope]. Create branch refactor/track-N. Make all changes, run tests for your scope, commit with conventional commits.' Step 3: After all agents complete, create a fresh integration branch, merge each track branch sequentially, run the full test suite after each merge, and fix any integration issues. Step 4: Create a single PR with a summary table of all changes per track. Report any conflicts encountered and how they were resolved.

Autonomous Portfolio and Content Generation Pipeline

You spent 25+ sessions on visualization design and 46 on content editing — often iterating 20-50 rounds to fix data accuracy, styling regressions, and factual errors against source code. An autonomous pipeline that reads your actual codebase metrics, validates claims against source of truth files, and self-reviews rendered output could compress these marathon sessions into single-prompt deployments.

Getting started: Use Claude Code to build a generate-validate-fix loop that greps your codebase for real metrics, renders HTML, and uses the chrome MCP tool to visually verify output.

Paste into Claude Code:

You are an autonomous portfolio generator. Step 1: Read all source files in [PROJECT_DIR] and extract real metrics: test count (grep for test_ functions), lines of code (find + wc), version (from pyproject.toml or package.json), key architectural patterns. Store these as verified facts in a JSON scratchpad. Step 2: Generate the portfolio HTML section using ONLY verified facts — never hallucinate numbers. Step 3: Self-review by reading the generated HTML and cross-checking every metric/claim against your scratchpad. Flag and fix any discrepancy. Step 4: Deploy to [deploy target]. Step 5: Output a verification table with columns: Claim | Source File | Verified Value | Status. If any claim cannot be grounded to source code, remove it and note why.

"Claude forgot to actually save the file after writing an entire comparative analysis, and had to be reminded by the user"

During a session comparing Claude Code vs OpenClaw agent architectures, Claude produced a full blog-ready markdown analysis but never wrote it to disk — the user had to ask 'did you actually save that?' to get Claude to commit it to a file.