# Claude Code Insights

722 messages across 144 sessions (343 total) | 2026-01-14 to 2026-02-12

At a Glance
What's working: You've developed a strong pattern of using Claude as a full-stack scaffolding engine — generating entire multi-page UIs (like the QuickIOT admin panel) and orchestrating parallel agents to deliver complete features with backend, frontend, and navigation in a single session. Your iterative ML notebook workflow is also impressive, where you treat Claude as a research engineering partner and refine notebooks through multiple targeted rounds of additions like timing metrics, few-shot validation, and t-SNE visualization. Impressive Things You Did →
What's hindering you: On Claude's side, buggy generated code is your biggest pain point — type mismatches, incorrect loss math, and incompatible library parameters keep requiring multiple fix rounds, especially in ML work. On your side, several sessions stall because Claude falls into exploration-and-planning loops without ever writing code, and there's no guardrail stopping it from trying to build or run projects in environments where the required tools aren't installed (like MAUI via WSL). Where Things Go Wrong →
Quick wins to try: Create a custom `/implement` skill that instructs Claude to skip exploration, accept a plan as input, and go straight to writing code — this would eliminate your plan-only sessions. Also add environment constraints to your CLAUDE.md for each project (e.g., "Do not attempt to build MAUI projects" or "Do not run Python scripts, just generate code") so Claude stops making wrong assumptions about what it can execute. Features to Try →
Ambitious workflows: As models get better at self-correction, try having Claude embed validation checkpoints directly into ML notebooks — shape assertions, loss sanity checks, dtype verification — so it can catch bugs like the NaN loss or embedding collapse autonomously before you ever run a cell. You should also prepare to scale your parallel-agent pattern to every feature, with dedicated agents for API, UI, and tests running simultaneously against shared interface contracts, turning what you did for the Employees KPI feature into your default workflow. On the Horizon →
722
Messages
+64,063/-1,090
Lines
458
Files
20
Days
36.1
Msgs/Day

## What You Work On

IoT Admin Panel & Platform Architecture ~3 sessions
Development of a QuickIOT dark tech admin panel UI with 6 interconnected pages (dashboard, devices, OTA, alarms, provisioning) and architectural brainstorming for a ThingsBoard replacement IoT system. Claude Code was used to generate complete multi-page HTML/CSS UIs and facilitate structured product architecture brainstorming sessions with product brief creation.
ML/CV Model Training & Evaluation Notebooks ~18 sessions
Extensive work on machine learning pipelines for candy detection and classification, including CenterNet training, ResNet-18 with supervised contrastive loss, few-shot learning, ONNX export/evaluation, and embedding-based classification. Claude Code generated Jupyter notebooks, debugged training issues (NaN losses, embedding collapse, device type errors), added t-SNE visualization, and iteratively refined timing metrics and evaluation workflows. This was the most friction-heavy area, with buggy generated code and multiple debugging rounds being common.
Receipt Template Engine Development ~12 sessions
Design and implementation of an XML-based receipt template engine in .NET, including col/row tag percentage-based width support, word wrap features, HtmlPrinter refactoring into a builder pattern, and creation of a template test project. Claude Code was used for codebase analysis, architecture reviews, planning, and multi-file refactoring with test verification, though several sessions stalled in plan mode without reaching implementation.
MAUI Blazor Template Editor Application ~10 sessions
Building a MAUI Blazor Hybrid template editor with Monaco code editing, split-pane layout, live preview pipeline, file operations (New/Open/Save), syntax highlighting, code completion, and keyboard hotkeys. Claude Code scaffolded the full project and implemented features across multiple files, but encountered significant friction with BlazorMonaco API compatibility, NuGet package versioning for .NET 10, and WSL build environment limitations for Windows MAUI projects.
Blazor Employees KPI Feature & Backend ~7 sessions
Full-stack implementation of an Employees KPI tracking feature in a Blazor application, including PRD creation, UI design reference pages, state management (AppState pattern refactoring), API endpoints in AssigneesController, and Blazor components with models. Claude Code was used for requirements gathering, parallel backend/frontend agent coordination, multi-file code generation following existing patterns, and an HTTP polling job source as a SignalR alternative.
What You Wanted
Feature Implementation
10
Feature Addition
7
Code Generation
6
Debug Runtime Error
6
Bug Fix
5
Build Error Fixing
5
Top Tools Used
Read
811
Bash
452
Write
389
TaskUpdate
298
Edit
294
Glob
231
Languages
Markdown
428
HTML
77
Python
61
JSON
24
CSS
13
YAML
11
Session Types
Single Task
24
Iterative Refinement
19
Exploration
3
Quick Question
2
Multi Task
2

