claude-code
Claude Code Best Practices 2026: What the Official Docs Don't Cover
AI Product Development
System track
A Claude Code workflow that ships products, not demos.
This track covers Claude Code workflows, WebMCP agent interfaces, context management, evidence gates, RAG, and the operational decisions that move an AI idea into production.
Guided track Machine-readable 20 implementation notes, case studies, and security-automation architectures
Why this cluster exists
AI product teams get stuck when they confuse model output with system design. This cluster documents the loops that matter: context control, verification, tool orchestration, and shipping discipline.
System object
protocol board
Best for
builders, founders, and engineers shipping with AI
What a Claude Code workflow has to survive
A Claude Code workflow is the set of habits, files, and checks that sit between a prompt and shipped code. The tool itself is the easy part. What breaks in practice is everything around it: context that runs out in the middle of a task, generated code that reads well and fails at runtime, token bills that double without anyone changing the prompt, and demos that never become products. This page is the reading order for a workflow that survives those four failures, drawn from the products I have shipped with agents rather than from the documentation.
Start with Claude Code best practices 2026, which covers what the official docs leave out, tested across 36K lines of shipped code. Then read my two-gate system, the review process that cut my error rate 84% by refusing to trust a self-report from the model: one gate checks the plan, the second checks the evidence before anything merges. Those two posts are the spine. Every other piece in this track is a specialization of one of them.
The reading order matters because the failures compound. A context failure produces confident code with a missing piece. A verification failure lets that code through. A token failure means you cannot afford to run the check that would have caught it. And a product failure is what all three look like from the outside: a demo that worked once and a repository nobody can maintain. Fixing them in order is cheaper than fixing them after a customer finds the gap.
Context, tokens, and quota
Most Claude Code failures are context failures wearing another name. Compaction failed: causes and 3 fixes explains the error that appears when the conversation can no longer be reduced, why it means the state lived in the wrong place, and the three fixes that move state into files. Reduce Claude token usage 60% is the three-tier progressive disclosure system that loads only what the current step needs. 10 patterns behind a 32% plan-quota burn is the audit of my own usage: which habits burned the plan and which were free.
The private MCP server for memory across sessions is the long-term answer to the same problem: a memory that outlives the conversation, that Claude queries rather than re-reads, and that does not count against the context window until it is needed.
The order to read these is the order the failures show up. Compaction fails first, in the middle of a task, and the fix is structural. Token cost shows up on the bill a week later. Quota burn shows up when the plan resets and you cannot finish the sprint. A memory server is the last piece because it only pays off once the other three are under control.
Verification before shipping
Generated code needs a different review than human code, because the failure modes are different. How to test AI-generated code before shipping documents 57 bugs caught with evidence-based review and the categories they fell into. The secret-leak post shows the one guardrail that paid for itself immediately: a pre-commit check that caught a credential before it left the machine. The output-gating gap is the limit of that approach, the one thing none of the eight lifecycle events can see.
The pattern across all three is the same as the two-gate system: the model reports what it did, and the workflow checks it against something the model did not write. Tests, diffs, and rendered output count. A confident summary does not.
Two more posts belong in this section for readers building on top of retrieval. What is RAG? is the plain explanation of retrieval-augmented generation, and What is WebMCP? covers the browser-side protocol that lets an agent act on a page rather than scrape it. Both are foundations for the verification question, because a system that retrieves the wrong context will generate the wrong code with the same confidence.
Models and tools
Model choice is part of the workflow, not a separate decision. Fable 5 vs Opus 5 explains why I demoted a model sixteen days after making it the default, and Fable 5 vs Opus 4.8 is the reasoning-tier matrix with per-task cost. How to use Claude Opus 5 is the failure-tested guide to the model that took the seat. Claude vs Cursor vs Copilot covers the choice between tools for readers who have not settled on one.
Is Claude nerfed? belongs here too. Four documented mechanics explain most of the complaints, and knowing them changes how you read a bad session: usually the context, sometimes the fallback, rarely the model.
From workflow to product
AI-first product development is the case for shipping products with agents rather than an IDE, with 5 shipped products as the evidence. SvelteKit MCP in 90 minutes and 3 files is a complete worked example on this site. The decisions that follow a launch have their own posts: flat-rate versus usage-based pricing and serverless PDF parsing that works on Vercel.
If you would rather have this workflow installed than read about it, the services page lists the engagements I take on. Everything linked above stays free, and the newsletter at the bottom of this page carries new posts in this track before they are announced anywhere else.
Start here
The best first read in this track.
Core journey
Read these in order if you want the strongest mental model.
Capability overhang
This track is built for agents as well as readers.
The AI product development cluster is where the site’s AAO, AEO, and GEO stack becomes most explicit: answer-ready articles, machine-readable discovery files, and WebMCP tools that agents can call directly.
WebMCP
Callable blog tools
Agents can query posts through structured browser tools instead of scraping screenshots or brittle DOM selectors.
See the implementationAEO
Answer-shaped articles
Definition blocks, FAQ scaffolding, source sections, and track context make these posts easier to extract, cite, and continue.
Read the AEO guideGEO
Discovery infrastructure
`llms.txt`, `ai.txt`, JSON-LD, and internal entity structure give search and AI systems multiple high-trust ways to understand the site.
See the discovery layerFoundation
Reduce Claude Token Usage 60%: Progressive Disclosure
3-tier progressive disclosure cuts Claude API costs 40-60%. The exact system: tier 1 triage, tier 2 context, tier 3 full pass.
RAG Explained: How to Stop LLMs From Making Things Up
RAG retrieves live data to fix LLM hallucinations. Build accurate AI apps with up-to-date knowledge sources without retraining or fine-tuning models.
Deep dive
Self-Improving RAG with Claude Code: Learning From Its Own Debugging Mistakes
Build a self-improving RAG system where Claude learns from your debugging sessions, captures insights automatically, and reflects to fix issues faster.
Build SaaS With AI Agents: 7 Days to Paying Users
How a 4-agent system (Researcher, Architect, Developer, Deployer) took StatementSync from problem statement to Stripe billing and paying users in 7 days.
Applied / adjacent
AI-First Product Development: 5 Products Shipped With Agents, Not IDE Plugins
AI agents will replace IDE plugins in product development. Here's how I built MicroSaaSBot to prove it, and what it means for your workflow.
How to Use Claude Opus 5: A Failure-Tested Guide
Learn how to use Claude Opus 5 with failure replay, effort sweeps, deterministic checks, and a scheduled regression worker.
Flat-Rate vs Usage-Based SaaS Pricing: Why I Chose Flat
Flat-rate SaaS pricing explained: why it beats per-transaction models, saves heavy users money, and builds customer loyalty in 2026.
unpdf: Serverless PDF Parsing for Node That Works on Vercel
unpdf is a serverless-safe PDF parser for Node: zero native deps, Edge-safe, 3-5s per PDF. Why pdf-parse crashes on Vercel, and the full migration path.
Bug Bounty Automation Framework: Zero False Positives
A bug bounty automation framework that cuts false positives to zero: the 4-agent evidence-gating architecture, what it costs to run, and what it takes to build one for your own security program.
Human-in-the-Loop AI: Why It Beats Full Automation for Security Tools
Keep humans in control when building AI security tools. Full automation sounds impressive until your reputation tanks from false positives.
I Let an AI Agent Write My Blog for 30 Days. Here's What Happened.
How I configured OpenClaw to study my writing voice, handle SEO/AEO/GEO, and publish blog posts autonomously with a single Telegram approval.
Claude Code Hooks Caught a Secret Leak Before I Shipped It
Stop accidental secret leaks in Claude Code hooks. Learn 4 production patterns to validate, format, and gate commands before execution.
10 Patterns Behind a 32% Claude Code Plan-Quota Burn
10 specific patterns that explain why my Claude Code plan-quota burn runs at a fraction of what r/claudecode operators report on similar workloads. Each pattern lists the multiplier and the named alternative you can run today.
I Built a Private MCP Server to Give Claude Memory Across Sessions. Here Is What Broke.
I shipped a private MCP server bridging my knowledge base into claude.ai via OAuth 2.1: the architecture, two bugs the smoke test missed, and the isolation pattern.
Claude vs Cursor vs Copilot: 2026 Comparison
I built a 4,000-line trading bot with all three tools. Here's which handles context best, costs least, and actually ships production code without you.
Claude Code Has 8 Hook Events. None of Them Can See the Agent's Output.
I built hooks into a 38,240-line production harness. The gap nobody documents: no hook fires on the agent's output text. The harness is the guardrail.
Fable 5 vs Opus 4.8: Every Reasoning Tier Benchmarked
Fable 5 low beats Opus 4.8 xhigh on SWE-bench Pro. Full tier matrix, low through xhigh, with per-task cost reads and the routing rule for agentic coding. Updated September 1, 2026 for Claude Fable 5.1, whose per-token price did not change, and for where Opus 5 changes the answer.
Fable 5.1 vs Opus 5 in Production: A Whole Day on Fable Used 19% of a Max Weekly Window
Same harness, same day: 2,443 Fable 5.1 turns and 1,120 Opus 5 turns after a weekly reset consumed 19% of the Max weekly window, and the 5-hour window peaked at 59% without capping. Fable errored less per tool call, hit more permission gates, and would have cost 1.4x per turn on the API, not 2x.
Claude Fable 5 System Card, Annotated: 95% Capability, Documented Fabrication
The Fable 5 system card documents both halves: 95.0% SWE-bench Verified, and fabricated status reports with unverbalized early-stops. The annotated read.
What Is WebMCP?
WebMCP is an experimental browser API that lets websites expose structured tools to AI agents through document.modelContext. Learn how it works, its security boundaries, browser support, and how it differs from MCP.
Is Claude Fable 5 Nerfed? Four Mechanics Behind the Panic
Is Claude nerfed? Four documented Fable 5 mechanics explain the panic: the Opus 4.8 fallback, adaptive thinking, harness-gated gains, and tier pricing.
Supporting angle
Not every important idea belongs in the main reading path.
Use the supporting pieces to deepen the model, test tradeoffs, and connect adjacent ideas without losing the main narrative.
Recommended next
Reduce Claude Token Usage 60%: Progressive Disclosure
3-tier progressive disclosure cuts Claude API costs 40-60%. The exact system: tier 1 triage, tier 2 context, tier 3 full pass.
Related tools and products
Explore products and experiments
See the tools and MVPs built from the same workflow stack.