Claude Code Insights

1,802 messages across 113 sessions (342 total) | 2026-07-29 to 2026-10-28

At a Glance
What's working: You treat Claude less like a coding assistant and more like a team you manage. You run executor, reviewer and overseer agents across many repos, and the overseer has caught real problems like overlapping edits and a destructive push. You're also good at turning friction into durable rules through /learn, canon files and AGENTS.md entry points, and you trust Claude with real-world errands while keeping the risky final step, like confirming a bank transfer, for yourself. Impressive Things You Did →
What's hindering you: On Claude's side, the biggest problem is ignoring context that already exists. It contradicts decisions recorded in sibling repos, asks questions those repos already answer, and refers to item numbers, fragments or relative paths without showing what they mean. That last habit is especially costly for how you read. On your side, a lot of time goes to the environment rather than the work: secret-read guards on token files, a Telegram plugin that won't connect, expired Cloudflare credentials and safety-filter cutoffs that stall otherwise finished tasks. Where Things Go Wrong →
Quick wins to try: Try a Stop hook that checks every response against your ADHD canon before you see it. It should require full quoted text, absolute /Users/ws/ paths, an expanded files block and self-contained decision cards. Turn your recurring 'look up existing decisions across the Cheap repos before asking me anything' step into a custom skill so every multi-repo task starts with it. You could also move your overseer and PR-watch loops to headless mode on a schedule, so Claude only wakes up when something actually changes. Features to Try →
Ambitious workflows: As models improve, your overseer can move from watching to dispatching. It would split a backlog into isolated worktrees, run parallel executors, and gate each PR on tests and a reviewer agent before merging or escalating to you. Pair that with a pre-flight agent that searches your canon, MemPalace and sibling repos before any question reaches you, attaching evidence to each choice. The goal is that the only messages you receive are real decisions, already presented with full context. On the Horizon →
1,802
Messages
+33,903/-494
Lines
348
Files
38
Days
47.4
Msgs/Day

What You Work On

Multi-Agent Orchestration & Autonomous Pipelines ~18 sessions
Built and supervised automated task pipelines, including the Orca execute/review/cleanup flow, an overseer agent that monitored other sessions and PRs, and the blog-to-site feed with Haiku backlog parsing. Claude Code relied heavily on Agent, SendMessage and Bash to coordinate sub-agents, post PR reviews, write reviewer RULES files and run as a live meeting co-pilot. The most common friction was contradicting earlier decisions or asking questions that other repos already answered.
Cheap Project Sites, Reports & Spreadsheets ~16 sessions
Worked on the reports site, start-page links, Wordstat and Google Sheets tables with colored headers and column guides, the wishlist site and test-site discovery. Claude made multi-file edits, merged PRs, deployed changes and built side-by-side HTML review pages for approving Google Doc rewrites. Friction came from unclear explanations to an ADHD user, safety-filter cutoffs and expired Cloudflare credentials.
Git Repo Management, Skills & Documentation Canon ~18 sessions
Scaffolded private repos with standard _cons folders, shared and renamed the c-learn skill, managed collaborator invitations, restored a missing .git folder, and marked deprecated scripts across six repos. Many sessions centered on git push/merge workflows, v3 templates and card rewrites, and recording decisions with /learn into AGENTS.md, CLAUDE.md and canon files. Users wanted full absolute paths and consistent formatting, and wrong approaches here caused frustration.
Mac Tooling, Updates & System Maintenance ~13 sessions
Covered routine maintenance: GSD and MemPalace upgrades with version checks, moving 43 GB backups to iCloud to free about 80 GB, analyzing Orca workspace disk usage, and diagnosing Homebrew CLT errors. Claude also built Strawberry natively from source on arm64 and traced Fable model usage through logs. Most of these sessions were fully achieved through careful Bash-driven verification.
Personal Admin, Messaging & Errands ~13 sessions
Handled personal tasks such as a WhatsApp contact registry via wacli, Telegram bot setup and scheduled chat exports, a BBVA payment taken up to the confirm step, Wispr Flow promo-code hunting, and research into apostilled documents and nic.ru domain emails. Claude used browser automation and repo logging to track these errands, and once played a video hands-free on a second monitor. Friction came from decision requests without context, blocked Telegram sends and guard hooks on secret files.
What You Wanted
Git Push
11
Git Push Merge
10
Status Check
6
Open File Or Folder
6
Text Formatting Edits
5
Send Telegram Message
5
Top Tools Used
Bash
6401
Edit
373
Read
281
Write
280
SendMessage
166
Skill
89
Languages
Markdown
530
Python
202
HTML
32
JavaScript
3
JSON
3
Shell
2
Session Types
Multi Task
49
Iterative Refinement
16
Single Task
6
Quick Question
5
Exploration
2