## How You Use Claude Code

You are a prolific, multi-domain power user who drives Claude through a wide variety of projects — IoT admin panels, Blazor enterprise apps, PyTorch/ONNX ML notebooks, and template engines — across 144 sessions in just 30 days. Your interaction style is characterized by giving Claude ambitious, multi-file implementation tasks and expecting it to run with them. You lean heavily on the Task/TaskCreate/TaskUpdate system (639 combined uses), showing you've adopted a parallel agent orchestration approach where you dispatch sub-agents for backend, frontend, and other concerns simultaneously. When things go well, Claude delivers impressive multi-file changes (your top success pattern at 18 instances), and you're clearly satisfied — 68 out of 81 rated sessions show likely satisfaction. However, your sessions reveal a recurring tension: you want Claude to execute, not explore, and you frequently get frustrated when it spends too long in plan mode or excessive codebase reading instead of writing code.

Your friction patterns tell a vivid story. The most common issue is buggy code from Claude (17 instances), followed by wrong approach (12 instances) — things like Claude trying to build a Windows MAUI project in WSL, attempting to run scripts without required libraries, or modifying Program.cs when you just wanted JSON extracted from a method. You interrupt Claude decisively when it goes off track: cutting off excessive exploration, stopping it from running bash commands you'd rather do yourself, and redirecting it from over-planning back to implementation. Multiple sessions show Claude stuck in "plan mode" — reading files, writing plans, revising plans — without ever producing code, which clearly frustrates you. Your iterative debugging style is notable in the ML notebook sessions, where you'll push through multiple rounds of fixes (like the NaN loss saga requiring three attempts) rather than abandoning the approach. You tend to provide detailed upfront specs (PRDs, 6-page UI layouts, multi-file implementation plans) but expect Claude to fill in the technical details autonomously, correcting course only when it makes environment assumptions or picks wrong package versions.

Key pattern: You are a high-throughput orchestrator who dispatches ambitious multi-file tasks with detailed specs and expects immediate execution, frequently interrupting Claude when it over-explores or plans instead of writing code.
User Response Time Distribution
2-10s
14
10-30s
29
30s-1m
31
1-2m
41
2-5m
48
5-15m
37
>15m
18
Median: 112.1s • Average: 288.5s
Multi-Clauding (Parallel Sessions)
4
Overlap Events
5
Sessions Involved
2%
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)
244
Afternoon (12-18)
339
Evening (18-24)
102
Night (0-6)
37
Tool Errors Encountered
Command Failed
62
User Rejected
45
Other
44
File Too Large
24
File Not Found
13
File Changed
1

## Impressive Things You Did

Over the past month, you've driven 144 sessions across IoT platforms, ML pipelines, and .NET development, showing a strong command of Claude Code for complex, multi-file engineering work.

