Claude Code Insights

175 messages across 22 sessions (32 total) | 2026-06-17 to 2026-07-12

At a Glance

What's working: You treat Claude as a capable research analyst and builder, not just a chatbot—you push past surface answers, demand specific strategies over generic advice, and deploy real applications to your own Raspberry Pi infrastructure. Your instinct to verify claims (like catching that pump-and-dump) and flag security risks (hardcoded API keys) shows you're using Claude as a force multiplier while staying firmly in the driver's seat. Impressive Things You Did →

What's hindering you: Claude's side: It too often ships buggy code that needs multiple fix cycles, and jumps to solutions before fully confirming what you actually want—wasting your time with wrong endpoints, compilation errors, or generic risk disclaimers when you asked for a specific numbered strategy. Your side: Sessions sometimes start without enough project context, forcing costly re-explanation of decisions and pitfalls you've already navigated. Where Things Go Wrong →

Quick wins to try: Turn your repeated Raspberry Pi deployment steps into a reusable Custom Skill—one `/deploy-pi` command that bundles SSH verification, cache busting, Git push, and post-deploy smoke testing so you never hit a stale page again. For investment research sessions, ask Claude to label every factual claim with a confidence level (confirmed / reported / rumored) upfront—this would have caught the Samsung earnings rumor-vs-fact confusion before it reached you. Features to Try →

Ambitious workflows: As models improve, you could run autonomous research agents that monitor your watchlist 24/7, cross-reference financial data sources, flag coordinated misinformation before it spreads, and escalate only high-signal alerts to you. On the dev side, agents will self-test their own code, catch regressions, deploy with built-in cache busting, and verify the live site actually loads correctly—eliminating the fix-deploy-retry loop entirely. On the Horizon →

175

Messages

+10,631/-445

Lines

Files

Days

11.7

Msgs/Day

What You Work On

Investment Research & Market Analysis ~7 sessions

Extensive research on Korean semiconductor companies (Samsung, SK Hynix), MLCC industry fundamentals, and Hong Kong micro-cap stock tips. Claude Code was used heavily for web-sourced financial data gathering, generating detailed reports with currency conversions, and developing leveraged buying strategies based on real-time market analysis.

Hong Kong Job Search & Resume Preparation ~4 sessions

Created tailored bilingual LaTeX resumes for Hong Kong semiconductor roles, researched job platforms, and identified companies supporting IANG visa renewal. Claude Code assisted with iterative resume editing, market-rate salary research, and generating a Claude Code insights report required for a job application.

Application Development & Raspberry Pi Deployment ~5 sessions

Built and debugged a Flutter expense tracker app with LLM-powered parsing and swipe-to-delete features, implemented PWA offline caching with a custom service worker, and deployed both the tracker and a Tetris game to a Raspberry Pi. Claude Code handled SSH-based remote deployment, HTTPS configuration, and multi-file project development.

Content Creation & Education Materials ~3 sessions

Generated a multi-platform promotional plan for a Hong Kong student class, drafted and refined three wedding speeches, and created bilingual lecture notes with an AP growth plan, math level assessment, and parent communication checklist for a G9-to-G10 student transition.

General Information & Advisory Queries ~3 sessions

Provided structured, web-researched answers on Singapore work visas and PR processes, investigated Tailscale exit node privacy on a Raspberry Pi via SSH, and offered empathetic health anxiety guidance with professional referral suggestions.

What You Wanted

Information Queries

Investment Analysis

Deployment

Information Gathering

Feature Development

Debugging

Top Tools Used

Bash

234

Read

160

WebSearch

146

Edit

141

Write

TaskUpdate

Languages

Markdown

JSON

HTML

YAML

JavaScript

Shell

Session Types

Iterative Refinement

Multi Task

Quick Question

Exploration

Single Task

User Response Time Distribution

2-10s

10-30s

30s-1m

1-2m

2-5m