How You Use Claude Code

You treat Claude Code less as a coding assistant and more as an always-on operations layer for your whole digital life and a fleet of agents. Bash dominates your tool usage (6,401 calls against only 373 Edits), most of your files are Markdown, and your most common goals are terse operational commands: 'push', 'push and merge', '/gsd-update', 'open it in Orca', 'send it to Telegram'. The scope is wide. In one week you might have Claude pay Vasily's 90 EUR invoice through BBVA up to the confirm step, evict 80 GB of backups to iCloud, build Strawberry from source, and play an Osetinskaya interview fullscreen on your second monitor by voice while you lie on the couch. You also run multi-agent setups: an Orca execute/review/cleanup pipeline, an overseer agent that nudges other sessions and catches a destructive push bug in PR #25, a PR reviewer for your laptop agent, and live meeting co-pilots fed by transcripts. The 166 SendMessage and 88 Agent calls show you are coordinating, not just prompting.

Your instructions are usually short and outcome-focused, and you expect Claude to fill in context from what already exists. You get angry when Claude asks questions whose answers sit in your other Cheap repos. You reject caution you consider pointless, such as proposed rate limits and night pauses on Haiku parsing when your subscription has none. You also got annoyed when Claude acted on WhatsApp edits before confirming its understanding. Wrong approach (34) and misunderstood request (31) are your biggest friction sources. They tend to come from Claude guessing scope wrongly rather than from bad code. Examples include treating review comments as standalone tasks, mixing branches from different repos, and researching DIY apostille steps when you wanted a turnkey Moscow firm.

The most distinctive thread is how strongly you react to communication that makes you hold context in your head. You've noted you have ADHD. Your sharpest frustrations came when Claude asked you to decide 'by number' without quoting the actual messages, quoted a fragment like 'id9213' with no surrounding text, gave repo-relative paths instead of full /Users/ws/ paths, or collapsed a 'Files to check' block you wanted expanded. You respond by turning each failure into durable rules: you write it into the adhd-check canon, run /learn to record decisions, log incidents, and threaten to hand the work to another agent. So you iterate quickly and let Claude run long and autonomously. But you hold it to a growing personal rulebook, and you expect every message to be readable on its own without scrolling back.

Key pattern: You run Claude as an autonomous ops hub and agent orchestrator using terse commands, expect it to infer context from your existing repos and rules, and react sharply to any reply that isn't self-contained.
User Response Time Distribution
2-10s
105
10-30s
124
30s-1m
100
1-2m
204
2-5m
212
5-15m
313
>15m
284
Median: 204.4s • Average: 557.3s
Multi-Clauding (Parallel Sessions)
61
Overlap Events
56
Sessions Involved
36%
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)
402
Afternoon (12-18)
482
Evening (18-24)
537
Night (0-6)
381
Tool Errors Encountered
Command Failed
160
Other
37
File Changed
3
Edit Failed
1
User Rejected
1

Impressive Things You Did

