Claude Code Insights

217 messages across 10 sessions (1,307 total) | 2026-05-05 to 2026-05-11

At a Glance

What's working: You run tight iteration loops on a complex WordPress codebase, catching subtle issues like rule violations and over-engineered approaches before they ship. Your instinct to delegate heavy lifting to Codex MCP while keeping Claude as the orchestrator is a sophisticated pattern—the Self-Assessment rebuild is a great example of this paying off. Impressive Things You Did →

What's hindering you: On Claude's side: it often commits to an approach before validating constraints (Elementor CSS overrides, custom MCP bridges, wrong page targets) and occasionally takes destructive actions like password resets without checking. On your side: known project rules and credentials sometimes live in your head rather than in a persistent place Claude can see, so the same constraints get re-violated across sessions. Where Things Go Wrong →

Quick wins to try: Try moving your recurring project rules (no CSS overrides on Elementor, preferred MCP transports, credential locations) into a CLAUDE.md or Custom Skill so they're loaded automatically every session. Hooks could also catch destructive actions—e.g., a pre-commit or pre-edit hook that flags password resets or Elementor CSS edits before they happen. Features to Try →

Ambitious workflows: With stronger models, flip your bug-fix loop: turn each reported issue into a failing Playwright test first, then let Claude iterate autonomously to green—the tooltip and MFP-modal rounds collapse into one pass. Longer term, scale your Codex delegation pattern into a parallel pipeline where one orchestrator describes a refactor and several agents work modules simultaneously while a supervisor reconciles and tests. On the Horizon →

217

Messages

+21,068/-251

Lines

188

Files

Days

43.4

Msgs/Day

What You Work On

Genuvia WordPress Site Development ~5 sessions

Extensive iterative work on a clinic/medical WordPress site including body map CPT restructuring, mobile navigation overhaul, shortcode AJAX fixes, ACF display bugs, hero/menu refinements, and client panel features. Claude used Bash, Write, and Edit heavily to ship multi-file changes, though occasionally violated project rules (Elementor CSS overrides) and required iteration on tooltip positioning and mobile nav approaches.

Production Launch Prep & UI Polish ~2 sessions

Pre-deployment cleanup including snippets, CPTs, permissions, MFP fixes, button hover consistency, price labels, and admin column glitches. Claude delivered Polish-language copy for body map sections and handled multiple small bug fixes per session, with TaskCreate/TaskUpdate used to track parallel cleanup items.

Self-Assessment Tool Rebuild ~1 sessions

Disabling OpenClaw services and rebuilding a Self-Assessment UI with triage-first redesign, identity-aware classification, deduplication, and improved navigation. Claude delegated significant portions to Codex MCP and tightened a duplicate validator after false positives on same-amount transactions.

MCP & Dev Environment Setup ~2 sessions

Installing and configuring Google Stitch MCP server for web design work (pivoting from a custom bridge to native HTTP transport) and troubleshooting passwordless SSH into a VPS from the Claude app. The Stitch setup succeeded and was saved to memory, but the SSH issue went unresolved after multiple passphrase and identity-file attempts.

Demo Presentation & Client Communication ~1 sessions

Building a presentation tour page and demo gallery for the Genuvia site, plus drafting a client email. The /prezentacja/ tour failed to work properly and was abandoned, with the user pivoting to having Claude write the client email instead.

What You Wanted

Bug Fix

Ui Bug Fix

Data Quality Fixes

Feature Adjustment

Credentials Request

Demo Presentation Build

Top Tools Used

Bash

941

Write

182

Read

151

Edit

TaskUpdate

TaskCreate

Languages

Markdown

Python

JSON

Shell

Session Types

Multi Task

Iterative Refinement

Single Task

Exploration

How You Use Claude Code

You work in rapid, conversational iterations rather than handing Claude detailed upfront specs. Your sessions are long (averaging nearly 4 hours each) and dense with back-and-forth — 217 messages across 10 sessions with Bash being invoked 941 times shows you treat Claude as a hands-on collaborator that executes constantly while you steer. You tend to batch multiple loosely-related issues into a single session (e.g., the Genuvia WP session covering hover bugs, missing price labels, admin column glitches, and a CPT dropdown all at once), then react to each fix before moving to the next. When something doesn't work — like the /prezentacja/ tour or the slideshow MFP crop — you cut your losses quickly and pivot rather than forcing Claude to keep trying, often redirecting to a different deliverable like 'just write the client email instead.'