5-15m

>15m

Median: 68.6s • Average: 186.6s

Multi-Clauding (Parallel Sessions)

No parallel session usage detected. You typically work with one Claude Code session at a time.

User Messages by Time of Day

Morning (6-12)

Afternoon (12-18)

161

Evening (18-24)

Night (0-6)

Tool Errors Encountered

Other

Command Failed

File Not Found

User Rejected

Edit Failed

File Too Large

Impressive Things You Did

Across 22 sessions, you've built an impressive hybrid workflow spanning deep investment research, full-stack development with self-hosted deployments, and sophisticated multi-language document engineering.

Systematic Investment Research Pipeline

You conduct multi-layered investment analysis—validating a micro-cap stock tip as a coordinated pump-and-dump by tracing KOL networks, building leveraged buying strategies during SK Hynix's -12% crash with specific price triggers, and deep-diving into MLCC industry fundamentals with web-sourced data. You push beyond surface answers, correcting Claude when it confuses rumors with facts or deflects with risk warnings instead of delivering the numbered strategy you requested.

Self-Hosted, Security-Conscious App Deployments

You build complete Flutter applications with LLM integration, swipe-to-delete gestures, and PWA offline caching—then deploy them to your own Raspberry Pi via dual-branch GitHub setups with HTTPS, custom subdomains, and API keys stored in Supabase. When Claude hardcoded credentials in build flags, you caught the security risk immediately, and you persisted through SSH key misconfigurations and Git command blockers to get everything running on your own infrastructure.

Bilingual Document Engineering with LaTeX

You designed a polished bilingual (English/Chinese) LaTeX resume tailored specifically for Hong Kong semiconductor jobs—researching templates, customizing the document class file to fix FontAwesome compilation failures, and iteratively refining content and layout across multiple sessions. You also generate structured lecture notes, wedding speeches, and promotional plans, then refine them with precise feedback until every detail matches your vision.

