Claude Code
CLI-based AI coding assistant
A Committed Symlink That Points Outside the Worktree — Auditing Repos Before You Let AI Spin Up Parallel Trees
Claude Code 2.1.212 fixed a bug where a committed symlink under .claude/worktrees could be followed during worktree creation and write outside the repo. The patch closes the following side. Here is an audit script for the committed side, plus a quarantine workflow.
I Could No Longer Remember What I'd Changed in Auto Mode — Where claude auto-mode reset Fits In
Running nightly automation for weeks, I kept nudging my auto-mode settings one at a time. One morning a small oddity made me realize I could not recall what I had changed. Here is how I rebuilt my configuration around claude auto-mode reset as a known-good baseline, from a solo developer's field notes.
I Stopped the Headless Claude Code Job, but the Build Kept Running — Designing Teardown Around exit 143
In headless mode, a SIGTERM received while Claude Code was mid-Bash used to orphan the command's process tree. The 2.1.212 fix changes that to a clean exit 143. Here is how to redesign your supervisor and cleanup around that contract.
I Believed Plan Mode Only Read — Replacing That Belief With Machinery
Claude Code 2.1.212 fixed a bug where plan mode ran file-modifying Bash commands without the permission prompt or the SDK canUseTool callback. Here is what could happen while that assumption was broken, how to verify your own setup, and how to stop leaning on a mode name for safety.
Branch with /fork, Delegate with /subtask — Two Commands That Traded Jobs
In Claude Code 2.1.212, /fork now clones your conversation into a background session, and in-session subagents moved to /subtask. Here is how I decide between them, and the budgets worth setting before you start branching freely.
The MCP Server I Declared Vanished from the List — Designing Config for a Namespace You Share with the Vendor
When a vendor reserves an MCP server name, your .mcp.json declaration goes quiet instead of failing. Here is the preflight check and prefix convention I use to turn that silent gap into a loud stop before an unattended run.
The String I Approved Wasn't the String I Read — Testing a Relayed Permission Prompt with Deceptive Characters
I pushed bidi overrides and zero-width characters through my own approval relay. NFKC normalization caught 0%. Here is why, and the implementation that catches 100% with zero false positives.
My Nightly Subagents Ran, and I Couldn't Retrace Them — Trimming the Logs That --forward-subagent-text Unleashed
Subagent text and thinking can now flow into stream-json output, and unattended log volume climbs sharply with it. Here are measured numbers, a three-tier retention filter that keeps only what postmortems need, and a correlation ID design that survives missing fields.
The Morning My Table Ended in "… 2,847 more rows" — Separating Render Caps from Token Cost in Tool Output
Claude Code 2.1.209 caps markdown tables at 200 rows plus a remainder count. Only the rendering is capped — the model still receives every row. Here is how to measure the gap and redesign tool output around aggregates.
The Permission Rules You Added for Safety Are Taxing Every Turn — Auditing the Ruleset Without Loosening It
Version 2.1.209 fixed the per-turn slowdown from large deny/ask rulesets, but the design debt in your rules is still yours. Here are the audit scripts, a shadowing detector, a turn-timing harness, and how to fold enumerated rules into prefix rules safely.
Your Overnight Session Wakes Up at 3GB — Four Places Memory Piles Up, and How to Tell Them Apart
The Claude Code process I left running overnight had grown to 3.4GB of resident memory by morning. Here are the four accumulation sources closed in 2.1.209, how to separate what's left in your own setup by sampling RSS slope, and a watchdog pattern that folds a session before it hurts.
Switching Claude Code to Plain-Text Rendering — Three Ways In, and What Your Logs Actually Weigh
I opened last night's Claude Code log and found the same spinner line stacked dozens of times. Here are the three ways to turn on screen reader mode, a short script that measures what escape sequences and redraws really cost you, and what you give up when the rendering goes plain.
Keeping Unattended Logs Readable — Measuring axScreenReader's Plain-Text Rendering Before Adopting It
Piping Claude Code into a log file leaves you with escape codes and redraw debris instead of an answer. Here is how I enabled axScreenReader across its three entry points, measured the difference on one real task, and moved my unattended runs over to it.
Choosing Dynamic Workflow Size and Effort From a Ledger, Not a Hunch
Dynamic Workflows went generally available, handing you the workflow size and effort dials. After a week of picking large and watching only the bill grow, here is how to turn Claude Code's OpenTelemetry console output into a ledger and assign size and effort per task type.
Answering auto mode's confirmation prompts in headless runs — a deny-by-default permission-prompt-tool
auto mode's confirmation step is a friend when you're at the keyboard, but in an unattended midnight run it becomes the reason a job sits waiting until morning. Here is how I catch those prompts with permission-prompt-tool, decide deny-by-default, and log every ruling — with working code.
The Types Landed, but Nothing Got Safer — Where I Delegated a JS→TS Migration to Claude Code, and Where I Didn't
A green tsc run does not mean any is gone. Measuring a migration by type coverage, drawing a clear line between what Claude Code handles well and what a human must decide, and a CI ratchet that refuses regressions.
One Day My Push Had an Extra Destination — Guarding Against /commit-push-pr Pushing to Remotes Beyond origin
The July 14 update made /commit-push-pr push to configured push remotes in addition to origin. Convenient, but if you keep a mirror or backup as a second remote, unintended pushes quietly multiply. Here is how to inventory which remotes you can push to, block anything off the allowlist with a pre-push hook, and keep unattended runs safe — with working code.
An Empty Variable and rm -rf: How Claude Code's Auto Mode Preflight Saved My Late-Night Cleanup
One night I let Claude Code sweep the build caches out of several app repositories at once, and an empty variable nearly turned a targeted cleanup into a wide delete. Here is the field record of being saved by auto mode's rm -rf preflight, and the confirmation rules I built afterward.
My MCP Timeout Was Being Ignored, and Every Call Died at Exactly 60 Seconds — Reclaiming Per-Server request_timeout_ms
A longer MCP tool call kept dying at exactly 60 seconds, ignoring the wait I had set. The cause: a per-server request_timeout_ms in .mcp.json that was never read, silently falling back to the default. Here is the correct placement after the fix, how to back the value out from a tool's response profile, and how to verify the cutoff yourself — with working code.
Carrying Decisions Across Compaction with PreCompact and SessionEnd Hooks
Auto-compaction does not delete your conversation. It deletes the reasons behind it. Here is a working PreCompact / SessionEnd / SessionStart hook pipeline that rescues decisions to disk and hands them to the next session, with real code and measurements.
Is the Draft That Passed the Gate the Same One You Published?
In unattended pipelines, the file your quality gate inspected and the file you actually publish can quietly diverge. Here is a digest-bound gate receipt design, with working code and measured results from 180 days of running it.
Claude Code vs Cursor: The Definitive 2026 Comparison — Choosing the Right AI Coding Tool
A comprehensive comparison of Claude Code and Cursor across pricing, features, accuracy, and workflow. Find the AI coding tool that best fits your development style with our 2026 data-driven guide.
Auditing Your Own Code for Required Reason API Declarations with Claude Code
Required reason codes in PrivacyInfo.xcprivacy apply to your own code, not just third-party SDKs. After a wallpaper app of mine was rejected, here is the Claude Code workflow I use to scan Swift sources and match APIs to reason codes before submission.
I Could Detect Failures — Then the Alerts Grew So Loud I Stopped Noticing
The moment I could detect silent job failures, my phone started buzzing too often to be useful. Here is how I collapsed alerts by action rather than event, added hysteresis and quiet hours, and built a three-step escalation so only the pages worth waking me survive.
My background session sat at running all night — adding heartbeats to the agents view
The Claude Code agents view finally lets you see every background session at once, but a running badge is not proof of progress. Here is the external heartbeat layer I built to catch a silently stalled session in minutes instead of the next morning, with real numbers and the traps I hit.
Which Nightly Job Wrote This Commit? Threading a Correlation Key Through Claude Code's Readable Session Names
When you run unattended nightly jobs across several repositories, you lose track of which session produced which commit. Here is how I redesigned Claude Code's readable session names into a correlation key that ties commits, logs, and sessions into a single thread — with real numbers.
I Was Starting the Ad SDK Before the Consent Dialog — Fixing ATT and AdMob Ordering with Claude Code
Starting the ad SDK at launch initializes it before ATT consent, so the IDFA is all zeros and only your measurement goes thin while fill rate stays fine. Here is how I traced the scattered init paths with Claude Code and reshaped them to start ads only after ATT resolves.
Rolling Out Trusted Devices for a Small Team: Enrollment, Preflight, and Rotation
How to introduce Team/Enterprise Trusted Devices for a 2-5 person team: device enrollment, an unattended-run preflight gate, and closing the gaps that appear during device rotation and offboarding.
When to Use Claude Code's Native 1M Context — and When Not To: A Cost-Based Rule
With Sonnet 5 as the default, Claude Code now handles a native 1M-token context. A big window is convenient, but every token you park in it is billed again each turn. Should you load the whole repo, or feed slices? Here is an estimable token model and a decision rule that gives a concrete answer per situation, with working code and the traps to avoid.
A 1M Context Window Is the New Default — So I Built an Admission Policy Instead of Filling It
Sonnet 5 is now the Claude Code default and native 1M context is standard. The hard errors disappeared, but a quieter kind of degradation took their place. Here is how I made it visible with a probe, plus an admission policy and an effective-token-cost view — with working code and my own measurements.
Keep the Extra Capacity Out of Your Baseline — Burning Backlog During the Time-Boxed +50% Weekly Limit
Claude Code's weekly limits are raised 50% until July 13. A design for spending the temporary headroom only on finite backlog work: an expiry-aware burst queue, a dual-lane ledger, and a single ratio that tells you whether your baseline quietly grew.
Five Minutes of Silence, and Something Retries on Your Behalf — Rethinking Retry Ownership After the Streaming Idle Watchdog Became a Default
Claude Code's streaming idle watchdog is now on by default, quietly adding another retrying layer to your stack. This article inventories the four layers (SDK, wrapper, watchdog, scheduler), computes worst-case attempt amplification, and shows how to collapse retry ownership into a single layer.
When a Claude Code Refactor Passes Every Test but Behaves Differently in Production — Catching Silent Contract Drift with a Behavior Diff Harness
Hand Claude Code a large refactor and your tests can stay green while production behavior quietly shifts. Here is how I record exception channels, log shape, init order, and return values as a signature, then diff them per commit to catch contract drift before it ships.
Which Model Ran Last Night's Unattended Session? Building Model Attribution and Default-Drift Detection After the Sonnet 5 Switch
Claude Code's default model switched to Sonnet 5, and unpinned headless runs changed models silently. Here is a working design for extracting the actual model from run output, appending an atomic run record, and deciding per task lineage whether to pin or follow the default.
Don't Accept an Agent's Numbers and Citations As-Is — A Verification Gate Built on a Dedicated Auditor Subagent
A design that verifies every number and citation in an agent-generated summary using a separate subagent before accepting it — with working TypeScript for deterministic recomputation and fail-closed source matching.
My Claude Code Hooks Stopped Firing After an Update — the Hyphenated Matcher Exact-Match Change in v2.1.195
In Claude Code v2.1.195, hook matchers containing a hyphen switched from partial match to exact match, silently disabling an existing PreToolUse hook. Here is how I isolated the cause and how to write matchers that won't break.
Fixing Blurry Wallpapers on New iPhones with Claude Code: Safely Growing a Per-Device Resolution Map
Why wallpapers go blurry or letterboxed on brand-new iPhones, and how to collapse scattered device branches into a single source of truth you can extend in one line — walked through as a real Claude Code refactor with before/after code.
Borrowing the Trusted Devices Idea for a Solo Setup: Pinning Automated Runs to Devices You Approved
The Trusted Devices feature that landed in Claude Code on June 28, 2026 is for Team and Enterprise. You can't use the feature on a solo plan, but you can borrow the idea. Here is how to identify a device in a way that doesn't break, and stop any automated run that starts from a device you never approved — with working code and the traps to avoid.
When You Fan Out Streaming Sessions, Your Laptop's CPU Gives Out First — An Adaptive Throttle That Caps Concurrency by Measured Load
Even with lighter streaming, fanning out many sessions on one machine saturates the host CPU before anything else. Here is why a fixed semaphore fails, plus a working adaptive gate that raises and lowers concurrency from measured CPU.
Stop Leaving a Static API Key in Your Unattended Jobs — Move to Short-Lived WIF Credentials
Claude Code is moving from static API keys toward short-lived, scoped credentials via WIF (Workload Identity Federation). Here is how to translate that idea to a small unattended pipeline so a leaked key has a much smaller blast radius — with working code and the failure modes to watch.
When an OAuth Token Expires, Your Unattended Run Has Nowhere to Go — A Token-Lifecycle Design That Keeps Remote MCP Alive
Remote MCP connectors are authorized via OAuth, but access tokens are short-lived. Interactive sessions can re-authorize in a browser; an unattended scheduled run has nobody to click the dialog. Here is a token-lifecycle design that owns expiry and refreshes ahead of time.
Will It Stay Light When You Run It Unattended? Observing and Capping Claude Code's Long-Session Memory
How to keep long, unattended Claude Code sessions from slowly getting heavier — with a tiny ps-based RSS sampler, a rolling-baseline watchdog, and session segmentation, shown with working scripts and a before/after comparison.
When You've Gone Five Steps in the Wrong Direction: Rewinding Conversation and Code with Claude Code's /rewind
Claude Code's /rewind is a safety net that returns both conversation and code to an earlier checkpoint. Here is how it differs from git, what it restores, and the pitfalls that bite in automated runs.
We Collected Plenty of Claude Code Usage Data — Then Budgeting Still Didn't Work. Field Notes on Cost Attribution and Idle Seats
The Claude Code Analytics API gives you data, but data alone doesn't run a budget. Here are field notes on turning raw usage logs into cost attribution, idle-seat detection, and alerts that don't cry wolf — with working code and the thresholds we actually use.
The Day a Non-Responding MCP Call Swallowed an Entire Unattended Run — Owning the Stop With Your Own Deadline
When a remote MCP tool call stops responding, an unattended scheduled run just keeps waiting. Instead of leaving the cutoff entirely to the platform, here is how I designed my own deadline and a per-connector circuit breaker to own the stop — with working code.
Higher Rate Limits Don't Mean Tighter Schedules — Spend the Headroom on 429 Recovery
When Claude Code's rate limits went up, the instinct was to pack the schedule tighter. Here's why I did the opposite and routed the new headroom into retry budget instead — a pacing note for unattended pipelines.
Your Sandbox Can Run the Code but Shouldn't Read Your Credentials — Shrinking the Secret-Read Surface with sandbox.credentials
Claude Code's sandbox can still read ~/.aws/credentials and token env vars by default. Using sandbox.credentials (v2.1.187+), here is how I tightened the secret-read surface of unattended runs at the OS level, with config and verification you can reuse.
Productionizing a Claude Design Prototype — Single Source, CI, and OGP Auto-Generation
Turn a Claude Design prototype into something that survives production with Claude Code. The call to keep the generated runtime as your foundation, separating logic with a mixin, a single-source data design around a ledger CSV, and CI auto-updates with real-browser OGP capture — implementation included.
I Watched an Agent Try to Fix a File It Had Already Fixed — Stale Shallow Clones and Refreshing Before You Decide
An unattended agent tried to re-fix a file it had already fixed. The cause was a days-old shallow clone it kept reading. Here is how to detect that staleness numerically and re-clone only before decisions.
Working Between Claude Design and Claude Code — Splitting Diverge and Converge
Rough design in Claude Design, fine detail in Claude Code. Now that the two live close together in the desktop app, here is how to run them as a divide-of-labor between diverging and converging — bridges like Link Local code and Send to included.
When Claude Code Still Writes Stale Code With Context7 Installed — Verifying the Injection Actually Worked
You installed Context7 MCP, yet Claude returns code against a deprecated API. Most of the time the documentation injection silently no-ops. Here are field notes on a hook that detects misses, pinning doc versions, and a harness that checks generated code every time.
Keep MCP Connector Authorization in One Place — A Solo Dev Design That Survives Growing Integrations
When Claude chat, Claude Code, and Cowork each configure the same MCP connector separately, their authorization drifts apart and breaks silently. Here is how to borrow the managed-connector idea of 'provision once, reuse everywhere' as an indie developer.
Handing Claude Design Mockups Straight to Claude Code: Folding the Design-to-Code Loop
The June 17 Claude Design update added codebase-aware generation. Here's how to make your tokens the single source of truth, hand mockups to Claude Code, and collapse the design-to-code round trip — with code you can copy.
Noticing From the Outside When a Scheduled Job Quietly Did Nothing
exit 0, but zero output. How to catch a silent no-op not from the job's own log but from an external heartbeat ledger and ground truth, written from running several sites on a nightly schedule as an indie developer.
An Article My Gate Rejected Got Published — The Cost of Chaining the Quality Gate and git push in One Call
In an unattended publishing pipeline, an article my quality gate had rejected went live anyway. The cause was chaining the gate and git push into a single shell call. Here is how the exit code gets swallowed, and a two-phase publish-marker design that refuses to push until every gate has demonstrably passed.
Claude Code Adds /cd — Carrying Your Warm Cache Across Repositories
Claude Code's new /cd moves a running session to another working directory without rebuilding the prompt cache. Here are the design calls and pitfalls when you sweep across several repositories in one sitting.
Moving Cleanup and Logging into a SessionEnd Hook
How to use Claude Code's new post-session hook to automate temp-file cleanup and log writing after a session ends, with real examples from a pipeline that processes several repositories in sequence.
Give an Unattended Agent Only the MCP Tools It Needs — Enforcing a Deny-by-Default Policy
An unattended Claude Code agent can't lean on a permission prompt, so whatever a tool can reach becomes the blast radius. Here's how to lock MCP servers and tools down to deny-by-default and hand back only what the job needs, with managed-settings.json examples.
When a Broken settings.json Stops Claude Code From Starting — Safe Mode and How to Split Your Config
How to find which config layer is broken when a settings.json syntax error stops Claude Code from starting, recover in minutes, and structure your settings so an automated pipeline can't quietly break itself.
The Day a Billing Change Got Reversed at the Last Minute — Designing a Reversible Pipeline So You Don't Rewrite in a Panic
A billing change due to take effect on June 15 was retracted at the eleventh hour. From the position of someone who had literally logged 'effective today' the night before, here is why I didn't have to scramble to rewrite my headless stages, and how to build a pipeline that survives reversals and delays — with working code.
When an Announced Billing Change Gets Paused at the Last Minute: Designing Automation That Doesn't Rush the Cutover
A billing change that was supposed to take effect on June 15 was paused that same day. If your pipeline trusts the announced date, a retraction breaks it twice. Here is a design that decides the cutover from a runtime signal, with implementation code.
When an Announced Billing Change Is Withdrawn at the Last Minute, Change No Code
A billing change that was supposed to take effect was withdrawn on the day. To survive announce, apply, and revert without touching code, I keep platform behavior behind a single flag and project the monthly delta from real logs.
It Says '500' in the Browser but curl Returns 200 — When a Next.js Error Boundary Misreads a ChunkLoadError
A production Next.js article page shows '500 Internal Server Error' in the browser, yet curl returns 200. The culprit was not the server but a ChunkLoadError surfacing through error.tsx. Here is the diagnosis and a fix with built-in auto-reload.
Keeping Large Claude Code Refactors Revertible One Commit at a Time — Field Notes on Checkpoints and Rollback Detection
Hand a big refactor to Claude Code and the speed hides a real cost: review-proof, oversized diffs. Here are the field notes I actually run — declaring checkpoints in a manifest, enforcing commit granularity with a pre-push hook, and tying rollback calls to observability.
Two Days Into the Billing Change: How Far My Headless Costs Drifted From the Estimate
On June 15 the billing change moved headless execution onto separate monthly credits. Two days in, I broke down cost per pipeline stage and found one stage running at roughly double my estimate. Here is how I measured it, and why I moved one stage back to my subscription.
Before Per-PR CI Burns Through Your Monthly Credits: A Three-Layer Guard for Claude Code GitHub Actions
From June 15, Claude Code GitHub Actions bills against non-rolling monthly credits. Run a review on every PR and you can drain the month in the first week. Here is a three-layer guard — when to run, how heavy one run can get, and making spend visible — with working workflows.
Finding and Installing Claude Code Plugins from a Marketplace — Read What's Inside Before You Trust It
A practical walkthrough for discovering and installing Claude Code plugins from a marketplace. Beyond the /plugin commands, it covers how to read the bundled contents before you install, and how to choose between User and Project scope.
A SubagentStop Hook That Grades Subagent Output and Sends It Back to Be Redone
When a Claude Code subagent occasionally returns rule-breaking work, a SubagentStop hook can grade it automatically and ask for a redo. Here is a working setup with code and field notes.
Pacing Non-Rollover Monthly Credits: A Burn-Rate Scheduler That Avoids Both Early Exhaustion and Wasted Balance
Non-rollover monthly credits punish you for spending too fast and for spending too slow. Here is the design of a scheduler that derives a daily burn rate from remaining balance and days left, throttles headless runs automatically, and the real numbers from running it on a personal automation setup.
Running Claude Code Hooks as a Quality Gate Without Breaking Your Pipeline
An implementation note on running Claude Code Hooks as a safety valve for automation: when to block with exit code 2 versus JSON output, how to keep formatters from looping or over-blocking, and how to log every hook firing so misfires are traceable.
Measuring a Week of Headless Usage the Night Before the Billing Change
With headless Claude Code moving to monthly credits on June 15, I spent a week logging how many tokens my unattended runs actually consume, so I could pick a plan based on numbers instead of a guess.
What the June 15 Claude Code Billing Change Means for Headless Runs
From June 15, 2026, the Agent SDK, headless claude -p, GitHub Actions, and third-party agents move to monthly credits. Here's how a solo developer running automation decided what to keep and what to cut.
Pin Your Execution Model with enforceAvailableModels — Don't Let Auto-Upgrades Burn Through Your Credits
From June 15, monthly credits become non-rolling. This is a setup-layer approach to keep subagents and fallbacks from silently upgrading to pricier models, using enforceAvailableModels to pin the model set from the managed-settings layer, with a verification step you can run in CI.
Context Budgets for Nested Subagents: Designing Contracts So 5-Level Delegation Doesn't Lose Quality
Once subagents could nest, deeper delegation made summaries thinner and reruns more frequent. Here is how I rebuilt quality by adding four contracts between layers: token budgets, a handoff schema, failure isolation, and an independent grader.
Shipping Production-Quality Go REST APIs with Claude Code — Gin, GORM, Docker, and CI/CD with the Judgment Calls That Matter
A hands-on walkthrough of building a production-quality REST API with Claude Code and Go — Clean Architecture with Gin and GORM, graceful shutdown, minimal Docker images, and GitHub Actions, with the operational judgment calls AI won't make for you.
How Deep Should Nested Subagents Go? Rethinking My Delegation Tree After Claude Code's 5-Level Limit
Claude Code subagents can now spawn their own subagents, up to five levels deep. I rebuilt my automation around nesting and settled on three levels — here is why.
When Your Edited SKILL.md Doesn't Take Effect — Hot-Swapping Claude Code Skills with /reload-skills and Auto-Loaded .claude/skills
A practical routine for hot-swapping Claude Code skills without restarts: /reload-skills, SessionStart hooks, and version stamps that show which SKILL.md is live.
A Three-Tier fallbackModel Setup for Claude Code — Keeping Unattended Runs Alive Through Overload Mornings
How I run Claude Code with a three-tier fallbackModel chain so overnight batches survive overload errors: logging which model actually ran, measuring quality drift on fallback days, and pairing it with deny rules.
Fixing Overlapping Paywall and Review Dialogs on Android with a Central ModalGate
How I fixed three dialogs — paywall, review prompt, and rewarded-ad promo — stacking on top of each other with a priority-based central gate, plus the three dismiss-leak paths a Claude Code design review uncovered.
Untangling Android Back-Button Ad Gates: A Parallel, Priority-Ordered Redesign with Claude Code
Nested back-button ad gates fired at the wrong moments. The parallel, priority-ordered redesign we shipped in v2.1.0, with Claude Code, Kotlin, and tests.
Stopping Claude Code Before It Runs a Destructive Command — a PreToolUse Screening Hook
How I wired a PreToolUse hook that screens every Bash command Claude Code is about to run: the settings.json setup, the Python screening script, what exit code 2 really does, and the false positives I tuned out over several weeks.
When git add -A Sweeps Up .bak Backups — The Quiet Trap of In-Place Fix Scripts
How .bak backups left by sed -i and homegrown --fix scripts get silently swept into production by git add -A, why it is so easy to miss, and how scoped adds and .gitignore close the gap for good.
When Yesterday's Article Bleeds Into Today's — The Stale Fixed-Name Temp File Trap
In a Claude Code automation pipeline, a fixed-name temp file kept stale content from the previous run and leaked old body text into a completely different article. Here is why the write fails silently, and how unique names plus a post-write grep check prevent it.
Clearing Crashlytics 'Missing dSYM' Warnings with Claude Code: A Field Memo
Right after moving Firebase to SPM, my Crashlytics reports stopped symbolicating and showed raw addresses. Here is how I narrowed down the Missing dSYM cause with Claude Code and rebuilt an upload path that does not break again.
Triaging iOS Test Failures Fast: Parsing .xcresult with Claude Code
Xcode 16 deprecated xcresulttool's legacy JSON, changing how you pull test failures out of a .xcresult bundle. Here's how to shape the new test-results format with jq and hand it to Claude Code to pinpoint the cause and a fix, drawn from running six apps in parallel.
When git push Says Success but Nothing Lands — the Silent commit Failure in Claude Code
git push prints Everything up-to-date and exits zero, yet your changes never reach the remote. Here is why commit silently fails on a fresh sandbox clone, and how to verify a real push with SHA comparison.
Fixing Claude Code's 'Credit balance is too low' Error
You launch Claude Code and it immediately stops with 'Credit balance is too low' — even though you have an active subscription. The error looks like a money problem, but it is almost always a mismatch in which auth path is billing you. Here is how to tell them apart and fix it: switching auth routes, topping up credits, and setting auto-reload.
Two Weeks of Splitting iOS Work Between Claude on Xcode and Claude Code
I ran Claude on Xcode, which lives in the Xcode sidebar, alongside Claude Code in the terminal across two weeks of real wallpaper-app work. Here is how I ended up dividing the tasks, and the simple rule I use to decide which one to open.
Fixing 403 Write Access to Repository Not Granted When Pushing from Claude Code
When Claude Code automation pushes to GitHub and hits a 403 'Write access to repository not granted', the cause usually lies in how fine-grained PATs differ from classic ones. Here's how to diagnose repository access, Contents permissions, and org approval.
Moving Firebase From CocoaPods to SPM With Claude Code as a Partner: An Implementation Memo
A record of migrating Firebase from CocoaPods to Swift Package Manager in an indie iOS app. What I handed to Claude Code, what I decided myself, and the Crashlytics dSYM trap I hit along the way.
What to Do When Claude Code Hits the Context Window Limit
Long Claude Code sessions eventually hit the 200k token limit and stall. Here's how to use /compact, --continue, and session design patterns to keep development moving without losing context.
Claude Code vs. Claude in Chrome: Where I Draw the Line in Daily Ops
Running apps solo means constantly hopping between an editor and a browser, and that hopping quietly drains your focus. Here is how I split work between Claude Code and Claude in Chrome over a month, plus the rule I use when a task straddles both.
Designing Skills That Stabilize Output: Template Fixing and Decision Guides in Claude Code
A practical design guide for stabilizing wobbly Claude Code skill output: stating when to use it, decision-guide tables, fixing quality with references templates, and traceability rules, with code from real operations.
The Second Half of My SKILL.md Wasn't Being Read: Keeping It Under 200 Lines
Sparked by an observation that Codex CLI stops reading SKILL.md at around 220 lines, a look at how long an agent actually reads, and how to keep SKILL.md under 200 lines by offloading detail into references.
Authoring Dynamic Workflows: Building Reusable Research Pipelines with phase / agent / pipeline
A hands-on guide to writing your own Claude Code Dynamic Workflows: the phase / agent / pipeline / parallel primitives, locking outputs with JSON Schema, porting the adversarial-verification pattern, and designing for token cost.
Why git Says detected dubious ownership in repository — and How to Get Past It
An automation that ran fine yesterday suddenly dies on detected dubious ownership in repository. Here is what actually triggers it, the safe.directory fix, and how it differs from a real Permission denied.
Running Claude Code's Dynamic Workflows: What I Learned About Orchestrating Subagents
A hands-on walk through Claude Code's Dynamic Workflows (v2.1.154): running /deep-research, enabling the feature, watching progress with /workflows, and saving a workflow for reuse, from an indie developer's angle.
Hand Claude Code a One-Line Done-When and Let It Run — Inside My Four-Site Article Pipeline
How I built an E2E-driven article pipeline that runs Claude Code autonomously across four AI blogs, publishing 16 articles per day. The trick is collapsing the done-when into a single Python gate and capping retries at five.
The Six-Step Order I Use Before Handing Claude Code to Non-Engineers — A Rollout Design for Tiny Teams
I took CyberAgent WINTICKET's six-session Claude Code training for business roles and compressed it into a rollout sequence that fits a solo indie developer or a tiny team. Covers Permission design, supply-chain defense with pnpm, Managed Settings, and shipping a first real PR.
Claude Code × Xcode Cloud — A One-Week Migration of ci_scripts and TestFlight Auto-Delivery
Notes from migrating a long-running indie iOS CI from Fastlane to Xcode Cloud in one week, with the three ci_scripts/ hook scripts in full, TestFlight automation, and dSYM upload — all paired with Claude Code.
The Morning I Hit Cloudflare Workers' 62 MiB Limit, and the Content Split Architecture I Rebuilt for 5,000 Articles
One morning, an indie developer running 4 AI tech blogs on Cloudflare Workers + Next.js woke up to a deployment that had stopped because articles.json grew large enough to push the Worker bundle past the 62 MiB limit. This is the concrete implementation walkthrough of splitting metadata from HTML, with the build-time and bundle-size numbers observed across the first month.
How Claude Code Helped Me Kill a Glide 5.0.5 Java 8 Crash with One Line
After Beautiful HD Wallpapers v2.0.0 shipped, every Android 6.0.1 user crashed within 3 seconds. The fix turned out to be a single missing line in build.gradle.kts — and Claude Code is what got me there.
11 Days in Crashlytics: A Claude Code Debug Loop on a 50M-Download Android App
After shipping Beautiful Wallpapers v2.0.0 and Ukiyo-e Wallpapers v1.7.0 in early May, Crashlytics and Play Console threw more than 30 new issues at me in 11 days. This is the operations log of how I drove the fix list down to v2.1.1 / v1.8.1 using Claude Code as a triage partner.
When Claude Code's Bash Tool Hits Permission Denied on /tmp — A $HOME/repos Fallback Pattern
A practical look at why git clone inside Claude Code's sandboxed Bash sometimes fails with Permission denied on /tmp, and how a tiny $HOME/repos fallback keeps unattended schedules alive across four indie sites.
Four Weeks With Claude Code: Driving Xcode Warnings to Zero in an Indie iOS Codebase
An indie iOS developer behind 50M+ downloads pairs with Claude Code for four weeks to clear hundreds of accumulated Xcode warnings. Notes on weekly scope, what to delegate, and the boundary where human judgment still wins.
Fixing Garbled Japanese Files in Claude Code — Identifying Shift-JIS vs UTF-8 and Converting Safely
When the Read tool spits out characters like 縺ゅ＞縺ゅ＞ instead of Japanese, the file is almost always Shift-JIS or EUC-JP being misread as UTF-8. Here is a practical workflow to detect the real encoding and convert it for Claude Code, drawn from running a Japanese wallpaper app since 2014.
Wiring Chrome DevTools for agents 1.0 into Claude Code: a setup memo
Google shipped Chrome DevTools for agents 1.0 as a stable release. Here is how I wired it into Claude Code, why I picked the MCP path over the CLI, and how it compares to the version bundled in Antigravity 2.0.
How I Stopped Claude Code's 'File has been modified since read' Error From Recurring
If Claude Code keeps tripping over 'File has been modified since read it' partway through a long session, the cause usually narrows down to three settings. Here is what actually worked in my own setup.
Notes from Seven Months of Running a Four-Site Auto-Publishing Pipeline with Claude Code and GitHub Actions
Lessons from running Claude Code scheduled tasks to auto-publish 16 articles a day across four Lab sites, including the Helpful Content System index collapse that forced a redesign of the quality gate, with the full Python gate code, token management, and rollback procedure.
Three State-Passing Patterns for Claude Code Subagents — Lessons from 4 Months of Automated Blog Pipelines
JSON files, environment variables, and context bundles — three ways to hand state between Claude Code subagents, compared with four months of production data and clear guidance on when to pick each.
Putting an Autonomous Librarian on Top of Claude Code × Obsidian — Operating Notes From Running Four Sites Through a Three-Layer Knowledge OS
Starting from Andrej Karpathy's LLM Wiki idea, I redesign a Claude Code × Obsidian autonomous knowledge OS against the actual shape of running four AI tech blogs in parallel. The article covers the three-layer storage, ingest/compile Skills, Dataview monitoring, and a weekly audit job — all sized for real production use.
Five Filters I Use Before Wiring a Claude Code Skill Into My Daily Workflow
Public Claude Code Skills keep multiplying. As an indie developer running four AI tech blogs through Claude Code, I share the filters that decide which Skills stay in my daily workflow — and which ones I quietly remove after a few days.
Recovering from Claude Code's 'Tool result could not be submitted'
What 'Tool result could not be submitted' really means in Claude Code, and the practical recovery steps I rely on after years of running indie apps with 50M+ downloads through it.
When Claude Code's Sequential Edits Cascade into Failure — Fixing 'old_string not found' and 'not unique' on the Same File
Run several Edits against the same file in one turn and the second or third one suddenly fails with 'not found' or 'not unique'. The cause is order-dependence inside a single context snapshot, and a Read + scoped patches usually rescue it.
Automating iOS Crashlytics Triage with Claude Code — A Production Pipeline from dSYM Symbolication to Draft PR
How I rebuilt iOS crash triage at our 50M+ download app studio: Firebase Crashlytics issues flow into a Cloud Functions + Claude Code pipeline that handles dSYM symbolication, blast-radius estimation, and a draft fix PR in under 90 seconds. Real numbers, real code, real lessons.
Retiring Dormant SDKs with Claude Code — A 12-Year Indie Developer's Pipeline for Safely Auditing Inactive Dependencies
Twelve years of indie iOS/Android development leaves a quiet sediment of SDKs that nobody calls anymore — but the dependencies remain. Here is the Claude Code pipeline I built to audit and safely retire them across four wallpaper apps, with the actual code and four weeks of operational metrics.
A Daily Revenue Pipeline for 4 Wallpaper Apps: 8 Weeks Running App Store Connect API + AdMob With Claude Code
An 8-week record of running App Store Connect API and AdMob Reporting API through a Python pipeline for 4 iOS wallpaper apps, with Claude Code helping absorb JWT auth quirks, gzip TSV edge cases, timezone misalignment, and Slack alerting thresholds — written from an indie developer's perspective.
Notes from May 2026: Running a Parallel StoreKit 2 Migration Across Four iOS Wallpaper Apps with Claude Code
Operational notes from running a four-app iOS StoreKit 2 migration in parallel with Claude Code on a single Mac mini M5, captured during May 2026.
Skill, Subagents, and Rules in Claude Code: A One-Hour Implementation Loop That Fits a Solo Operator
Misaki Ito at SonicGarden wrote about wiring Claude Code's Skill, Subagents, and Rules to close a week's worth of low-priority work in one meeting. Here is how I adapted that pattern as a solo developer running a 50M-download app business.
Three Months of Letting Claude Code Handle the Monthly Content Refresh for My Four Wallpaper Apps
Starting in February 2026 I began handing off the monthly content refresh of my wallpaper apps — Beautiful HD Wallpapers and three sibling titles — to Claude Code. After three months I want to share what kinds of judgement I felt comfortable delegating, and where I deliberately kept my own hands on the work.
Why Claude Code Breaks Your MDX Frontmatter With YAML Errors (and How to Fix It)
If you have ever let Claude Code mass-produce MDX articles, sooner or later your build dies with a cryptic YAML error. Nested double quotes, stray colons, comma-joined tag entries — here is what is actually happening and the five patterns I trust in production.
Six Weeks Running a Claude Code Hooks + SwiftLint Quality Gate on My Indie iOS Apps
A six-week field report on wiring SwiftLint into Claude Code's PostToolUse hook to keep my indie iOS codebases consistent. Motivation, implementation, three adjustments that mattered, and the rough edges I hit along the way.
Claude Code Hook `command timed out`: Timeout Settings and Split-Execution Patterns That Actually Work
Fix Claude Code's `command timed out` hook failure without just bumping the timeout. Includes practical split-execution, detached background jobs, and a settings.json layout that keeps your session fast.
Claude Code Says 'All Tests Pass' but CI Goes Red — Designing Around Exit Code Pitfalls
Locally, Claude Code reports 'all tests pass.' You push it, and GitHub Actions turns red within minutes. The root cause is usually not Claude Code itself but how the shell and the test runner interpret exit codes. Here is a practical, experience-backed walkthrough.
Pruning Custom Subagents in Claude Code: After Six Months, Five Became Two
I built five custom subagents in Claude Code, ran them across six sites for six months, and ended up keeping only two. Here are the notes I took along the way — what worked, what didn't, and how I learned to write subagent descriptions that actually get called.
Why Claude Code's WebFetch Returns 403 or Empty Pages — and How to Fix It
When Claude Code's WebFetch returns a 403, or a 200 OK with the body mysteriously empty, there are really only four root causes worth checking. This walkthrough breaks them down — Cloudflare bot protection, client-side rendering, the allowed-domains gate, and stale caches — with the practical responses I use in production.
Running Apple Privacy Manifest as an Indie Developer — Catching Dependency Drift with Claude Code
Apple Privacy Manifest (PrivacyInfo.xcprivacy) is a quietly painful area for indie iOS developers. Drawing on twelve years of running iOS apps with over 50 million combined downloads, this article walks through how I use Claude Code to detect drift, respond to rejections, and bake the whole flow into CI.
Why Your `cd` and `export` Vanish Between Claude Code Bash Calls
Claude Code's Bash tool runs each call in a fresh shell, so cd and export never persist. Here's the symptom, the cause, and five practical patterns I use across my Dolice Labs pipelines.
Automated Play Store Staged Rollout Monitoring with Claude Code — Lessons from 50+ Crashes in v2.0.0
A hands-on record of building a Claude Code-powered monitoring system for Android staged rollouts (5%→100%). Covers crash-free rate thresholds, Wilson confidence intervals, and automatic Go/No-Go decisions — based on real experience shipping Beautiful HD Wallpapers to 50M+ users.
Six Months Until CocoaPods Shutdown — Migrating Beautiful HD Wallpapers to Firebase SPM with Claude Code
Firebase Apple SDK is dropping CocoaPods in October 2026. Here's how I migrated Beautiful HD Wallpapers — one of four iOS apps I run as an indie developer — to Swift Package Manager, and where Claude Code made the difference.
How I Fixed Android RecyclerView Crashes in 28 Days Using Claude Code
After releasing v2.0.0 of Beautiful HD Wallpapers, RecyclerView IndexOutOfBoundsExceptions hit 50+ users over 28 days. Here's how a conversation with Claude Code uncovered the root cause — a defensive copy pattern.
Eliminating SwiftUI Animation Guesswork with Claude Code — Prompt Patterns from a 50M Download Wallpaper App
How to use Claude Code for SwiftUI animation work — practical prompt patterns and Before/After code examples from the development of Beautiful HD Wallpapers, a 50M+ download app.
Claude Code Doesn't Recognize nvm/pyenv/asdf — Shell Initialization and 4 Fixes
Fix 'node: command not found' and Python version mismatches in Claude Code when using nvm, pyenv, or asdf. Learn why shell initialization is skipped and how to solve it for good.
I Rewrote My App's README With Claude Code — There Was Something to Fix Before Adding More Features
A practical walkthrough of using Claude Code to revamp neglected app README files. Covers the setup, prompts, and before/after results from a real indie development workflow.
Claude Code Bash Tool Hangs on `npm run dev` and `docker run` — How to Handle Long-Running Processes
Claude Code's Bash tool freezes when running npm run dev, docker run, or other long-running processes. Learn background execution patterns, timeout strategies, and process management best practices.
Accidentally Committed API Keys to Git — Emergency Response with Claude Code
Step-by-step emergency guide for when you accidentally commit .env API keys to git. Covers immediate key rotation, removing secrets from git history with Claude Code, and preventing it from happening again.
Managing iOS Localizable.strings with Claude Code — A Solo Developer's Multilingual Workflow
How a solo developer managing multiple wallpaper apps used Claude Code to streamline iOS localization. From extracting missing keys to quality checks — a realistic workflow for one-person teams.
Claude Code MCP Server Won't Start — How to Fix "spawn npx ENOENT" and PATH Issues
You configured an MCP server in Claude Code's settings.json, but it never starts — just "spawn npx ENOENT" or "spawn uvx ENOENT" errors. The culprit is a PATH mismatch between your shell and Claude Code's spawning environment. Here's how to diagnose and fix it.
Wiring Claude Code from Crash Reports to a Fix Commit — A Personal Developer's Post-Release Operations Playbook
A working pipeline for personal developers to triage Crashlytics and Sentry reports with Claude Code, drawn from the routine I still run on my own apps every morning.
Catching Template Phrases Before They Ship: grep Guards in Claude Code SKILL.md
Even with detailed prompt instructions, generating articles every day eventually lets template phrases slip through. I added grep-based guards to the final step of my Claude Code SKILL.md so that violations block the push and force the model to rewrite. Here's what changed after one week.
When Claude Code's Read Tool Silently Truncates Large Files — offset/limit Patterns and When to Reach for Bash
Lessons from running an indie app business since 2014: how Claude Code's Read tool quietly cuts off after 2000 lines, the three signs of truncation, and when to use offset/limit versus bash.
Why Claude Code's Glob and Grep Return Zero Results
When Claude Code's Glob or Grep tool returns no matches even though the files clearly exist, the cause is almost always one of four things. Here's how to triage.
Designing Claude Code Skills That Actually Run Unattended — Three Patterns to Avoid Permission-Dialog Stalls
I learned the hard way that Claude Code skills can silently freeze in scheduled runs because of permission dialogs. Here are three implementation patterns that keep file work, path detection, and recovery fully autonomous — distilled from a month of running content automation across four sites.
Pre-commit AI Review with Claude Code, husky, and lint-staged — Reviewing Only Staged Files
A pragmatic guide to running a lightweight Claude Code review on only the files you've staged for commit. Using husky and lint-staged, this setup minimizes both cost and latency for solo developers.
Parallel Development with Claude Code Across Multiple Repos — What Three Simultaneous Projects Taught Me
Claude Code gets messy with multiple repos. Here are the CLAUDE.md strategies, session habits, and cost tips from three months of real parallel development.
Multi-Agent Skill Architecture with gh skill — Versioning, CI/CD, and Agent-Specific Optimization
A production-grade approach to managing SKILL.md across teams using gh skill. Covers repository structure, semantic versioning, GitHub Actions automation, agent-specific optimization, and monorepo patterns.
react-native-permissions vs Expo Permissions API — Claude Code
Should you use react-native-permissions or the Expo permissions API? This guide clarifies the decision criteria and shows practical iOS/Android implementation patterns using Claude Code, including common pitfalls and Privacy Manifest requirements.
Building a SaaS Solo with Claude Code in 90 Days — A Complete Record of Design, Implementation, and Monetization (2026)
A full behind-the-scenes account of building and monetizing a SaaS product using only Claude Code in 90 days — including tool choices, cost management, and every painful lesson learned.
How gh skill Lets You Share SKILL.md Across Claude Code, Copilot, Cursor, and 30+ AI Agents
The gh skill GitHub CLI extension lets you publish and install SKILL.md definitions across Claude Code, GitHub Copilot, Cursor, Gemini CLI, and 30+ AI agents — write once, deploy everywhere.
Build a Personal AI Automation Hub with Claude Code and MCP — Cross-Service Integration Guide
How to build a personal AI automation hub spanning GitHub, Notion, and Slack with Claude Code and MCP — covering cross-service context, error-handling code, production pitfalls, and a measured ~60% token reduction.
BDD with Claude Code in Production— From Gherkin Scenario Generation to Cross-Team Test Culture
A production-ready guide to Behavior-Driven Development with Claude Code. Learn how to auto-generate Gherkin scenarios, implement step definitions, integrate with Playwright/Cucumber, and build a cross-team test culture — all with working code examples.
7 Design Principles for Production-Grade Autonomous Agents with Claude Code SDK
Building a Claude Code SDK agent that works is easy. Building one that keeps working in production is hard. Here are the 7 design principles I extracted from running content automation systems at scale.
Using Extended Thinking with Claude Code in 2026: A
A practical guide to using Claude 4's Extended Thinking feature with the Claude Code CLI and API. Learn how to set thinking budgets, handle streaming, and use it where it actually helps in production.
Your Design Doc Quality Sets Claude Code's Speed Limit: Spec-First AI Development
The story of compressing 16 person-days into 2 hours isn't about how good the AI was — it's about how well the design doc prevented AI from having to think. Learn how to build specs that unlock Claude Code's true speed.
Building a Recurring Revenue Freelance Business with Claude Code — A 6-Month Roadmap to ¥1M MRR
Transform your freelance dev business from per-project income to predictable monthly recurring revenue. Learn how to pitch retainer contracts, price Claude Code's productivity gains correctly, and build a client management system that scales to ¥1M MRR.
Building a Zero-Touch Code Review Environment with Claude Code Hooks
Learn how to use Claude Code's hook system to automatically review code on every tool execution. Covers PostToolUse, Stop hooks, and the pitfalls to avoid when implementing PreToolUse blockers.
Claude Code Desktop Got a Major Overhaul: New UI for the Parallel Agents Era
Anthropic redesigned the Claude Code desktop app in April 2026 for the parallel agent era. Explore the new multi-session sidebar, drag-and-drop layout, integrated terminal, Side Chat, and Routines.
Claude Code MCP Connection Troubleshooting: A Complete Diagnostic Guide
A systematic approach to diagnosing MCP server failures in Claude Code—from config file validation to transport-layer debugging, crash recovery, and multi-server production patterns.
5 Common Claude Code Errors and How to Fix Them
A practical guide to the five most common Claude Code errors—Permission denied, rate limits, MCP connection failures, context overflow, and bash failures—with real causes and fixes for each.
Claude Code + Ollama: Cutting API Costs with Local LLMs
Worried about Claude Code API costs? Learn how to combine Ollama (local LLM) with a litellm proxy to significantly reduce expenses, and discover a practical framework for deciding which tasks to run locally versus in the cloud.
MCP Server Suddenly Stopped Working in Claude Code: A 5-Step Diagnosis Guide
Five steps for diagnosing a broken MCP server: check /mcp status, read stderr logs, validate JSON config, verify auth tokens, and restart Claude Code cleanly.
Build a Pipeline Where Docs Update Automatically Every Time Your Code Changes
Build a CI/CD pipeline that auto-generates README, CHANGELOG, and API docs whenever code changes. Use Claude Haiku 4.5 for cost-efficient classification and Sonnet 4.6 for quality output — cutting API costs by up to 70% while keeping documentation accurate.
5 Practical Ways to Work Around Claude Code's Context Window Limit
When Claude Code warns you that the context limit is approaching on large codebases or long sessions, here are five practical approaches — from /clear and /compact to CLAUDE.md and scope splitting.
Claude Code vs OpenCode + Gemma 4 — A Strategic Guide for Cloud and Local AI Coding
OpenCode paired with Google Gemma 4 is being marketed as a 'free Claude Code'. After running Claude Code in production for half a year, here is an honest, four-axis framework for choosing between them — or, more often, combining them.
From Handy Tool to Development Backbone: Five Operational Pillars for Claude Code
Claude Code is not just a coding assistant — it can become the backbone of your entire development process. Here are the five operational pillars that turn it from a helpful sidekick into the engine of your workflow.
Improving Test Coverage Incrementally with Claude Code
Learn how to use Claude Code to identify uncovered functions, generate targeted tests, and incrementally improve test coverage in TypeScript + Vitest projects.
Setting Up Claude Code's GitHub PR Trigger for Automated Code Review
A step-by-step guide to configuring Claude Code's GitHub PR trigger, writing effective CLAUDE.md review policies, and what two weeks of real usage taught me about keeping the signal-to-noise ratio high.
Claude Code MCP Servers in Practice — From Setup to Real-World Use
A practical guide to connecting MCP servers in Claude Code — covering configuration tips, common errors, and real project setups that actually work.
Claude Code Client Pricing Strategy 2026 — How an Indie Developer Doubles Project Rates
An indie developer's playbook for actually doubling client project rates with Claude Code: how to estimate hours, write proposals that close, structure contracts that protect you, and convert one-off projects into ongoing retainers.
Building an iOS/Android Auto-Deploy Pipeline from Scratch with Claude Code and Fastlane
Learn how to automate iOS and Android app releases by combining Claude Code with Fastlane. Covers Appfile design, certificate management, App Store Connect API integration, and real-world debugging workflows with working code examples.
Doubling Your Freelance Rate in the Claude Code Era — Proposal, Pricing, and Delivery Playbook
A practical playbook for freelance engineers using Claude Code in earnest — how to keep rates high, structure proposals around outcomes, and run multiple parallel projects without exhaustion. Built from real client work.
Claude × Stripe Meter Events — Building a Usage-Based SaaS
A production-ready architecture and full implementation for billing Claude API token consumption through Stripe Meter Events — covering idempotency, usage caps, and a hybrid base + overage pricing model.
How to Commit and Push via GitHub REST API When git CLI Fails in VM Environments
A practical guide to using GitHub REST API (blobs→trees→commits→refs) to push files when git CLI is blocked by index.lock, ownership errors, or permission issues in VM and sandbox environments.
How to Diagnose and Fix Claude Code Network and Connection Errors in 5 Minutes
A systematic guide to diagnosing network and connection errors in Claude Code. Understand what common error messages mean, and follow a step-by-step flow to pinpoint the root cause within 5 minutes.
Claude Code for Data Science — pandas, scikit-learn, and ML Workflows with AI Pair Programming
A hands-on guide to using Claude Code across the full data science and machine learning workflow. From EDA and feature engineering to model evaluation, hyperparameter tuning with Optuna, SHAP analysis, and MLOps basics — with working Python code throughout.
7 Daily Decisions in Solo Development with Claude Code — A Year of Lessons
When I started using Claude Code for solo development, seven recurring decision points kept tripping me up. After a year of running, breaking, and fixing my workflow, here is the criteria I have settled on — including the reasoning behind each judgment call.
Designing Zero-Downtime Database Migrations with Claude Code: A Production Operations Guide
A production guide to designing zero-downtime database migrations with Claude Code. Covers Expand-Contract, NOT NULL additions, renames, backfills, and subagent reviews — practical patterns that survive real production traffic.
Claude Code Stops Mid-Execution: Complete Diagnostic Guide
Diagnose why Claude Code freezes or stops mid-task. Covers context budget exhaustion, unresponsive subagents, infinite loops, and tool timeouts with actionable fixes for each scenario.
Stop the 'old_string is not unique' Error in Claude Code's Edit Tool — A Practical Rewrite Strategy
When Claude Code's Edit tool throws 'old_string is not unique in the file', the root cause is usually that the prompt didn't guarantee a uniquely identifiable target. Here's how to design rewrites that actually stick.
Recipes for a Useful Claude Code Status Line — Show Model, Remaining Context, and Git Branch in One Line
Concrete recipes for a Claude Code status line that displays the active model, remaining context, and git branch in a single line — written in both Bash and Node.js, with the failure modes you should plan for.
Designing a Release Gate Claude Code Can Run — Pre-Deploy Verification You Can Actually Read
A green CI does not mean a safe release. Walk through a seven-checkpoint release gate that asks Claude Code to write a readable, narrative report — with concrete scripts and the operational lessons behind them.
/clear vs /compact in Claude Code: Choosing the Right Reset for Long Sessions
When should you use /clear, and when should you reach for /compact in Claude Code? Three decision criteria from real long-session experience, with the pitfalls that hit me before I figured it out.
Claude Code × Storybook: A Production-Grade Component-Driven Development Playbook — From Auto-Generated Stories to Visual Regression and Design System Operations
A practical guide to combining Claude Code and Storybook for production-grade component-driven development. Covers auto-generating stories, visual regression strategy, interaction testing, CI integration, and running a design system at scale, with full code examples.
Testing Stripe Webhooks Safely with Claude Code: Three Practical Local Workflows
Reproduce Stripe webhook failures locally with confidence. Three practical patterns combining Claude Code with Stripe CLI, signed payload replay, and idempotency checks — with full working code.
Eliminating Flaky Tests Systematically with Claude Code
Move past the 'just hit retry' habit. This guide walks through a structured workflow for using Claude Code to classify, reproduce, and fix flaky tests at the root cause level — without papering over them with sleeps or skips.
Composing Claude Code Skills — Building Automation a Single Skill Can't Reach
A practical guide to going beyond one-skill-at-a-time and composing multiple Claude Code Skills into real workflows. Pipeline, branching, and meta-skill patterns with full implementation examples and the failure modes you should design against.
Designing Codebases Where AI Agents Hit the Ground Running
A practical blueprint for designing codebases where Claude Code and other AI agents can contribute productively from minute one. Covers CLAUDE.md, contract boundaries, guardrails, and test strategy.
Why Claude Code Skips .gitignore Files in Search — and How to Pull Them in When You Need Them
When .env.example or dist/ won't show up in Claude Code's Glob and Grep, .gitignore is the reason. Here's why it happens, plus three concrete ways through it: the Read tool, --no-ignore flags, and selective gitignore overrides.
Automating Frontend Accessibility Audits with Claude Code — axe-core, Hooks, and PR Comments That Actually Get Read
A practical way to make accessibility audits actually stick in a real codebase. Combine axe-core with Claude Code skills, pre-commit hooks, and a GitHub Actions PR comment, with code you can paste in today.
Observability for Claude Code with OpenTelemetry — A Production-Grade Tracing Guide for Agentic Workflows
Trace Claude Code agent runs end to end with OpenTelemetry. Hook integration, per-tool spans, MCP propagation, cost attribution, and sampling patterns that survive thousands of runs per day.
Claude Code Auto-Update Not Working? A Practical Diagnosis Flow When `claude --version` Won't Move
If you ran `npm install -g @anthropic-ai/claude-code` but `claude --version` still reports last week's number, this guide walks you through the three most common root causes — PATH conflicts, stale binaries, and shell-managed Node — with concrete fixes for each.
Two Personalities for Claude Code — A Morning and Afternoon Workflow That Separates Exploration from Implementation
Treating Claude Code as a different persona in the morning and afternoon stabilises design decisions. A solo developer's six-month run with two CLAUDE.md files, a switching script, and the failure modes I hit along the way.
Stopping Claude Code from Quitting Mid-Task — Prompt Patterns and Verification Loops
Claude Code says "Done!" — but the build is broken and only half the files were touched. Here are the prompt patterns and automated verification loops I now use in production to keep agents running until the job is actually finished.
From /init Output to a CLAUDE.md That Actually Steers Claude — A 4-Step Refinement
The CLAUDE.md that /init generates is a draft, not a finished file. Here's the 4-step process I run on every new project to turn that draft into a CLAUDE.md that meaningfully changes how Claude behaves.
Pasting Screenshots into Claude Code: A Practical Workflow for Fixing UI Bugs Fast
A field-tested workflow for handing screenshots and design comps to Claude Code from the terminal—covering the three input methods, prompt templates that actually work, and the gotchas that bit me in production.
Weekend MVP with Claude Code — From Zero to First Revenue in 48 Hours
Build a minimum viable product in a single weekend using Claude Code, integrate Stripe payments, and get your first paying customer — with actual prompts and commands shown step by step.
Automate Presentation Slides in 30 Minutes with Claude Code Skills
Learn how to combine Claude Code Skills with Markdown intermediate format to generate presentation slides from planning to Google Slides export in just 30 minutes.
Read Your Own Code as Someone Else's: Coaxing Tougher Reviews from Claude Code
When you review code you just wrote, the rough edges become invisible. Here's how I summon Claude Code as a mid-career engineer reading someone else's code, plus the prompts I actually use in production.
Turning Claude Code Into a Design Sparring Partner
How to use Claude Code as a sparring partner for design decisions rather than a code generator. The questioning craft I have refined while running four sites and several apps as a solo developer.
Claude Code Context Window Mastery — 7 Production Patterns to Stop Sessions From Stalling
Most slowdowns and silent quality drops in Claude Code on large repos come from context window management, not from model limits. This guide walks through seven patterns I rely on in production, with measurement scripts and runtime rules.
Claude Code Hooks: A Complete Field Guide to All 8 Hook Types and How to Pick the Right One
Claude Code hooks are powerful, but most people give up before figuring out which event does what. Here's the field guide I wish I had when I started — six months of running hooks in production, distilled.
When `claude --resume` Won't Restore Your Previous Session — A Practical Troubleshooting Guide
When Claude Code's --resume or --continue stops bringing back your last conversation, the cause almost always falls into one of four buckets. Here's how to walk through them in five to ten minutes.
Using Claude Code in a pnpm Monorepo — Combining --filter with dlx
Running Claude Code in a pnpm monorepo? It often touches files in packages you didn't ask about. Here's how to scope work properly with --filter, when dlx is dangerous, and what to put in .claude/settings.json so confirmation dialogs stop interrupting you.
Should You Flip CLAUDE_CODE_USE_POWERSHELL_TOOL=1? — A Practical Decision Guide for Windows Developers
When you run Claude Code on Windows, you eventually wonder whether CLAUDE_CODE_USE_POWERSHELL_TOOL=1 is worth flipping on. After running both modes across several projects, here is the decision rubric I now use.
Untangling Claude Code's 'Authorization Failed' Error — OAuth, MCP, and Dynamic Client Registration
Why Claude Code suddenly throws 'authorization failed' or 'incompatible auth server: does not support dynamic client registration', and what to actually do about it. A practical walkthrough of OAuth, MCP server requirements, and the real fixes that work in production.
Test-Driven Development with Claude Code — A TDD Workflow for the Agent Era
Adding the constraint of 'write tests first' to Claude Code stops the agent's drift and dramatically changes the quality of generated code. Here's the TDD workflow I arrived at after six months of trial and error.
Designing Pricing for Indie Projects with Claude Code — Shorten the Lead Time to Your First Revenue
When indie projects fail to earn, the gap is rarely technical — it's pricing design and lead time. Here's a practical mindset for using Claude Code to ship the smallest revenue-ready MVP and reach your first paying customer faster.
Letting Claude Code Handle Dependency Upgrades — A Verification Loop That Catches Breaking Changes
Once a solo project carries 30+ dependencies, the monthly upgrade run becomes a dreaded ritual. This article maps out where Claude Code can take the wheel, where humans must keep judgment, and the verification loop I use to keep breaking changes out of production.
Sharing Claude Code's .claude/ directory across a team — what to commit and what to keep personal
When you start sharing Claude Code's .claude/ directory across a team, which files belong in Git and which stay local? Here are the boundaries I've drawn after running it on four projects, plus a working .gitignore template.
Secret Management and Trust Boundaries for Claude Code — A Production Guide for the Agent Era
A field-tested approach to secrets in a Claude Code workflow: trust-boundary modeling, three injection patterns, leak-prevention hooks, and rotation runbooks — with working code for .env, MCP, and OS Keychain integrations.
When Claude Code Hooks Loop Forever — Stopping Self-Triggering PostToolUse Hooks
You wired up Claude Code hooks and now your terminal is a waterfall of tool calls that won't stop. Here's why PostToolUse hooks loop on themselves, and the patterns I use in real projects to make sure they never do again.
Claude Code for Unity Game Development: Practical
Hands-on guide to using Claude Code on real Unity projects: writing CLAUDE.md for Unity, the Unity MCP server, scene-aware C# generation, PlayMode tests, and build verification.
Automating CI/CD Pipelines with Claude Code's --print and --output-format json
A practical guide to using Claude Code's --print flag and --output-format json in CI/CD pipelines. Covers automated code review in GitHub Actions, PR comment generation, and test failure analysis — with working code throughout.
Claude Code × uv: Blazing-Fast Python Environment Setup — 10x Faster Than pip in Practice
Learn how to combine uv — Astral's Rust-powered Python package manager — with Claude Code for dramatically faster environment setup. Covers project initialization, dependency management automation, CI integration, and migrating from pip.
When Claude Code Hits `index.lock` in VMs and CI: Three Workarounds That Actually Stick
When Claude Code freezes on `fatal: Unable to create '.git/index.lock'` inside a VM, container, or CI sandbox, here are three battle-tested workarounds — pick the one that matches the layer of failure you're actually hitting.
Editing Multiple Repositories at Once With Claude Code --add-dir
How to use Claude Code's --add-dir flag to edit multiple repositories in a single session. Practical patterns for cross-repo API changes, shared utility refactoring, and keeping docs in sync with code.
Running Claude Code Without Breakage — A Failure-First Production Workflow with Plan Mode, Hooks, Rewind, and Subagents
If Claude Code has ever landed a broken commit on your main branch, this guide shows how to combine Plan Mode, Hooks, Rewind, and Subagents into a single failure-first workflow that keeps your repository safe without slowing you down.
Why Your Custom MCP Server's Logs Disappear — Writing to stderr in Claude Code
If you're building your own MCP server and your console.log lines never appear — while Claude Code silently reports the tool as unresponsive — you're probably polluting stdio. Here's how to spot it and rewrite your logs to keep the protocol intact.
Diagnosing Claude Code Subagents That Stall or Never Return
Diagnostic flow for Claude Code subagents that freeze, return silently, or produce the wrong output shape — classified by symptom with runnable examples.
Claude Code's TodoList Quality Comes Down to Task Granularity — Patterns That Actually Worked
The TodoList tool in Claude Code can backfire when used carelessly. Three field-tested patterns — task granularity, verification steps, and update timing — that shift the output from 'looks organized' to 'actually delivered'.
The Claude Code Error Handbook — Auth, Billing, Stalls, Tools & MCP, Diagnosed by Symptom
A field-tested reference for 40+ Claude Code error patterns, organized by visible symptom: authentication, billing, response stalls, tool failures, MCP connectivity, and hook issues. Each entry tells you where to look and what to change.
Claude Code Environment Variables — The Complete Practical Reference
A practitioner-focused reference for every Claude Code environment variable that actually matters. Covers API connectivity, model selection, PowerShell tool quirks, logging, timeouts, security flags, and real-world templates for solo, team, and CI/CD setups.
Debugging Claude Code Hooks in Production — Where to Start When Logs Are Missing
Your Claude Code hooks work locally but go silent in production. Here is the three-layer observability pattern I use on real projects, plus a 60-second minimal reproduction recipe for isolating failures.
Fixed-Bid Pricing Engineering for Freelancers in the Claude Code Era
How to price fixed-bid engagements in the Claude Code era without bleeding profit — a three-layer cost model, risk buffers, and contract clauses that protect freelancers when generative AI compresses hours.
Claude Keeps Saying 'Response Incomplete' — A Layered Troubleshooting Guide
Diagnose why Claude or Claude Code freezes with a 'Response incomplete' or 'Try stopping' message. Walk through the four layers where generation can stall and recover the session without losing context.
Three Minutes with /doctor: Catching Claude Code Config Drift Before It Costs You an Hour
When Claude Code acts up, the first thing to run is /doctor. It shows merged settings, MCP server status, and permission mode at a glance.
Write the Repro Test Before Delegating Bug Fixes to Claude Code
After watching Claude Code spin its wheels on ambiguous bug reports, I started writing the failing test myself before delegating. This post walks through the design principles, a concrete repro test, and the three-stage workflow I run in production.
Finishing Long-Running Claude Code Tasks: A Resilience Playbook You Can Ship
Multi-hour Claude Code jobs — bulk refactors, TypeScript migrations, mass test generation — always stop before they finish, and recovery is painful when you cannot tell what already ran. This guide ships concrete patterns: a checkpoint-driven manifest, a three-state circuit breaker, idempotent retry rules, and a freeze-and-resume protocol you can copy into your repo today.
Turning Claude Skills and Claude Code Plugins Into Products That Actually Sell
How to design, price, distribute, and improve Claude Skills and Claude Code Plugins as real products — with concrete patterns for packaging, billing, churn control, and knowing when to shut it down.
Auto-Generating Conventional Commits with Claude Code — Letting it Infer Type and Scope from the Diff
Are your commit messages starting to look like a wall of update and fix? Here's a small, stable setup that lets Claude Code read your staged diff and turn it into proper Conventional Commits.
Stop Rewriting Code: Using Claude Code Plan Mode as a Real Design Phase
Claude Code's Plan Mode sounds unremarkable on paper, but treating it as a dedicated design phase dramatically reduces token spend and rework. Here's when to switch into it, the prompt template that produces useful plans, and the pitfalls I kept hitting.
Stabilizing Solo Revenue: A Customer Portfolio Playbook for Claude Code Consultants
After you have raised your rate, the next challenge is revenue volatility. A practical framework for solo Claude Code consultants to design a client portfolio that keeps monthly income predictable.
Taking Over an Unfamiliar Codebase in One Week with Claude Code — A Maintenance Handover Playbook
When you inherit a codebase from someone who has already left, how do you use Claude Code to reach a state where you can confidently make changes in just seven days? This is the exact protocol I've repeated many times across solo projects and client work, complete with the prompts I use.
Keeping Claude Code Accurate Through Long Sessions: Signals of Context Decay and What to Do About Them
After a few hours in the same Claude Code session, output quality can quietly slip. This is a practical field guide to spotting the early signals, choosing where to end a session, and keeping a long workflow reliable.
Build a Mobile App Revenue Dashboard with Claude Code — Integrating AdMob, App Store Connect, and Google Play Console APIs with Automated Daily Reports
A production-ready guide to unifying AdMob, App Store Connect, and Google Play Console revenue data into a single dashboard, with automated daily Slack reports. The definitive revenue visibility setup for indie mobile developers.
Claude Code × Python Hybrid Development Patterns: A Production Guide to 50% Token Reduction
Seven production-tested patterns for hybrid Claude Code × Python workflows, each with working code and real-world token reduction data.
When Bash Misbehaves in Claude Code on Windows — A Practical Note on CLAUDE_CODE_USE_POWERSHELL_TOOL=1
On Windows, Claude Code's Bash-based shell tool sometimes fails in odd ways. Setting CLAUDE_CODE_USE_POWERSHELL_TOOL=1 routes commands through PowerShell and removes many of the symptoms. Here are the practical trade-offs I've seen after living with the switch.
The 12-Week Roadmap from Zero to a Monetized Claude Code Product
A week-by-week roadmap for indie developers starting from a single idea and reaching a product with paying users in 12 weeks, built around Claude Code. Includes the exact prompts I use and the mistakes I ran into along the way.
Resolving tRPC Type Errors in 15 Minutes with Claude Code — A Practical Workflow
When tRPC type errors cascade across files, how can Claude Code help you fix them fast? Router design, client integration, and the pitfalls I hit in real projects — distilled into a practical workflow.
Running Next.js on Cloudflare Workers in Production with Claude Code — Every Build Crisis, Cache Bug, and Automation Pattern We Solved
Running Next.js on Cloudflare Workers is not the same as Vercel. The 62 MiB bundle limit, ASSETS binding quirks, and edge cache personalization conflicts are real production hazards. Here's how Claude Code helped us solve each one.
Building a Stripe Subscription SaaS with Claude Code: Webhooks, Auth, and Production Pitfalls
A complete implementation guide for building a Stripe subscription SaaS with Claude Code on Cloudflare Workers. Covers Webhook signature verification, two-layer KV + Cookie auth, and the production pitfalls that official docs won't warn you about.
Claude Code × Cursor × Windsurf: Hybrid AI Development Workflow — Maximizing Speed by Combining All Three Tools in 2026
A practical guide to building a hybrid AI development environment by understanding the strengths of Claude Code, Cursor, and Windsurf — and knowing when to use each. Covers cost optimization, team operations, and configuration sync.
Building iOS 18 Widgets & App Intents with Claude Code: A Complete Implementation Guide
Accelerate WidgetKit and App Intents development with Claude Code. A hands-on guide covering interactive widgets, Live Activities, and Siri integration—with working code and real-world pitfalls.
Claude Code for Mobile App Development in 2026: A Practical SwiftUI & Kotlin Workflow
How to actually integrate Claude Code into iOS (SwiftUI) and Android (Kotlin) development. Real patterns from an indie developer maintaining multiple apps.
Three Months of Cutting Technical Debt in Half with Claude Code — A Practical Record
A three-month hands-on record of tackling accumulated technical debt using Claude Code. Covers visualization, prioritization, and automated refactoring — with real numbers showing what actually changed.
From Spec to Production: Spec-Driven Development with Claude Code
Write a YAML spec and Claude Code auto-generates tests, implementation, and documentation. A practical guide to Spec-Driven Development covering spec formats, TDD automation, and CI/CD pipeline integration with real code examples.
Building a Custom Autonomous Agent Loop with Claude Code SDK — Beyond the CLI
Understand the internals of the Claude Code SDK and build custom autonomous agent loops in Python and TypeScript. Covers tool permissions, error recovery, and streaming, plus the cost instrumentation and monthly model audits I rely on in real operation.
Claude Code Multi-Agent Parallel Execution — Task Tool and SubAgent Patterns That Hold Up in Practice
Measured results from parallelizing Claude Code with the Task tool and SubAgents. Covers what to split and what never to split, a validating aggregation layer in TypeScript, and the disk contention and stale-input traps I hit along the way.
Claude Code × SwiftUI × StoreKit 2 — Complete In-App Purchase & Subscription Implementation Guide
Master in-app purchases and subscriptions with Claude Code, SwiftUI, and StoreKit 2. From transaction handling and server-side validation to paywall UI design — production-quality code that passes App Store review.
Claude Code Stopped Mid-Task? A Practical Recovery Guide to Resume Work Safely
When Claude Code stops responding mid-task, the worst thing you can do is immediately retry. This guide walks you through a 5-step recovery process using git to confirm what was completed before resuming safely.
Claude Code Tool Permissions: Custom Allow/Deny Policies
Learn how to control Claude Code tool permissions with allowedTools, disallowedTools, and settings.json. Includes project-specific permission patterns for frontend, backend, and read-only review scenarios.
Claude Code Sub-agent Patterns — Designing Autonomous Task Decomposition and Parallel Execution
Dissect Claude Code's internal Sub-agent architecture and learn concrete design patterns for task decomposition, parallel execution, and result merging in your own projects.
CLAUDE.md Not Working? A Complete Troubleshooting Guide for Claude Code
Claude Code ignoring your CLAUDE.md settings? This guide covers the most common causes — wrong file location, formatting issues, conflicting configs, and more — with clear fixes for each.
Claude Code × Swift/iOS Production Guide — From Xcode Integration to App Store Launch
A practical guide to building production-quality iOS apps with Claude Code and Xcode. Covers CLAUDE.md design, SwiftUI implementation, Clean Architecture, automated testing, Fastlane CI/CD, and App Store submission.
Running Claude Code and GitHub Copilot Together — Different Philosophies, Practical Division of Labor
Claude Code and GitHub Copilot are built on different philosophies, and their strengths barely overlap. Here is how their limits compare across real implementation scenarios, and how to run both in one workflow.
Claude Code × Docker — DevContainers, Multi-Stage Builds, and Production Deployment
A practical guide to production-grade development workflows combining Claude Code and Docker. From DevContainer setup and multi-stage build optimization to GitHub Actions CI/CD and Kubernetes deployment — with practical code examples throughout.
Claude Code × SvelteKit Full-Stack Development Guide: From Zero to Production
A complete guide to full-stack development with Claude Code and SvelteKit. Covers Svelte 5 Runes, Drizzle ORM, Auth.js, and Cloudflare Workers deployment through practical, production-ready workflows.
iOS Test Automation with Claude Code — Where XCTest, Swift Testing, and XCUITest Each Belong
Build a solid iOS test suite with Claude Code. Cover XCTest, Swift Testing, and XCUITest, automate CI with Xcode Cloud, and reach 80%+ coverage with AI.
Fix Claude Code Bash Tool Execution Errors — Timeouts, Permission Denied, and Truncated Output
Learn how to troubleshoot and fix Claude Code Bash tool errors including timeouts, Permission Denied, ENOENT, truncated output, and environment variable issues with step-by-step solutions.
Claude Code × Go: Production-Grade REST API Development — Gin, GORM, Docker & GitHub Actions
Build production-grade Go REST APIs with Claude Code. Covers Gin, GORM, PostgreSQL, Docker multi-stage builds, JWT auth, and GitHub Actions CI/CD.
An Implementation Notebook for Shipping Android/Kotlin Apps to Google Play with Claude Code
A production notebook from years of running an indie Android app business. Compose × Hilt × Room design calls, ProGuard crash triage, and a 14-item pre-release checklist that goes in front of every Google Play AAB upload.
Claude Code × Flutter: Complete App Development Guide — Accelerating Mobile Development with Dart and AI
A practical guide to using Claude Code for Flutter development. From auto-generating Dart code to state management, UI design, test automation, and App Store submission — a complete roadmap for indie developers.
Claude Code × Python FastAPI in Production — Architecture, pytest, and Docker Deployment
Building production-ready Python FastAPI servers with Claude Code as an AI pair programmer — Pydantic v2, pytest automation, Docker, and CI/CD, with working code at each step.
Claude Code Subagent Orchestration Mastery: 10x Your Development Speed with Parallel Processing
A deep-dive guide to Claude Code's subagent capabilities. Covers parallel Task tool usage, orchestration patterns, and real-world case studies — premium-level content, fully free.
Claude Code × Next.js 15 App Router Production: RSC, Server Actions, Auth, Testing & Deployment
The practical guide to production Next.js 15 App Router development with Claude Code. Covers RSC architecture decisions, Server Actions patterns, Auth.js v5, Vitest testing, and Cloudflare Workers deployment with practical code examples.
Automate Project Initialization with Claude Code — From CLAUDE.md Design to CI/CD Setup
A practical guide to fully automating project initialization with Claude Code. From CLAUDE.md design patterns and scaffolding automation to Git hooks and CI/CD pipeline setup — all covered systematically.
Managing Your Obsidian Knowledge Base with Claude MCP (2026)
Connecting Obsidian to Claude MCP so an AI can search, write, and reorganize your vault — setup through everyday workflows with Claude Code.
Claude Code × Drizzle ORM: Type-Safe Database Development 2026
A practical guide to building type-safe PostgreSQL applications with Claude Code and Drizzle ORM. Covers schema design automation, migration strategies, advanced query patterns, connection pooling, and edge deployment — everything you need for production-grade development.
Claude Code VS Code 'Not Responding — Try Stopping' — Isolating the Cause
Five step-by-step checks for the 'Not responding — try stopping' error in the Claude Code VS Code extension — root causes, Webview cache, Windows conflicts, and clean reinstalls.
Claude Code /insights Command: Analyze Your Coding Habits and Boost Productivity
Use Claude Code's /insights command to analyze your session history, spot coding inefficiencies, and turn data-driven findings into real productivity gains.
Claude Code + Figma MCP Advanced Guide: Automating Your Personal Design Workflow
Master the deep integration of Claude Code and Figma MCP. Complete Design.md system design, advanced implementation patterns, iteration strategies, and real-world optimization techniques.
Shipping iOS/Android Apps Monthly as a Solo Developer with Claude Code and Expo
A workflow for solo developers shipping iOS/Android apps on a monthly cadence using Claude Code and Expo. Covers CLAUDE.md setup, AdMob monetization, EAS Build, and App Store review hurdles that come up in practice.
Claude Code × Terraform: Complete AWS Infrastructure Automation Guide — Design, Generation, Security Auditing, and Cost Optimization
Combine Claude Code with Terraform to automate AWS infrastructure — IaC generation, security auditing, cost estimation, and drift detection in one AI workflow.
Claude Code's PowerShell Tool — A Native Windows Path That Bypasses WSL
Setup and practical use of the Claude Code PowerShell tool on Windows — when it actually beats WSL2, security hardening for corporate environments, and real automation patterns from daily use.
Claude Code Hooks: Building Automated Workflows in Practice
A systematic guide to Claude Code Hooks. Learn how to use PreToolUse, PostToolUse, Stop, and Notification hooks to automate code quality checks, logging, notifications, and more.
Parallel Development with Claude Code Worktrees
A practical look at running parallel tasks with Claude Code and Git worktrees. Learn how to isolate branches into separate directories so context switches stay cheap, with the rough edges I hit while actually running this day to day.
Claude Code HTTP Hooks × GitHub Actions Integration Guide — Production Patterns for Automated Code Review, Testing, and Deployment
A deep dive into integrating Claude Code HTTP Hooks with GitHub Actions to build production-grade pipelines for automated code review, quality checks, and deployment — with detailed code examples throughout.
Claude Code × App Store Connect API: A Complete Automated iOS/Android Release Pipeline Guide
Learn how to combine App Store Connect API with Claude Code to fully automate iOS app releases. From AI-generated release notes to TestFlight distribution and GitHub Actions integration, this guide covers the complete pipeline with working code.
Using Claude Code on Windows — Native vs WSL2
Set up Claude Code on Windows using the native installer or WSL2. Includes step-by-step instructions, a practical comparison, and troubleshooting tips.
How to Auto-Resolve Git Conflicts with Claude Code — Merge and Rebase Strategies
Learn how to resolve Git merge conflicts efficiently using Claude Code. This guide covers 3-way merge fundamentals, rebase conflict handling, complex resolution patterns, and automation techniques with practical command examples.
Claude Code Model Selection Strategy — Maximize Development Efficiency with /model and opusplan Mode
Learn how to strategically switch between Opus, Sonnet, and Haiku in Claude Code using the /model command. Discover opusplan mode, task-based model selection, and cost optimization techniques.
Claude Code Won't Start: Complete Diagnostic Checklist
Systematic guide for diagnosing Claude Code startup failures. Covers Node.js, npm, PATH, permissions, and proxy issues with step-by-step troubleshooting.
Claude Code Not Working? Complete Troubleshooting Checklist — From Setup to Connection Issues
Getting started with Claude Code but nothing works? Commands fail, files aren't created, or you get connection errors. This beginner-friendly guide covers installation, configuration, common errors, and immediate fixes.
Running Claude Code × Playwright E2E Tests in Production — Measured Numbers, Pitfalls, and Decision Criteria from 6 Sites
Implementation patterns for running E2E tests with Claude Code and Playwright in production, plus measured numbers from operating six sites in parallel: flaky-test rate 15.3% to 0.42%, Page Object generation 4 hours to 18 minutes. Includes the Cloudflare Workers and Pages preview deployment pitfalls, and a decision framework that indie developers can use to judge whether E2E tests are worth the investment.
Claude Code Team Development Guide — AI Pair Programming with CLAUDE.md, Git Hooks, and Automated Reviews
Learn how to integrate Claude Code into team development workflows. From sharing project context through CLAUDE.md to automating code reviews with Git Hooks, this guide covers everything you need for effective AI pair programming.
How to Build a Landing Page from Design Comps Using Only Claude Code
Learn how to turn Figma design comps into a fully functional landing page using Claude Code alone — even without coding experience. We cover Plan Mode strategy, CLAUDE.md design, and section-by-section implementation techniques.
Claude Code × JetBrains — Setup and Workflow for IntelliJ, WebStorm, and PyCharm
Learn how to use Claude Code with JetBrains IDEs including IntelliJ IDEA, WebStorm, PyCharm, and GoLand. Covers plugin installation, native Diff view, selection context sharing, keyboard shortcuts, and practical workflow examples.
Claude Code Statusline — Displaying Rate Limits and Building Custom Scripts
Learn how to customize Claude Code's statusline to display real-time rate_limits usage. Covers settings.json configuration, custom script creation, and community tools for monitoring your usage.
Claude Code Mastery — Hooks, Orchestration & Multi-Agent Operations
Master Hooks and Orchestration in Claude Code. Learn 21 lifecycle events, 4 handler patterns, and multi-agent coordination strategies inspired by DevMoses' 198-agent parallel execution.
Retracing Claude Code's Five Levels in Real Use — I Stalled at Level 3 and Level 5
Claude Code mastery is usually described as five levels, from Raw Prompting to Orchestration. Retracing them as an indie developer running apps and four sites, I found the steps are nowhere near equal in height.
Fixing ENOSPC Errors in Claude Code: A Hands-On Guide
ENOSPC errors in Claude Code and Cowork can stop your work cold. Drawing on the time I jammed my own four-site automation pipeline, here's how to find the cause, recover on the spot, and design so it never happens again.
CLAUDE.md and AGENTS.md—Differences, Best Practices, and Implementation Patterns
Master AGENTS.md (now a standard with 60,000+ repos) and CLAUDE.md. Learn their differences, how to write them effectively, and when to use each format.
Fully Automated Code Review with Claude Code—Implementing Harness Engineering Patterns
Master harness engineering (coined by HashiCorp founder) for AI-driven code review. Learn Claude Code implementation patterns and solutions for over-suggestion and review oscillation.
Vibe Coding × Claude Code: Build Apps Without Engineering Experience
Discover how vibe coding with Claude Code enables non-engineers to create functional applications by describing ideas in natural language. A practical guide for absolute beginners.
Claude Code × VS Code Extension: Doubling Your Development Productivity
Learn how to maximize your development productivity with the Claude Code VS Code extension. From installation to inline edits, terminal integration, and essential shortcuts for beginners.
Claude Code Worktree — Maximize Productivity with Parallel Development
Master parallel branch development with Claude Code's --worktree flag. Work on multiple features simultaneously without switching overhead.
Claude Code Memory Management Basics — Understanding CLAUDE.md and MEMORY.md
Learn how Claude Code's memory system works through CLAUDE.md and MEMORY.md. Persist project-specific instructions and feedback to streamline your AI-powered development workflow, with lessons from real day-to-day use.
Claude Code Hooks— Practical Techniques to Automate Your Dev Workflow
Learn how to automate your development workflow with Claude Code Hooks. From PreToolUse and PostToolUse configuration to automated code review, security checks, and deployment pipeline integration.
How to Automate Game Development with Claude Code × unity-mcp — A Complete Workflow from Concept to Release
Learn how to combine Claude Code with unity-mcp to automate Unity game development. The hcg-workflows skill set provides an 8-phase workflow from planning to deployment.
Claude Code × Monorepo Development — Streamlining Large-Scale Projects with Turborepo and pnpm Workspaces
Learn how to supercharge your monorepo workflow with Claude Code. Covers CLAUDE.md configuration for Turborepo and pnpm Workspaces, cross-package refactoring, dependency management, and practical tips for large-scale codebases.
Claude Code --bare Flag: Headless Automation and Scripted Execution
Learn how to use Claude Code's new --bare flag for fast, lightweight scripted automation. This guide covers CI/CD pipelines, batch processing, and safety best practices for headless Claude Code execution.
Claude Code Custom Slash Commands — Build Your Own Commands to Supercharge Team Workflows
Learn how to create, manage, and share custom slash commands in Claude Code. From the .claude/commands directory to team sharing and practical command examples.
Claude Code Channels: How to Control Your Coding Agent from Telegram and Discord
Claude Code Channels let you send messages from Telegram or Discord directly into a running session. Learn how to set up, configure, and use this powerful new feature for remote development.
Accelerate Frontend Development with Claude Code — A Practical React & Next.js Workflow
Learn how to supercharge your React and Next.js frontend development with Claude Code. From component generation and styling to testing and performance optimization, discover practical workflows you can use today.
Claude Code Won't Start? Setup Troubleshooting FAQ
Claude Code CLI setup troubleshooting guide for beginners. Covers npm permission errors, API key issues, PATH configuration, proxy setup, CLAUDE.md loading, sub-agent startup, and git hook conflicts.
Designing CLAUDE.md for Stable Output — Hierarchy, Sub-Agents, and External Memory
Learn how to structure CLAUDE.md with a 3-tier hierarchy, sub-agent workflows, and external memory to keep Claude Code's output consistent — with the practical lessons that actually moved the needle in real operation.
NemoClaw × Claude — Automating Revenue Pipelines with Enterprise AI Agents
A practical guide to revenue automation with NVIDIA NemoClaw and Claude Code / Claude API. Covers agent design, API orchestration, automated content generation, and SaaS backend architecture for building self-running revenue pipelines.
Claude Code Output Styles Guide — Customize Responses to Maximize Development Efficiency
Master Claude Code's output styles feature. Learn how to use built-in styles, create custom styles, and distribute team-wide configurations through plugins to transform your AI pair programming experience.
Implementation Patterns for Custom Claude Code Skills — SKILL.md Design, Testing, and Distribution
A hands-on tutorial for building three production custom Claude Code skills from scratch. Covers SKILL.md structure, agent types, context injection, testing, and team distribution.
Unity × Claude Code Advanced Workflow — Shader Generation, CI/CD & Performance Optimization
Advanced Unity development with Claude Code. Auto-generate custom shaders, build CI/CD pipelines, and implement performance profiling—with production-tested code.
Claude in Xcode 26: AI-Powered iOS/SwiftUI Development
A complete guide to Claude in Xcode 26 and Xcode 26.3's Claude Agent SDK integration. Learn how to automate iOS and SwiftUI development with AI from setup to advanced agentic workflows.
Test-Driven Refactoring with Claude Code — Safely Modernizing Legacy Code
Learn how to use Claude Code to safely refactor legacy code by adding tests first. Combine TDD principles with AI assistance to eliminate technical debt without breaking existing functionality.
Building Production-Grade Multi-Agent Systems with Claude Code: Complete Implementation Guide
Master advanced multi-agent orchestration patterns using Claude Code and Agent SDK. Learn parallel execution, dependency management, automatic retries, and dynamic task distribution. Complete implementations for financial analysis, web scraping, and complex workflows.
Claude Code Launches Code Review — AI Agent Team Automatically Hunts Bugs on Every PR
Anthropic adds Code Review to Claude Code. Every time a PR is opened, a team of AI agents searches for bugs in parallel, verifies findings, and ranks them by severity. Here's how to read the accuracy data and adapt the idea for solo and small-team work.
Claude Code Worktree Guide — Safe Parallel Development Techniques
Learn how to use git worktree with Claude Code for safe parallel development. Work on multiple tasks simultaneously without branch switching.
Unity × Claude Code Game Dev Guide — Building AI-Driven Workflows with MCP
Learn to accelerate game development with Unity MCP and Claude Code. Covers scene building, asset management, script generation, and debugging with AI-driven workflows.
Claude Code CI/CD Integration Guide — GitHub Actions
Learn how to integrate Claude Code with GitHub Actions for automated PR reviews, issue handling, and code generation.
Cursor × Claude Code Integration Guide — The Ultimate AI Dev Combo
How to combine Cursor editor with Claude Code CLI for maximum development efficiency. Setup, practical workflows, and tips for using both tools together.
Figma × Claude Code Integration Guide — Bridging Design and Code with MCP
Learn how to connect Figma and Claude Code via MCP server for bidirectional design-to-code workflows, from setup to practical techniques.
Mastering Claude Code's Agent Features — From Sub-Agents to Teams
A practical guide to Claude Code's sub-agents, background tasks, and Agent Teams. Maximize development efficiency through context management and parallel processing.