Over three months you ran 113 sessions and made 373 commits, using Claude Code as a full operations hub for your repos, your Mac, your finances and your messaging, as well as for writing code.

Multi-Agent Pipelines With Oversight
You built a fully automated execute, review and cleanup pipeline in Orca and tested it end-to-end on a real task. You then folded your quality feedback back into its rules. You also ran overseer and reviewer agents that watched other sessions and PRs, caught real problems such as a destructive push bug in PR #25, and moved to a cheaper token-saving watcher script. Heavy use of SendMessage and Agent shows you coordinating several agents at once, where most people work with a single one.
Encoding Decisions Into Durable Rules
You keep turning friction into lasting guidance. You use /learn to record decisions, you added your files-block preference to the adhd-check canon, and you write RULES files and AGENTS.md/CLAUDE.md entry points so other models can onboard. You also mark failed experiments and scripts DEPRECATED across six repos, which keeps your many repositories understandable to both you and future agents.
Claude as Real-World Operator
You hand Claude whole real-life tasks and keep the final say on the risky steps. For a bank transfer, it located the invoice and filled the BBVA form up to the confirm step for you to approve. It also built Strawberry natively from source for arm64 and moved 80 GB of backups into iCloud after verifying them. Your consistent habit of ending sessions with a push, and having Claude confirm that local and GitHub commits match, keeps all this work safely versioned.
What Helped Most (Claude's Capabilities)
Multi-file Changes
24
Proactive Help
17
Fast/Accurate Search
14
Good Explanations
10
Good Debugging
6
Correct Code Edits
4
Outcomes
Not Achieved
2
Partially Achieved
4
Mostly Achieved
38
Fully Achieved
32
Unclear
2

Where Things Go Wrong

Your biggest friction comes from Claude asking you to decide things without showing you the actual content, from Claude ignoring decisions you or your repos had already settled, and from tool or guard blockers that stalled delivery.

Context-free questions and references
Claude often points to item numbers, fragments, or relative paths without showing you what they refer to. That is especially costly for you with ADHD. A standing rule in your CLAUDE.md would help: always quote the full text, give the location, and use absolute /Users/ws/ paths when asking you to decide or check something.
  • In the WhatsApp contact registry, Claude twice asked you to decide contact roles by number without quoting the messages, which angered you and left the session only partially achieved.
  • During the task 1.2 Google Doc rewrite, Claude's link-fix proposal quoted only 'id9213' with no surrounding text or location, so you couldn't tell what would change. You got frustrated twice before it was resolved.
Re-asking or overriding settled decisions
Claude repeatedly asks questions or makes changes that contradict decisions already recorded in your other repos or made earlier by you. Tell Claude to check the related repos, memory, and canon before asking or proposing anything new. Treat recorded decisions as binding.
  • Reviewer claude-3f had to correct Claude three times for contradicting Konstantin's explicit decisions: a +03:00 offset, a reshaped per-page feed, and letting a title error crash the build. Claude itself called it the third such mistake in two days.
  • In the Cheap pipeline, Claude asked you questions already answered in other Cheap repos, including a currency decision it then contradicted. It also proposed rate limits on Haiku parsing that you had to reject because your subscription has none.
Blocked outputs and tool guards
Safety filters, secret-read hooks, and broken plugins stopped work midway, and the workarounds sometimes cost more than the original task. Use naming conventions that avoid guard triggers, such as no 'env' in token filenames. For sensitive documentation, have Claude write it to a file in smaller chunks or allow a handoff to another tool.
  • A safety filter cut off the _cons-flow note and the table 150 sources answer, so the documentation was never saved. Claude then refused to pass the task to Cursor, which angered you.
  • The Telegram plugin failed to connect and a guard blocked reading the bot key, so you had to do every Telegram send for the wishlist site yourself. Earlier, a .env-named token file Claude proposed was blocked by its own secret guard and had to be recreated.
Primary Friction Types
Wrong Approach
34
Misunderstood Request
31
Buggy Code
16
Poor Communication
5
Tool Unavailable
3
Poorly Structured Communication
2
Inferred Satisfaction (model-estimated)
Frustrated
13
Dissatisfied
36
Likely Satisfied
238
Satisfied
26
Happy
12
Unsure
2

Existing CC Features to Try

Suggested CLAUDE.md Additions

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

Several sessions (WhatsApp contact roles, task 1.2 review, old dev tasks list, the adhd-check canon) ended in frustration because Claude pointed to numbers or fragments without context. One case escalated to an incident report and a handoff to another agent.
The user had to explicitly ask for full paths after getting repo-relative ones, and opening files and folders is one of their top goals.
In multiple sessions Claude asked questions already answered in other Cheap repos or contradicted Konstantin's explicit decisions. In one case this happened three times in two days, which angered the user.
The user had to ask for regrouping in the ORCA branch cleanup, the WhatsApp contact registry (by company), and the old developer-tasks list.
git_push and git_push_merge are the top two goals (21 sessions), several transcripts ended before the push was confirmed, and a zsh word-splitting bug broke a multi-repo push.
A .env-named token file was blocked by the guard hook, and the user pasted a token into a tracked card. Telegram sends also failed repeatedly because the bot key couldn't be read.

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

Custom Skills
Reusable /commands defined as markdown files that run a multi-step workflow consistently.
Why for you: You already use skills (/learn, /gsd-update), and 'push' / 'push and merge' is your #1 request. A /ship skill would always commit, push, merge, deploy, and verify that local and remote hashes match, so sessions stop ending with an unconfirmed push.
mkdir -p ~/.claude/skills/ship && cat > ~/.claude/skills/ship/SKILL.md <<'EOF' --- name: ship description: Commit, push, merge to main, deploy and verify across all touched repos --- 1. List every repo touched this session (full /Users/ws/ paths), grouped by repo. 2. In each: git add session files (never secrets / *.token), commit with a clear message, push. 3. If on a branch: open/merge the PR into main, delete the branch. 4. If the repo has a deploy script, run it. 5. For each repo print: repo path | local HEAD | origin/main HEAD | MATCH/MISMATCH. 6. Use zsh arrays: for r in "${repos[@]}"; do ...; done EOF
Hooks
Shell commands that run automatically at lifecycle events like before or after a tool call.
Why for you: You've had tokens nearly committed and secret-guard confusion. A PreToolUse hook on Bash can block any git commit that stages token or secret files, and a Stop hook can warn when there are unpushed commits, which matters with 373 commits across many repos.
{ "hooks": { "PreToolUse": [ { "matcher": "Bash", "hooks": [{ "type": "command", "command": "if echo \"$CLAUDE_TOOL_INPUT\" | grep -q 'git commit'; then git diff --cached --name-only | grep -Ei '(token|secret|\\.key$)' && { echo 'Blocked: secret file staged' >&2; exit 2; }; fi; exit 0" }] } ], "Stop": [ { "hooks": [{ "type": "command", "command": "git rev-parse --git-dir >/dev/null 2>&1 && [ -n \"$(git log @{u}.. --oneline 2>/dev/null)\" ] && echo 'WARNING: unpushed commits in '$(pwd) || true" }] } ] } }
Headless Mode
Run Claude non-interactively from scripts, cron, or launchd.
Why for you: You run overseer agents, PR reviewers, blog-post latency checks, nic.ru checks, and meeting co-pilots as long interactive sessions (6,400+ hours). Moving the recurring checks to cheap headless runs on a schedule would save tokens and free your sessions.
# crontab -e : review open PRs every 30 min, cheap model, post comments */30 * * * * cd /Users/ws/uno-cl/site-feed && claude -p "Review open PRs not yet reviewed. Check against RULES.md and recorded decisions in _cons-changes. Post review comments via gh. Output a 5-line summary." --model haiku --allowedTools "Bash(gh:*),Read,Grep" >> /Users/ws/logs/pr-review.log 2>&1

New Ways to Use Claude Code

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

Make Claude look up decisions before asking
Start multi-repo tasks by having Claude collect existing decisions before it proposes or asks anything.
Your biggest friction categories are wrong_approach (34) and misunderstood_request (31). Many of these came from Claude ignoring decisions already recorded in other Cheap or uno-cl repos (currency, +03:00 offset, feed shape). One reviewer had to correct Claude three times in two days. A short 'decision sweep' at the start of a task, done by a subagent, prevents most of this. It also stops the unnecessary questions that made you angry.
Paste into Claude Code:
Before doing anything: use an agent to search _cons-changes, _cons-inbox, AGENTS.md, CLAUDE.md and sibling repos in /Users/ws/uno-cl for decisions related to this task. Show me a short list: decision | quoted text | full file path. Only then propose a plan, and ask me only questions that are NOT answered there.
Context-rich decision requests
Ask Claude to present any choice as a self-contained card: the full original text, current state, proposal, and location.
Your most frustrating sessions came from Claude saying things like 'decide on #3' or 'fix id9213' without showing what those referred to. The worst cases were the WhatsApp contact roles, the task 1.2 Google Doc, and the old developer tasks list. You've already found that side-by-side HTML review pages work well. Making that the default format for any decision cuts the back-and-forth.
Paste into Claude Code:
For every decision you need from me, show a card with: 1) the full original text quoted, 2) where it is (full /Users/ws/ path or doc section), 3) what you propose to change it to, 4) why in one line. No item numbers without the quoted text. Group cards by company/repo.
Cheap monitors instead of long-running watcher sessions
Move overseer, PR-review, and pipeline-check loops to script-based watchers that only wake Claude when something changes.
You run several 'watch other agents / PRs / blog posts / meeting transcripts' sessions. Many turns were spent on 'no new signal' answers. In one session Claude already built a token-saving watcher script, and you were happy with it. Make that pattern standard: a shell watcher detects changes and only then calls Claude headlessly, with a clear brief. This also gives each check a persistent log in the repo.
Paste into Claude Code:
Build a watcher script in /Users/ws/uno-cl/ops/watchers/ that polls (gh pr list, new commits, new transcript chunks) every N minutes with plain bash, and only when something new appears calls `claude -p` with Haiku and a focused prompt. Log every run to a .md file in the repo, and show me how to start it with launchd.