You're a domain expert who corrects Claude's approach mid-flight. You called out Claude for building a custom MCP bridge when Stitch had native HTTP support, you enforced your 'no CSS overrides of Elementor settings' rule and required a revert, and you clarified scope when Claude investigated the wrong body-map page. This suggests you read Claude's actions closely and aren't shy about interrupting. At the same time, you tolerate a fair amount of iteration friction — the SSH/VPS session ran through multiple failed troubleshooting attempts (passphrase removal, identity file paths) before being abandoned, and tooltip positioning took several rounds. Your satisfaction signals (21 'likely satisfied', 11 'satisfied', only 2 'frustrated') indicate you grade on final outcome, not path efficiency.

You lean heavily on Claude for production WordPress/clinic site work with real stakes — pre-deployment cleanups, client-facing presentations, Polish copy, ACF debugging — and you delegate to Codex MCP when the task is structural (the Self-Assessment UI rebuild). The mix of Markdown (68 files) and Python (13) plus only 3 commits over 38 hours suggests you're using Claude primarily for planning, docs, and live-site fixes via snippets rather than traditional git-based development.

Key pattern: You run long, multi-task sessions as a hands-on director — batching issues, correcting Claude's approach in real-time, and pivoting away fast when something isn't working.

User Response Time Distribution

2-10s

10-30s

30s-1m

1-2m

2-5m

5-15m

>15m

Median: 198.5s • Average: 353.8s

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)

104

Evening (18-24)

Night (0-6)

Tool Errors Encountered

Command Failed

Other

File Not Found

User Rejected

Impressive Things You Did

Over 38 hours across 10 sessions, you drove a wide range of WordPress, infrastructure, and tooling work with a strong preference for delegation and iterative refinement.

Iterative WordPress Site Polish

You repeatedly cycled through Genuvia site issues—mobile nav, body map CPT, hero overflow, tooltip positioning—catching subtle problems like Claude violating your 'no CSS overrides of Elementor' rule and redirecting fixes. Your willingness to pivot approaches (e.g., scrapping horizontal scroll chips for a fullscreen bottom sheet) keeps momentum even when the first attempt fails.

Smart Delegation to Codex MCP

You leverage the Codex MCP server heavily for complex rebuilds like the Self-Assessment UI triage redesign, letting Claude orchestrate while a specialized model handles deep work. This multi-tool approach (21 Codex calls alongside 24 ToolSearch invocations) shows you treat Claude as a coordinator, not just an executor.

Course-Correcting on Tool Setup

When installing Google Stitch, you caught Claude building a custom MCP bridge unnecessarily and pointed it toward the native HTTP transport, then had the working config saved to memory. That instinct to question over-engineering before it ships saved significant cleanup later.