What Helped Most (Claude's Capabilities)

Good Explanations

Multi-file Changes

Good Debugging

Fast/Accurate Search

Proactive Help

Outcomes

Mostly Achieved

Fully Achieved

Unclear

Where Things Go Wrong

Your sessions are productive overall but you encounter recurring friction from code bugs requiring multiple fix cycles, solutions proposed without validating your preferences, and factual or domain context misunderstandings that force you to correct Claude's assumptions.

Code Quality & Iteration Fatigue

You often need multiple fix-restart cycles to get code working because Claude ships with bugs like wrong API endpoints, parsing errors, or missing deployment considerations. Requesting upfront validation or a pre-completion checklist before considering a task done could reduce these cycles.

LLM integration in your Flutter expense tracker had multiple bugs (wrong endpoint, model name, JSON parsing, timeout) requiring several fix-restart cycles before it worked correctly
Deployment of a bug fix missed cache busting, causing you to still see the old broken version until you manually force-refreshed the browser

Premature Solutions Without Validating Requirements

Claude sometimes jumps to building a solution before confirming your preferences or fully understanding the ask, leading you to reject unprofessional formats or having to repeat yourself when Claude deflects with generic advice instead of the specific strategy you requested.

Claude initially planned a Markdown-based resume which you rejected as unprofessional, then the replacement LaTeX approach used FontAwesome which caused a compilation failure requiring manual .cls file modification
When you asked for a specific leveraged buying strategy during SK Hynix's -12% crash, Claude initially responded with risk warnings instead of the numbered price-trigger strategy you wanted, forcing you to repeat and clarify your request

Factual & Domain Context Gaps

You've had to correct Claude when it treats unverified information as confirmed fact or misunderstands domain-specific context like sports tournaments or financial market terminology. Slowing down to verify sources and asking clarifying questions before presenting conclusions could prevent these errors.

Claude presented leaked rumor figures about a Korean semiconductor investment event as confirmed facts, requiring you to correct the distinction between expectations and official results twice before getting accurate analysis
Claude mistakenly asked if a soccer match was Nations League or Euro qualifiers instead of recognizing it as the 2026 World Cup, which you had to jokingly call out

Primary Friction Types

Buggy Code

Wrong Approach

Incomplete Changes

Misunderstood Request

Wrong Factual

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.

## Deployment Checklist
Before deploying any web app to Raspberry Pi:
1. Verify SSH key is configured on both local machine and Pi (`ssh pi@<host>` must work without password)
2. Add cache busting to all asset references (versioned filenames or ?v= query strings)
3. Never hardcode API keys in source code or build flags — use environment variables or Supabase/secret manager
4. After deploy, verify the new version loads by checking a unique marker in the page

SSH key misconfiguration blocked deployments in 2+ sessions, missing cache busting forced manual refreshes, and hardcoded API keys were flagged by the user as a security risk — all repeated friction points across the Flutter expense tracker deployment sessions.

After any code change to the Flutter project, run `flutter analyze` and fix all warnings before marking the task complete. Do not skip this step even for small edits.

Lint warnings appeared in 2+ sessions as follow-up fixes that could have been caught proactively, causing extra back-and-forth cycles.

When presenting financial or political news about Korean markets (SK Hynix, Samsung, government announcements), explicitly distinguish between: (a) confirmed official statements/earnings, (b) media-reported rumors/leaks, and (c) analyst expectations. Never present unverified leaks as confirmed facts.

User corrected Claude twice in one session for conflating leaked rumors with confirmed earnings numbers and event statuses — and Korean semiconductor investment research appears across 8+ sessions, making this a high-recurrence domain.

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

Hooks

Shell commands that auto-run at specific lifecycle events (pre-edit, post-save, pre-deploy)

Why for you: Your #1 friction is 'buggy code' (9 occurrences) and lint warnings appearing after changes. A PostToolUse hook could auto-run `flutter analyze` after every Edit to Flutter files, and a pre-deploy hook could validate SSH keys and run cache busting scripts — catching the exact failures that caused repeated back-and-forth in your deployment sessions.

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit",
        "paths": "*.dart",
        "command": "cd ~/expense_tracker && flutter analyze"
      },
      {
        "matcher": "Bash",
        "paths": "deploy.sh",
        "command": "bash scripts/verify-deploy.sh"
      }
    ]
  }
}

Custom Skills

Reusable prompt templates defined as markdown files that run with a single /command

Why for you: You have 3 clear repeatable workflows: (1) investment deep-dive research with web-sourced data and multi-currency analysis, (2) deploy Flutter app to Raspberry Pi with HTTPS, and (3) generate bilingual content with formatting constraints. Custom Skills like `/investigate`, `/deploy-pi`, and `/bilingual` would encode your preferences once instead of re-specifying them each session.

# Create file: .claude/skills/investigate/SKILL.md
# Then run: /investigate SK Hynix latest earnings

# SKILL.md content:
# When researching a company:
# 1. Search for latest earnings/financials from multiple sources
# 2. Convert all non-USD currencies to USD with exchange rate noted
# 3. Distinguish confirmed data vs analyst estimates vs rumors
# 4. Include competitor context and sector trends
# 5. Output as structured markdown with source links

MCP Servers

Connect Claude to external tools, databases, and APIs via Model Context Protocol

Why for you: Your expense tracker uses Supabase for secure API key storage, and your investment research sessions (8 total) involve repetitive web searches for financial data. An MCP server could give Claude direct access to Supabase for database operations, and a financial data MCP (Alpha Vantage, Yahoo Finance) could pull structured market data instead of parsing unstructured web pages — reducing the wrong_factual and misunderstood_request friction.

# Add a Supabase MCP server for the expense tracker:
claude mcp add supabase -- npx @anthropic/mcp-server-supabase --api-key $SUPABASE_KEY --url $SUPABASE_URL