On the Horizon

Your usage already runs well past single-task chat: you have overseer agents, Orca execute-review-cleanup pipelines and live meeting co-pilots, so the next step is having agents check their work against your stated preferences and past decisions before you see it.

Decision-aware agents that check canon first
Two of your largest friction sources are wrong approach (34) and misunderstood request (31). Many of these were agents contradicting decisions you had already recorded, such as the +03:00 offset, the feed shape and the currency choice, or asking questions already answered in other Cheap repos. A pre-flight agent could search your decision logs, AGENTS.md files, MemPalace and sibling repos before any plan or question reaches you, and attach evidence to each choice. Questions would only reach you once the agent has confirmed the answer isn't already recorded.
Getting started: Set up a 'decision-check' Skill plus a PreToolUse or UserPromptSubmit hook that greps the decision files across uno-cl and the Cheap repos and injects relevant entries into context. A sub-agent can then audit each draft plan against those entries before it is shown to you.
Paste into Claude Code:
Build a reusable Skill called 'decision-check'. When invoked with a task description, it should: 1) search all repos under /Users/ws/ (especially uno-cl and the Cheap repos) for AGENTS.md, CLAUDE.md, RULES files, _cons-changes, /learn entries and the adhd-check canon, plus MemPalace, for decisions related to the task; 2) return a compact table of decision, source file with full absolute path and date, and how it applies; 3) list any question I'd otherwise be asked that is already answered, with the answer and its source. Then add a hook so that this Skill runs automatically before any plan is proposed or any AskUserQuestion is used. Test it on three past incidents: the +03:00 offset, the per-page feed shape and the currency decision. Iterate until all three would have been caught. Commit, push and record the rule with /learn.
ADHD-friendly output linter on every response
Several frustration episodes came from the same formatting problems: answers pointing to item numbers without showing the items, fragments like 'id9213' with no context, relative paths, the collapsed 'Files to check' block and missing icons. A Stop hook could run each response through a checker for your canon and send it back for rewrite before you ever see it. Decision requests would then always quote the full original message, the full path and the before/after, so you never have to reconstruct context yourself.
Getting started: Write a Stop hook script that reads the transcript's last assistant message and checks it against rules in your adhd-check canon. If a check fails, the hook blocks the stop and returns the failure reason so Claude rewrites the response.
Paste into Claude Code:
Read my adhd-check canon and all /learn entries about communication style. Turn every rule into a testable check, for example: 'no bare item-number references without the quoted item', 'all file paths absolute from /Users/ws/', 'Files to check block never collapsed', 'every decision request quotes the source message in full', 'proposed edits show the full before and after text plus the location' and 'required icons present'. Implement these as a Python Stop hook that blocks the stop and returns specific fix instructions when a check fails. Build a test suite from at least 10 real bad responses taken from my recent transcripts (WhatsApp contact roles, task 1.2 link fix, old dev tasks list) and 10 good ones. Iterate until all bad responses are flagged and none of the good ones are. Then install the hook globally, push the repo, and show me the final check list.
Parallel agent fleet with self-healing overseer
You already have an overseer that catches overlapping edits and destructive pushes, and an Orca pipeline that executes, reviews and cleans up. The next step is to have the overseer dispatch work rather than just watch. It would split a backlog, such as the four task-description rewrites or the old-dev-task migration, into isolated worktrees and run parallel executors. Each PR would be gated on tests, schema validation and a reviewer agent, with up to three fix loops before a merge or escalation. Communication-only work like Telegram sends and status recaps could be handled end-to-end so that the only messages reaching you are approvals that need a decision.
Getting started: Combine Orca workspaces or git worktrees with the Agent tool for parallel executors, SendMessage for overseer-to-agent nudges, and a cheap watcher script on a schedule. Fix the Telegram plugin connection and the bot-key guard first so that sends do not depend on you. Add workspace cleanup after merge to keep ~/orca/workspaces from growing back to 35 GB.
Paste into Claude Code:
Act as fleet overseer for the following backlog: [paste tasks]. For each task: create an isolated Orca workspace or git worktree, then spawn an executor sub-agent with the task, the relevant decision-check output and the acceptance criteria. Run up to 4 executors in parallel and make sure no two touch the same files (check this before dispatch and serialize any that overlap). Each executor must open a PR that passes tests and validation. After that, a separate reviewer sub-agent reviews the PR against RULES and my prior decisions, posts comments and sends it back; allow up to 3 fix rounds. Block any force-push or history rewrite. Merge PRs that pass, delete their workspaces and branches, and report disk freed. Escalate to me only for genuine judgment calls, with full quoted context and absolute paths. Send one consolidated Telegram summary at the end via the bot, without asking me to send it. Run a watcher script every 15 minutes rather than polling continuously, to save tokens.
"A user lying on the couch had Claude act as a voice-operated TV remote. Claude found the latest Osetinskaya interview about aging, played it, skipped ahead, raised the volume, moved it to the second monitor and made it fullscreen. Garbled voice input turned 'aging' (старение) into 'related to the condition' (связан с состоянием)."
This was a lazy-evening session. The speech-to-text mix-up took a few rounds of clarification, and a stubborn screensaver made the user ask again. In the end the video played fullscreen on the second monitor without the user getting up.