What Helped Most (Claude's Capabilities)

Multi-file Changes

Good Debugging

Good Explanations

Proactive Help

Outcomes

Not Achieved

Mostly Achieved

Fully Achieved

Unclear

Where Things Go Wrong

Your sessions show recurring friction from Claude pursuing wrong initial approaches, taking unilateral actions you didn't sanction, and hitting output token limits that derail entire conversations.

Wrong initial approach requiring pivots

Claude frequently commits to an approach before validating it fits your context or constraints, forcing mid-task pivots. You could reduce this by stating known constraints upfront (e.g., 'Stitch has native MCP support' or 'no CSS overrides on Elementor') before Claude begins implementation.

Claude built a custom MCP bridge for Google Stitch before you pointed out native HTTP MCP support existed, wasting setup effort
Claude investigated buttons on /mapa-ciala/ when you meant the homepage body map, requiring clarification before any real progress

Unilateral destructive actions

Claude takes irreversible actions like password resets or rule-violating edits without asking, even when you've previously shared the relevant info. Explicitly telling Claude to confirm before destructive operations, or pinning known credentials/rules at the top of sessions, would prevent these reverts.

Claude reset the admin password instead of asking, despite you having shared it earlier, and also reset the client account password before catching itself
A subagent violated your known 'no CSS overrides of Elementor settings' rule, requiring a full revert

Output token limit failures and long debugging loops

Two of your ten sessions were completely lost to 500 output token API errors, and other sessions stretched long due to repeated misdiagnosis. Asking Claude for shorter, incremental responses and breaking complex debugging into smaller verification steps could prevent both issues.

Two sessions had no usable transcript because Claude's responses exceeded the 500 output token maximum, causing API errors
The VPS SSH session never resolved despite multiple attempts (passphrase removal, identity file paths) before discovering the app wasn't even sending the key

Primary Friction Types

Wrong Approach

Buggy Code

Misunderstood Request

Excessive Changes

User Rejected Action

Language Complexity

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.

## WordPress / Elementor Rules
- NEVER override Elementor settings with custom CSS — adjust within Elementor's UI/widget settings instead
- NEVER reset passwords for admin or client accounts; always ask the user (they have shared credentials before)
- When user mentions 'body map' or similar features, confirm WHICH page (homepage vs. dedicated page) before investigating

Across multiple Genuvia/WordPress sessions, Claude violated the no-CSS-override-of-Elementor rule (requiring reverts), reset passwords instead of asking, and investigated the wrong page when 'body map' was ambiguous — these are recurring frictions worth codifying.

## Response Format
- Keep individual responses concise; if a task requires extensive output, break it into smaller steps or write results to files rather than printing inline.
- Prefer Edit/Write tools over long inline code blocks in chat responses.

Two sessions failed entirely due to output token limit errors, wasting user time — proactively chunking output would prevent this.

## Debugging Approach
- Before suggesting fixes for connection/auth issues (SSH, MCP, APIs), first verify what is actually being sent (logs, verbose flags, network capture) rather than guessing at config options.
- Avoid jumping between speculative fixes; confirm the failure mode first.

The SSH session burned significant time on speculative fixes (passphrase removal, identity file paths) before discovering the app wasn't sending the key at all — root-cause-first would have saved the session.

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

Custom Skills

Reusable markdown prompts invoked via /command for repeat workflows.

Why for you: You run the same WordPress cleanup loops repeatedly (snippet audits, CPT fixes, ACF debugging, pre-deploy checks). A /wp-predeploy or /wp-audit skill would standardize these and reduce the iteration friction seen in multiple Genuvia sessions.

mkdir -p .claude/skills/wp-predeploy && cat > .claude/skills/wp-predeploy/SKILL.md <<'EOF'
# WordPress Pre-Deploy Check
1. Verify all custom snippets are active and error-free
2. Check CPT permissions and admin column rendering
3. Validate ACF fields display correctly on frontend
4. Confirm no custom CSS overrides Elementor settings
5. Test mobile nav and body-map interactions
6. Report findings as a checklist; do NOT auto-fix without confirmation
EOF

MCP Servers

Connect Claude to external tools/APIs via Model Context Protocol.

Why for you: You already used the Codex MCP and Stitch MCP successfully. Adding a WordPress MCP (e.g., for WP-CLI or REST API) would let Claude inspect site state directly instead of relying on shell guessing — addressing the 941 Bash calls dominating your tool usage.

claude mcp add wp-cli -- npx -y @wordpress/mcp-wp-cli --site=https://genuvia.local

Hooks

Shell commands auto-run at lifecycle events (e.g., post-edit).

Why for you: With 75 Edits and frequent buggy-code friction, an auto-lint/syntax-check hook on PHP and Python files would catch issues before they compound into multi-iteration fixes.

// .claude/settings.json
{
  "hooks": {
    "PostToolUse": [{
      "matcher": "Edit|Write",
      "hooks": [{"type": "command", "command": "if [[ $FILE == *.php ]]; then php -l $FILE; fi"}]
    }]
  }
}

New Ways to Use Claude Code

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

Bash-heavy workflow (941 calls)

Your sessions lean extremely heavily on Bash (4x more than Write/Read combined). Consider whether MCP servers or Task agents could replace shell scripting for repetitive inspection tasks.

With 941 Bash calls across 217 messages (~4 per message), much of your work is shell-driven WordPress/VPS inspection. A WP-CLI MCP server or Task agent for codebase exploration would reduce context-switching and let Claude reason about results in a structured way rather than parsing raw shell output. This is especially relevant for your Genuvia site work where you inspect CPTs, snippets, and ACF state repeatedly.

Paste into Claude Code:

Use a Task agent to explore the Genuvia WordPress site structure: list all active snippets, CPTs, ACF field groups, and Elementor templates. Return a structured summary I can reference in future sessions.

Iteration friction on UI fixes

Multiple sessions show 'wrong_approach' on UI work — Claude guesses at fixes before confirming the failure mode.

Tooltip positioning, MFP cropping, mobile nav chips, and SSH key issues all required multiple iterations because the initial diagnosis was speculative. Asking Claude to state its hypothesis and verification step BEFORE editing would reduce wasted edits. This applies especially to your Elementor/CSS work where premature fixes have been reverted.

Paste into Claude Code:

Before making any UI changes, state: (1) what you observed, (2) your hypothesis for the root cause, (3) how you'll verify the hypothesis before editing. Wait for my OK on the hypothesis.

Leverage Codex MCP delegation pattern

Your most successful session (OpenClaw redesign) used heavy Codex MCP delegation. Codify this pattern.

The session where you delegated to Codex MCP for the Self-Assessment UI rebuild was rated 'essential' and shipped a working triage-first redesign. Consider making this the default for large refactors: scope with Claude, delegate execution to Codex, review with Claude. This split played to each tool's strengths.

Paste into Claude Code:

For this refactor: first help me scope and plan, then delegate the implementation to Codex via MCP with a precise spec, then review Codex's output and identify gaps. Don't write code directly yourself unless I ask.

On the Horizon

Your WordPress and Genuvia work shows a pattern of iterative bug-fixing and UI refinement that's ripe for transformation into autonomous, parallelized workflows.

Autonomous WordPress QA Agent Fleet

Instead of manually reporting button hover bugs, missing price labels, and admin column glitches one-by-one, deploy a fleet of parallel Claude agents that crawl your live WordPress site, capture screenshots at multiple breakpoints, diff against design specs, and autonomously file + fix issues. Each agent owns a domain (mobile nav, ACF fields, Elementor templates, CPTs) and runs nightly, producing a morning report of fixes already committed to a staging branch.

Getting started: Use the Task tool to spawn parallel subagents with Playwright MCP for visual regression and your existing WP-CLI bash workflows. Pair with a 'rules.md' encoding constraints like 'no CSS overrides of Elementor settings'.

Paste into Claude Code:

Build me an autonomous WordPress QA system for the Genuvia site. Spawn 4 parallel subagents using the Task tool: (1) Mobile UI agent that uses Playwright MCP to screenshot every page at 375px/768px/1440px and diff against last week's baseline, (2) Admin UX agent that logs into wp-admin and verifies CPT columns, ACF fields, and dropdowns render correctly, (3) Performance agent that runs Lighthouse on key templates, (4) Content integrity agent that checks for missing prices, broken shortcodes, and duplicated sources. Each agent should respect a rules.md file (no CSS overrides of Elementor, never reset passwords, ask before destructive actions). Output a single markdown report with screenshots, severity-ranked issues, and proposed fixes in a staging branch.

Test-Driven Bug Fix Loop

Your bug_fix sessions (7 of 10!) often required multiple iterations because fixes were validated visually after the fact. Flip the loop: every reported bug first becomes a failing Playwright/PHPUnit test, then Claude iterates autonomously until green—rerunning, refining, and self-correcting without you in the loop. The tooltip-positioning and MFP-modal bugs that took multiple rounds would resolve in one session.

Getting started: Combine Claude Code's bash loop with Playwright MCP and a 'fix-until-green' system prompt. Use git worktrees so parallel fix attempts don't collide.

Paste into Claude Code:

I want you to operate in test-first autonomous mode. When I report a bug, you will: (1) Write a failing Playwright test (or PHPUnit test for backend) that reproduces it exactly, (2) Commit the failing test, (3) Enter a fix-iterate loop—write fix, run test, read failure, refine—up to 10 iterations without asking me, (4) Only stop when the test passes AND no other tests regress, (5) Report back with the diff and test output. Start with this bug: the mobile gender button on /mapa-ciala/ doesn't respond to taps on iOS Safari. Use git worktrees so you can try multiple approaches in parallel and pick the cleanest one.

Codex-Delegated Parallel Refactor Pipeline

Your Self-Assessment redesign already showed the power of delegating to Codex MCP. Scale this into a pipeline where you describe a large refactor once, and Claude orchestrates 3-5 Codex agents working on different modules simultaneously (classification, dedup, navigation, UI), with a supervisor agent reconciling conflicts and running integration tests. Multi-day feature builds compress into hours.

Getting started: Use mcp__codex__codex as worker agents orchestrated by Claude Code as supervisor, with TaskCreate/TaskUpdate for coordination and a shared design doc as the source of truth.

Paste into Claude Code:

Act as a refactor supervisor. I'll give you a feature spec; you'll decompose it into 4-6 independent workstreams and dispatch each to a parallel mcp__codex__codex invocation. Maintain a TaskCreate board tracking each workstream's status. After all workers complete, you run an integration pass: resolve merge conflicts, run the full test suite, and produce a single PR with a unified changelog. Workstreams must have clear interface contracts so they can't break each other. First feature: 'Rebuild the body-part CPT system with a treatment dropdown, identity-aware classification, dedup logic with configurable thresholds, and a triage-first admin UI.' Begin by proposing the workstream decomposition and interface contracts, then ask for my approval before dispatching workers.

"User abandoned a broken presentation tour and just asked Claude to write a client email instead"

During a long Genuvia site refinement session, after multiple failed attempts to get the /prezentacja/ tour working, the user gave up on the feature entirely and pivoted to having Claude draft a client email — a very human 'forget it, let's just send the email' moment.