# Or a financial data server:
claude mcp add market-data -- npx mcp-server-yahoo-finance

New Ways to Use Claude Code

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

Raspberry Pi Deploy-Standardize Workflow

Create a single `/deploy-pi` skill that bundles SSH verification, cache busting, Git push, and remote verification into one standardized pipeline.

Across 3+ deployment sessions (Flutter expense tracker, Tetris game, PWA setup), the same friction points recurred: SSH keys not configured on both ends, missing cache busting causing stale versions, and no post-deploy verification. Each time Claude had to rediscover and fix these issues. A standardized deploy skill with pre-flight checks (SSH test, deploy key format validation, asset hashing) would have prevented all of these, and the Tetris/Tracker/website deployments all followed the same Mac → GitHub → Raspberry Pi → HTTPS domain pattern.

Paste into Claude Code:

Create a deployment skill at .claude/skills/deploy-pi/SKILL.md that: (1) checks SSH connectivity to pi@<host> before anything, (2) adds cache-busting query strings to all CSS/JS/asset refs, (3) pushes to GitHub, (4) pulls on Pi via SSH, (5) curls the live URL to verify the new version loaded. Use this for all future deployments.

Investment Research with Structured Output

For investment sessions, always request a standardized output format with explicit fact-confidence labels and automatic currency conversion to a single base.

You ran 8 investment analysis sessions (SK Hynix, Samsung, MLCC, Murata, micro-cap due diligence) and friction arose when Claude mixed rumors with confirmed data or omitted currency conversions. Your successful sessions had a clear pattern: multi-source web research → structured analysis with financials → competitor context → actionable summary. The most satisfying sessions (MLCC deep-dive, Samsung earnings, pump-and-dump analysis) all followed this pattern with explicit sourcing.

Paste into Claude Code:

Research [COMPANY] and produce a structured report with: (1) Confirmed financials with source links and [FACT] label, (2) Analyst estimates with [ESTIMATE] label, (3) Media-reported rumors with [UNVERIFIED] label, (4) All figures converted to USD with exchange rate noted, (5) Competitor comparison table, (6) 3-5 actionable takeaways for an investor.

Multi-File Project Scoping Up-Front

Before generating multi-file outputs (resumes, lecture notes, websites), ask Claude to list all files it plans to create/modify with their purposes for approval first.

Several sessions involved generating multiple files (3-file Tetris game, bilingual resume with LaTeX templates, lecture notes + growth plan + assessment + checklist). Friction points like 'wrong approach' (6 occurrences) and 'incomplete changes' (2 occurrences) often stemmed from Claude choosing a format or scope the user didn't want (Markdown resume rejected for LaTeX, voice recognition only reached planning stage). A quick file manifest approval step before generation would catch format mismatches and scope gaps early.

Paste into Claude Code:

Before creating any files, first list every file you plan to create or modify with a one-line description of its purpose. Wait for my approval on the format and scope before writing any code or content.

On the Horizon

AI-assisted development is evolving from reactive code editing to proactive autonomous agents that research, build, test, deploy, and self-correct across entire multi-session workflows without human babysitting.

Autonomous Research-to-Report Investment Agents

Deploy parallel AI agents that autonomously monitor market events (earnings, FOMC, geopolitical shifts), cross-reference multiple financial data sources in real time, verify facts against competing narratives before publishing, and generate structured investment reports with price-target models—all triggered by a single watchlist. These agents can detect and flag coordinated misinformation (like the pump-and-dump the user caught manually) before a human sees it, running 24/7 with escalating alerts.

Getting started: Orchestrate a crew of Claude agents via the Agent SDK: one for web monitoring, one for fact-verification, one for financial modeling. Use TaskCreate/TaskOutput to chain them with human-in-the-loop at final output stage.

Paste into Claude Code:

You are an autonomous investment research agent. I'm giving you a watchlist: [SK Hynix, Samsung, Murata]. For each ticker: (1) continuously scan news, earnings calendars, and KOL chatter across KR/CN/EN sources, (2) whenever a material event occurs, spawn a fact-checking sub-agent that cross-references the claim against primary sources (exchange filings, company IR pages, government announcements), flagging any discrepancy between rumor and confirmed fact, (3) spawn a modeling sub-agent that updates a DCF or comparable-company price target incorporating the verified data, (4) compile a timestamped report with confidence scores for each claim. Run autonomously and ping me only when confidence-downgraded claims or >5% price-target changes are detected.

Self-Testing, Self-Healing Deployment Pipelines

Move beyond manual fix-deploy-retry cycles by giving agents the ability to write code, run a full test suite, catch their own bugs (the #1 friction at 9 instances), automatically apply fixes, verify the fix passes, then deploy with built-in cache-busting, security scanning (no hardcoded keys), and post-deploy smoke tests. An agent should never ship buggy code that requires the user to force-refresh—it should verify the live deployment itself and roll back on failure.

Getting started: Use Claude Code's Bash + Edit tools in a loop: after every code change, auto-run linters, unit tests, and a headless browser smoke test. Integrate with GitHub Actions so the agent can push, watch CI, and react to red builds autonomously.

Paste into Claude Code:

You are a deployment agent with self-healing capability. For every code change you make: (1) immediately run the project's full test suite and linter, (2) if any test fails or warning appears, diagnose and fix it yourself before proceeding—do not ask me, (3) before deploying, scan the entire diff for hardcoded secrets, insecure endpoints, or missing cache-busting hashes, (4) deploy to the target environment, then run a post-deploy smoke test that actually opens the live URL and verifies core functionality works (check for 'old version' stale cache indicators), (5) if smoke tests fail, auto-rollback to the last known-good commit and report the root cause. Never ship code that hasn't passed all four gates.

Persistent Cross-Session Memory with Project Context Recovery

Eliminate the costly 'context recovery after restart' friction by building agents that maintain a living project knowledge graph across sessions—tracking what was built, why key decisions were made, known pitfalls (like the .jpeg vs .jpg mismatch or FontAwesome cls hack), and active TODOs. When a session resumes, the agent proactively reconstructs full context, presents a diff of what changed since last interaction, and suggests the next logical step without the user needing to re-explain.

Getting started: Use Claude's project memory feature combined with a structured CLAUDE.md or AGENTS.md file that the agent auto-updates after every session with: decisions made, bugs encountered and their fixes, current project state, and a prioritized backlog of next actions. On session start, instruct the agent to read this file first and present a summary.

Paste into Claude Code:

At the end of every session, update the project's CONTEXT.md file with these sections: (1) CURRENT STATE: one-paragraph summary of what's built and deployed, (2) DECISIONS LOG: every architectural choice made this session and why (e.g., 'cache-first service worker chosen over network-first because offline PWA is priority'), (3) BUGS & FIXES: every bug encountered, its root cause, and the exact fix applied (e.g., 'FontAwesome cls file missing—fixed by downloading cls to project root'), (4) SHARP EDGES: known gotchas that could break things (e.g., 'photo must be .jpg not .jpeg'), (5) NEXT STEPS: ranked priority list of what to tackle next. On the next session start, begin by reading CONTEXT.md, diffing the current codebase against the recorded state, and proactively stating: 'Here's where we left off, here's what may have changed, and here's what I recommend doing next.'

"Claude thought the 2026 World Cup was a Nations League or Euro qualifiers match — the user jokingly roasted its sports knowledge"

During an investment strategy session, a soccer match came up in conversation. Claude earnestly asked whether it was the Nations League or Euro qualifiers, completely whiffing on recognizing the 2026 World Cup. The user noticed immediately and called it out with humor — a rare moment of the AI getting confidently tripped up on something millions of humans know by heart.