Full-Stack IoT UI Generation
You've leveraged Claude to scaffold entire multi-page admin panels and web UIs end-to-end — like the 6-page QuickIOT dark tech dashboard and the USB key configuration UI across 6 files. Your ability to describe a cohesive design vision and let Claude generate consistent, cross-linked pages shows a highly effective approach to rapid UI prototyping.
Iterative ML Notebook Development
You've built a sophisticated workflow for developing and refining ML notebooks — from PyTorch CNN classifiers to CenterNet+ArcFace pipelines, contrastive learning, and ONNX evaluation. You drive each notebook through multiple rounds of targeted refinement (adding timing metrics, few-shot validation, t-SNE visualization), treating Claude as a collaborative research engineering partner rather than a one-shot code generator.
Parallel Agent Feature Delivery
You orchestrated a full Employees KPI feature using parallel backend and frontend agents plus navigation integration and bug fixes, all within a single coordinated effort. Your heavy use of Task/TaskCreate/TaskUpdate tools (over 600 combined calls) shows you've mastered Claude's sub-agent orchestration to break complex features into concurrent workstreams, dramatically accelerating multi-file, full-stack feature delivery.
What Helped Most (Claude's Capabilities)
Multi-file Changes
18
Correct Code Edits
13
Proactive Help
6
Good Explanations
4
Good Debugging
3
Fast/Accurate Search
1
Outcomes
Not Achieved
2
Partially Achieved
15
Mostly Achieved
16
Fully Achieved
17

## Where Things Go Wrong

Your sessions are heavily impacted by Claude spending too long in exploration/planning without producing code, generating buggy outputs that require multiple fix cycles, and making incorrect assumptions about your development environment.

Excessive Planning Without Implementation
You're losing significant time to sessions where Claude gets stuck in exploration and plan-writing loops, never actually producing code. Consider giving Claude explicit instructions to limit planning to a brief outline and move directly to implementation, or interrupt earlier when you see it reading too many files without writing any.

- Multiple sessions (col tag support, refactoring HtmlPrinter, template editor preview) ended with only plan documents written and zero code changes, wasting entire sessions on deliverables you couldn't use
- Claude was interrupted twice in one session for excessive codebase exploration when you wanted it to move faster to planning, and in another session it spent the entire time making repeated ExitPlanMode calls without ever writing implementation code

Buggy Generated Code Requiring Multiple Fix Rounds
Your most frequent friction point (17 instances) is Claude producing code with bugs ranging from type errors to incorrect loss function math. You could reduce this by asking Claude to add simple validation checks or test cells inline, and by specifying known constraints (e.g., PyTorch dtype behavior, library versions) upfront in your prompts.

- A CenterNet+ArcFace notebook had four separate bugs—glob picking up non-image files, torch.sin on a plain float, weights_only incompatibility, and incorrect loss weighting causing embedding collapse—requiring multiple debugging rounds before the core approach even worked
- Claude's first two NaN loss fixes (autocast disable, F.normalize float cast) were wrong; it took a third iteration to identify the actual 0 * -inf = NaN root cause, burning debugging time on incorrect hypotheses

Wrong Environment Assumptions and Unauthorized Execution
Claude repeatedly tried to build or run code in your environment without checking whether the necessary tools, SDKs, or libraries were available—particularly problematic for your MAUI/Windows projects accessed via WSL. You should add environment constraints to your CLAUDE.md (e.g., 'Do not attempt to build MAUI projects; just generate code') so Claude stops making these mistakes.

- Claude attempted to build a Windows MAUI Blazor project inside WSL where MAUI workloads weren't installed, and used an incompatible NuGet package version (11.1.0 instead of 13.0.0 for .NET 10), causing build failures you had to manually diagnose and correct
- Claude tried to run Python scripts and ONNX exports in the environment despite missing required libraries, forcing you to interrupt multiple times and clarify that it should only generate the code, not execute it

Primary Friction Types
Buggy Code
17
Wrong Approach
12
User Rejected Action
4
Misunderstood Request
2
Missing Information
1
Environment Issue
1
Inferred Satisfaction (model-estimated)
Dissatisfied
12
Likely Satisfied
60
Satisfied
8

## Existing CC Features to Try

### Suggested CLAUDE.md Additions

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

`Do NOT attempt to build or run .NET MAUI projects in WSL. MAUI workloads are only available on Windows. If a build/test is needed, ask the user to run it and report results.`
Multiple sessions had friction where Claude tried to build MAUI projects in WSL, wasting time and requiring user correction.
`When working on Jupyter notebooks or Python ML scripts, do NOT attempt to run them or execute bash commands to test them. Generate the code only and let the user run it in their own environment with the required libraries.`
Across many ML/notebook sessions, Claude tried to run scripts without required libraries installed, causing interruptions and user frustration.
`Prefer implementation over planning. Do NOT spend entire sessions exploring and writing plan files without producing code. If a plan is needed, keep it brief (under 50 lines) and move to implementation immediately. If you need clarification, ask ONE focused question rather than exploring extensively.`
At least 6-7 sessions ended with only a plan written and no code implemented, which was the single biggest source of 'partially_achieved' outcomes and user dissatisfaction.
`For .NET projects: the solution targets .NET 10. Use compatible NuGet package versions. Do not downgrade to older framework-incompatible versions without asking.`
Claude used wrong NuGet package versions (e.g., 11.1.0 instead of 13.0.0) causing build errors that required user intervention to debug.
`When the user asks for a specific code change or feature, do NOT start with extensive codebase exploration. Read only the files directly relevant to the task. If you find yourself reading more than 5-6 files before writing code, stop and start implementing.`
Multiple sessions had friction from excessive exploration — users interrupted Claude to skip exploration and get to actual work.

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

Custom Skills
Reusable prompts that run with a single /command for repetitive workflows.
Why for you: You create Jupyter notebooks frequently (eval notebooks, training notebooks, classification notebooks) with a consistent pattern: explore dataset → write notebook → add timing/visualization cells. A /notebook skill would encode your preferred structure, avoid the excessive exploration phase, and ensure Claude jumps straight to implementation.
`mkdir -p .claude/skills/notebook && cat > .claude/skills/notebook/SKILL.md << 'EOF' # Notebook Creation Skill ## Instructions 1. Do NOT run any bash commands to test the notebook 2. Do NOT spend time exploring — ask the user for dataset path and model details upfront 3. Create the .ipynb file directly with these standard sections: - Imports and setup - Dataset loading with configurable paths - Model definition - Training loop with loss logging - Evaluation with per-class metrics - Visualization (confusion matrix, t-SNE if embedding-based) - Timing metrics (load time, inference time, total time) 4. Include pip install cells at the top for all dependencies 5. Use float32 by default to avoid NaN issues with mixed precision EOF`
Custom Skills
A /implement skill to force Claude to skip excessive planning and go straight to code.
Why for you: Your biggest friction pattern is sessions that end with only a plan file and no code. A /implement skill would set explicit guardrails: brief plan (max 20 lines in a code comment), then immediate implementation.
`mkdir -p .claude/skills/implement && cat > .claude/skills/implement/SKILL.md << 'EOF' # Implement Skill ## Instructions 1. Read ONLY the files directly mentioned or obviously required (max 5 files) 2. Write a brief implementation plan as a comment block (max 20 lines) in the first file you edit 3. Immediately begin writing code — do NOT create separate plan files 4. If you need clarification, ask ONE specific question, then proceed with your best assumption 5. After implementation, list what you changed and any assumptions made 6. Do NOT attempt to build or run the project unless explicitly asked EOF`
Hooks
Shell commands that auto-run at specific lifecycle events to enforce conventions.
Why for you: You work on .NET projects where build errors from wrong package versions and environment issues were recurring friction. A pre-commit or post-edit hook could auto-validate .csproj files for correct target framework and package version compatibility.
`# Add to .claude/settings.json: { "hooks": { "postToolUse": [ { "matcher": "Write|Edit", "hooks": [ { "type": "command", "command": "if echo \"$CC_TOOL_INPUT\" | grep -q '.csproj'; then grep -l 'net10' $(echo \"$CC_TOOL_INPUT\" | grep -o '[^ ]*.csproj') 2>/dev/null && echo 'Reminder: Verify NuGet packages are compatible with .NET 10'; fi" } ] } ] } }`

## New Ways to Use Claude Code

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

Break large features into implementation-first sessions
Instead of asking Claude to plan and implement in one session, give it the plan upfront and ask it to implement directly.
About 30% of your sessions ended as 'partially_achieved' — and the majority of those were sessions where Claude spent all its time exploring and planning without writing code. When you provided a detailed plan upfront (like the Employees KPI feature or the USB key config UI), outcomes were consistently 'fully_achieved' and rated 'essential'. Front-loading the plan yourself or in a prior session, then handing Claude a concrete implementation task, dramatically improves results.
Paste into Claude Code:
`Here is the implementation plan (attached/below). Implement all changes now. Do not create a separate plan file. Do not explore the codebase beyond what's needed to write the code. Start with [specific file] and work through each item.`
Specify environment constraints upfront for ML work
Always tell Claude your execution environment and what it should NOT try to run.
Your ML notebook sessions had repeated friction from Claude trying to run code (ONNX exports, dataset inspection, pip installs) in an environment without the required libraries. The sessions that went smoothly were ones where Claude just generated the notebook code. Adding a single line about execution constraints at the start of ML prompts would eliminate this entire friction category, which accounted for roughly a third of your buggy_code friction events.
Paste into Claude Code:
`Create a Jupyter notebook for [task]. Important: Do NOT run any cells or bash commands. Just generate the .ipynb file. Include pip install cells at the top. I will run it locally where I have GPU and all libraries installed.`
Use parallel Task agents for multi-file features (you already benefit from this)
Continue leveraging Task agents for cross-cutting features, but give each agent explicit file boundaries.
Your top tools show heavy Task/TaskCreate/TaskUpdate usage (182/159/298 calls), and your most successful sessions ('essential' rated) like the Employees KPI feature used parallel agents for backend and frontend. However, one session had a frontend agent reference a parameter that didn't exist on a component, suggesting agents need tighter scoping. Specifying which files each agent should read and modify prevents cross-agent inconsistencies.
Paste into Claude Code:
`Implement this feature using parallel agents: Agent 1 (Backend): modify only Controllers/ and Models/ files. Read Services/ for reference but don't change them. Agent 2 (Frontend): modify only Pages/ and Components/ files. Use only existing component parameters — read the component files first to check available parameters before using them.`

## On the Horizon

Your 144 sessions reveal a power user pushing Claude Code toward complex multi-file implementations and ML experimentation, but significant friction from excessive planning, wrong environments, and buggy first attempts points to massive gains from more autonomous, test-driven workflows.

Eliminate Plan-Only Sessions With Test-Gated Implementation
Nearly a third of your sessions ended with only a plan written and no code delivered—this is your single biggest efficiency leak. By giving Claude a failing test suite or acceptance criteria upfront, you can force it to iterate against concrete validation rather than endlessly exploring and replanning. Imagine every feature request automatically producing working, tested code in a single session instead of requiring a follow-up.
Getting started: Use Claude Code's headless mode or the /run command with a pre-written test file so Claude has a clear 'done' signal. Add a CLAUDE.md instruction like 'Never spend more than 2 minutes planning—write a failing test first, then implement until it passes.'
Paste into Claude Code:
`I need you to implement [FEATURE DESCRIPTION]. Do NOT write a plan document. Instead: 1) Write a failing test that validates the feature works correctly, 2) Implement the minimum code to make the test pass, 3) Run the test and iterate until green, 4) Only then refactor. If you're unsure about architecture, write multiple small tests that encode your assumptions rather than exploring files. Skip exploration of files unless a test failure tells you something is missing. Show me the test output at each iteration.`
Parallel Agents for Backend-Frontend Feature Delivery
Your Employees KPI session proved that parallel Task agents can deliver a full-stack feature in one shot—backend endpoints, frontend components, navigation, and bug fixes all at once. With 18 successful multi-file change sessions already under your belt, you could scale this to every feature by spawning dedicated agents for API layer, UI components, and integration tests running simultaneously. This could cut your feature delivery time by 60% while catching interface mismatches (like the missing CssClass parameter) through shared contract definitions.
Getting started: Use Claude Code's Task tool to spawn parallel sub-agents, each with a specific scope and a shared interface contract (e.g., a TypeScript type or C# interface). Define the contract first in your prompt, then let agents implement against it independently.
Paste into Claude Code:
`Implement this feature using parallel agents with a shared contract. First, define the data contract/interface that both backend and frontend will use. Then spawn these parallel tasks: Task 1 - BACKEND: Implement the API endpoints and service layer for [FEATURE]. Write integration tests that verify the endpoints return data matching the contract. Run tests until green. Task 2 - FRONTEND: Implement the Blazor components for [FEATURE] using the shared contract. Follow the existing AppState pattern. Include error states and loading states. Task 3 - INTEGRATION: After Tasks 1 and 2 complete, verify the frontend correctly calls the backend, navigation links work, and do a full build. Fix any interface mismatches. Shared contract: [DESCRIBE OR LET CLAUDE DEFINE IT] Feature: [DESCRIPTION]`
Self-Correcting ML Notebooks With Validation Checkpoints
Your ML notebook sessions consistently hit the same pattern: Claude generates a notebook, it has 2-4 bugs (wrong tensor types, glob picking up non-images, loss function NaN issues, incompatible parameters), and you spend multiple rounds debugging. By instructing Claude to embed validation checkpoints after every major cell—shape assertions, loss sanity checks, dtype verification—you can have it autonomously catch and fix issues like the 0*-inf=NaN bug or the embedding collapse before you ever run the notebook. This transforms notebook creation from a fragile back-and-forth into a self-healing pipeline.
Getting started: Use Claude Code's Bash tool to actually execute notebook cells incrementally via `jupyter execute` or `papermill`, catching errors in real-time. Add a CLAUDE.md rule for ML work: 'After every notebook cell, add an assertion cell that validates shapes, dtypes, and value ranges.'
Paste into Claude Code:
`Create a Jupyter notebook for [ML TASK DESCRIPTION]. Follow these mandatory rules: 1. After EVERY code cell, add a validation cell with assertions: tensor shapes, dtypes (no accidental float16 overflow), value ranges (no NaN/Inf), and device placement 2. Before any loss computation, add a cell that tests the loss function with edge cases: zero vectors, identical pairs, and extreme values. Print results and assert no NaN 3. For data loading: print 3 sample file paths, verify they're valid images, print dataset class distribution, assert no empty classes 4. For model outputs: after first forward pass, assert embedding dimensions, verify gradients flow (none are None), check magnitude ranges 5. Use try/except blocks around library calls that have version-sensitive APIs (like sklearn TSNE n_iter vs max_iter) 6. At the end, add a summary cell that prints all key metrics and saves a validation report Dataset path: [PATH] Model architecture: [DESCRIPTION] Training objective: [DESCRIPTION]`
"Claude kept trying to fix NaN losses with increasingly wrong guesses until it finally discovered the mathematically poetic root cause: 0 × negative infinity = NaN"
During a contrastive learning training session, Claude's first two fixes (disabling autocast, float-casting F.normalize) completely missed the mark. On the third attempt, it finally traced the NaN to the beautifully cursed edge case of multiplying zero by negative infinity in the loss function — a bug that feels like it belongs in a math philosophy class.