Claude Code
Full Stack Playbook

Module 01API Arsenal — 5 Stacks, 30+ APIs

The Startup Guide gave you 1-2 API connections. This module shows what happens when you wire up 30+. Each connection is not just a feature — it is a capability multiplier. Claude stops being a chatbot and becomes a full operating system for your business.

The 5 Stacks

Your .env File

Module 02Multi-Agent Orchestration

Single-threaded Claude is powerful. Multi-agent Claude is a team. You are not waiting for one task to finish before starting the next — you are running 5, 10, or 13 agents in parallel, each owning a different piece of the work.

Orchestrator vs Subagent

Here is how the pieces fit together visually. You talk to the orchestrator. The orchestrator delegates to specialised agents, each running the right model for the job:

3 Orchestration Patterns

Pattern 1: Fan-Out / Fan-In

Spawn N agents for independent tasks, wait for all to return, integrate results.

Pattern 2: Pipeline

Agent A's output feeds Agent B, which feeds Agent C. Sequential but each agent is specialised.

Pattern 3: Explore / Decide / Execute

Fast cheap agents explore options (Haiku), orchestrator decides direction (Sonnet/Opus), execution agents build the thing (Sonnet).

Spawn Syntax

Claude Code responds to natural-language spawn instructions. These are the prompts that trigger multi-agent execution:

Cost & Model Routing

Not all tasks deserve the same brain. Route by cost and complexity:

AI Setup Cost Calculator

Plow Mode — Burning Credits Efficiently

When you have compute budget to burn and a backlog of unblocked work, plow mode maximises parallel output:

Module 03The Skills Factory

Skills turn repeatable tasks into one-command workflows. Instead of explaining what you want every time, you type /weekly-report and Claude runs the whole playbook. A mature workspace has 30-55+ skills covering every recurring task.

Skill Anatomy

Frontmatter Reference

Chaining Skills

Skills can call other skills. A monthly report skill might internally call the data-pull skill, then the format skill, then the delivery skill:

Model Routing in Skills

The model in the frontmatter determines which Claude runs the skill at execution time. Match the model to the task complexity:

Plan Mode

Before building anything complex, use /plan to have Claude draft a structured plan before executing. Plan mode forces Claude to think before acting:

Claude will produce a numbered plan with file targets, dependencies, and estimated steps. Review it, approve it, then Claude executes. This prevents wasted compute on wrong-direction builds.

Hooks — Run Code Before and After Every Tool Call

Hooks let you run shell commands or scripts automatically before or after Claude uses any tool. They are configured in .claude/settings.json and execute at the harness level — meaning they run regardless of which skill or conversation is active.

Module 04Autonomous Mode — Loops, Events, Background Agents

This is where Claude goes from "tool you use" to "system that runs." Autonomous workflows execute without you watching, report back when done, and can trigger from real-world events.

3 Autonomous Patterns

There are three core patterns for autonomous work. Each fits a different kind of task:

Loops

The /loop command tells Claude to repeat a task on a schedule. Claude self-paces: it picks the right delay between iterations based on what it is waiting for.

Background vs Foreground Agents

Understanding when to use foreground vs background agents is the difference between efficient and wasteful work.

Background Agent Failure Modes

Background agents can and do fail. The three most common failure modes:

• Crash: The agent hits an error and stops mid-task. Output may be partial or missing.
• Timeout: Long-running tasks exceed the context window or session limit. Work is lost if not committed.
• Wrong file: The agent writes to an unexpected location, or overwrites another agent's work.

Event-Driven Patterns

The most powerful automations are not scheduled — they are triggered. Something happens, Claude responds.

Monitoring & Safety

Heartbeat Monitoring

For agent systems with many components, build a heartbeat monitor. Every agent writes a timestamp to its tracking record. A monitor checks: if last heartbeat is more than 5 minutes old, alert.

Kill Switch

If error rate exceeds a threshold in a time window, pause all automated operations and notify. This prevents runaway costs and cascading failures.

Graceful Degradation

If a premium data source fails, produce the output with whatever data is available. Clearly mark gaps rather than failing the whole task. API fallback chains: if source A is down, try source B, then source C.

Module 05The Memory Architecture

Memory is what makes Claude feel like a partner, not a tool. Across hundreds of sessions, Claude remembers your preferences, your projects, your decisions, your constraints — all stored as small markdown files that get loaded at the start of every conversation.

The 4 Memory Types

These four types cover different scopes. Here is how they relate to the three layers of context Claude actually uses:

MEMORY.md — The Index

MEMORY.md is loaded into every conversation. It is an index, not content — each entry links to a detailed file. Keep it under 200 lines (anything beyond gets truncated by the context loader).

Memory vs CLAUDE.md vs Plans

Do not save task-specific details to memory — those belong in the plan. Memory is for things that matter across sessions.

Collaboration Zones

Module 06Smart Personas — Your Specialist Team

One Claude instance can play many roles. But a Claude instance given a specific persona — with domain expertise, communication style, and decision frameworks baked in — produces dramatically better output than a generic prompt. Think of it as having a team of specialists, each one tuned for their domain.

The 4 Core Personas

Implementation

Personas are implemented as system prompts inside skills or as standalone persona files:

You can also switch personas mid-conversation:

Module 07MCP Ecosystem — Connecting Everything

MCP (Model Context Protocol) is Claude Code's native plugin system. Each MCP server gives Claude a new set of tools — read Google Sheets, search Drive, send Slack messages, fetch web pages — without leaving the terminal.

What MCP Unlocks

Without MCP, Claude reads and writes files in your workspace. With MCP:

• Claude can read your Google Sheets without you pasting data
• Claude can search your Drive by filename and read documents
• Claude can fetch any web page and extract structured data
• Claude can post to Slack channels and read message history
• Claude can manage GitHub issues, PRs, and code search via API

The Full MCP Stack

Configuration

Building Your Own MCP Server

The built-in MCPs cover about 80% of common use cases. But when you need Claude to talk to a system that does not have an existing MCP — your CRM, your internal tools, a custom database — you build your own. An MCP server is just a small program that exposes tools to Claude via a standard protocol.

Local LLMsWhen and How to Run Models Locally

Cloud AI (Claude, GPT) is the main engine. But there are scenarios where running a model on your own machine makes sense — privacy, cost, offline work, or bulk processing where quality is not critical. This section covers when to go local, which tools to use, and which models to start with.

When to Use Local vs Cloud

3 Ways to Run Local Models

Each tool has a different sweet spot. Pick based on whether you prefer the terminal, a visual interface, or the lightest possible footprint:

Recommended Models

Getting Started with Ollama (2 minutes)

Module 08Terminal Dominance

Before Claude Code, a typical morning looked like this: open Chrome, log into analytics, switch to your ad platform, open the project tracker, check Slack, open email, switch to the CRM, open a spreadsheet, alt-tab 47 times. By 10am you have done zero actual work.

With Claude Code, the entire stack is accessible from one terminal window. You type natural language, Claude calls the APIs, and results appear where you need them. No tab switching. No context switching. No SaaS dashboards competing for your attention.

Laptop Power Shortcuts

These shortcuts make the terminal workflow even faster. Memorise the ones you use most:

CloudflareYour Deployment Engine

Cloudflare is the infrastructure layer that makes everything you build accessible to the world. Five services handle 90% of what you need — and they all work from the terminal via wrangler, Cloudflare's CLI tool.

Pages — Deploy Any Static Site

Cloudflare Pages hosts static sites globally with automatic HTTPS, custom domains, and instant cache invalidation. One command deploys your site to 300+ edge locations worldwide.

That is it. Your site is live. Pages auto-detects the build output, uploads it, assigns a .pages.dev URL, and you can attach a custom domain in the Cloudflare dashboard or via the API.

• Use for: landing pages, client presentation decks, HTML reports, marketing sites, documentation, any static asset
• Cost: Free tier covers most use cases. 500 deploys/month, unlimited bandwidth.
• Auto-deploy: Connect a GitHub repo and every push to main triggers a new deploy automatically.

Workers — Serverless Functions at the Edge

Workers run JavaScript/TypeScript at the edge — no servers to manage, no cold starts worth worrying about. Perfect for webhook receivers, API proxies, cron triggers, and lightweight backends.

• Use for: Webhook receivers (Stripe, CRM events), API proxies, cron jobs, form handlers, redirect engines
• Cost: Free tier = 100k requests/day. Paid = $5/month for 10M requests.

R2 — Object Storage

R2 is Cloudflare's answer to S3 — with zero egress fees. Store images, voice clones, large files, client assets, backup data. Access via Workers or direct URL.

• Use for: Image hosting, voice clone files, large PDF storage, media assets, backup archives
• Cost: Free tier = 10GB storage, 10M reads/month. Zero egress fees ever.
• Key advantage: No surprise bandwidth bills. Upload once, serve globally, pay only for storage.

DNS — Manage Domains from Terminal

Cloudflare DNS is the fastest authoritative DNS on the internet. Once your domains are on Cloudflare, you can manage records from the terminal, automate subdomain creation, and get automatic HTTPS on everything.

• Use for: Domain management, subdomain routing, custom domains for Pages sites
• Cost: Free for all domains.

KV — Key-Value Store

KV is a global key-value store accessible from Workers. Use it to store configuration, feature flags, session state, cached API responses, or any small piece of data that needs to be fast and globally available.

• Use for: Config storage, feature flags, cached API responses, rate limiting counters, A/B test assignments
• Cost: Free tier = 100k reads/day, 1k writes/day.

PipelineFrom Build to Live — The Deployment Pipeline

Every piece of work follows the same 5-stage pipeline from code to live URL. Understanding this pipeline means you never wonder "how do I get this in front of someone?" again.

The same pipeline applies whether you are shipping a client site, an internal dashboard, an HTML report, or a presentation deck. Here is the detail on each stage:

Recipe 1 — GitHub Pages (3 commands)

Recipe 2 — Cloudflare Pages (2 commands)

ContextManaging the Context Window

Every Claude Code conversation has a context window of approximately 200,000 tokens (~150,000 words). This is enormous — but not infinite. Understanding how it works and when it fills up is the difference between a productive 3-hour session and losing your work to compaction.

How Context Works

Everything in your conversation takes up context: your messages, Claude's responses, file contents, tool calls, tool results, memory files, CLAUDE.md. As the conversation grows, the oldest messages get compressed or summarised to make room for new ones. This process is called compaction.

Signs Your Context Is Filling Up

• Claude forgets instructions you gave earlier in the session
• Claude loses track of which files it already read or modified
• Claude repeats itself or re-discovers things it already knew
• Claude asks you to confirm things you already told it
• Output quality drops noticeably on tasks that were working fine earlier

6 Strategies to Manage Context

1. Break work into focused sessions

One task per chat. Do not use one conversation for the morning's ad campaign review and the afternoon's pitch deck. Start a new chat for each distinct task. This keeps context fresh and focused.

2. Use memory files to persist state across sessions

Anything that needs to survive between conversations goes in a memory file. When you start a new session, Claude reloads all memory files automatically. The state persists even if the conversation does not.

3. Front-load critical context

CLAUDE.md loads first in every conversation. Put your most important rules and identity there. It is the last thing to get compacted. Memory files load next. Structure your system so the most critical context loads earliest.

4. Use @file references instead of pasting content

When Claude reads a file via @file, it processes the content efficiently. When you paste the same content into the chat, it takes up context twice (your message + the content). Always reference files instead of pasting them.

5. Commit frequently

If context compresses and Claude loses track of what it built, the files are still safe on disk (and in git). Frequent commits mean you never lose work, even if the conversation degrades.

6. Run /reflect before closing

Before ending a session, capture the current state: what was done, what is pending, key decisions made, important file paths. Save this as a reflection file in memory. The next session picks up exactly where this one left off.

Multi-ChatRunning 5-6 Parallel Chats

The real power move is not one Claude conversation — it is 5-6 running simultaneously, each working on a different piece of the same project. This is how you build in hours what would take days sequentially.

The Rules of Parallel Chats

1. Every chat gets a codename

Label each chat for instant identification: Chat-A: Data, Chat-B: Design, Chat-C: Deploy, Chat-D: Content, Chat-E: QA. The codename goes in the first message of each chat so you can identify it from the VS Code tab.

2. Each chat owns specific files — NO overlap

Before launching parallel chats, assign file ownership. Chat-A writes to output/data/. Chat-B writes to output/design/. Chat-C handles deploy/. No exceptions.

3. Main chat coordinates and integrates

One chat is the orchestrator. It does not produce files directly — it reviews output from other chats, integrates results, handles shared surfaces (MEMORY.md, master plan, git commits), and resolves conflicts.

4. Label each chat's first message

Start every parallel chat's first message with the codename and description so VS Code tabs are immediately identifiable:

5. Commit per-chat, not per-session

Each chat produces its own commits. If Chat-B crashes, Chat-A and Chat-C's work is already committed and safe. Never batch all parallel work into one commit at the end.

PromptsAdvanced Prompt Patterns

Good prompts produce good output. Great prompts produce output you can ship without editing. These 5 patterns are the difference between "close enough" and "exactly right."

Pattern 1: Compound Prompts

Stack role + task + constraints + output format into a single structured prompt. Each layer narrows the output space.

Pattern 2: Chain-of-Thought Forcing

Force Claude to show its reasoning before giving an answer. This catches errors that skip-to-the-answer prompts miss.

Pattern 3: Self-Critique Loops

Make Claude write a first draft, critique it against specific criteria, then produce the final version. The critique step catches 80% of quality issues.

Pattern 4: Structured Output

When you need machine-readable or consistently formatted output, specify the exact structure in the prompt.

Pattern 5: Meta-Prompting

Instead of writing the prompt yourself, ask Claude to write the prompt. This works especially well for complex, multi-step workflows where you know the desired outcome but not the best way to instruct Claude.

Module 09Showcases — What This Stack Actually Built

Theory is cheap. Here are 6 real patterns we have executed — genericised but real numbers.

Common MistakesWhat Goes Wrong (And How to Fix It)

Everyone hits the same walls. Here are the 7 most common mistakes — most people discover these the hard way.

Module 10The Frontier — Agent SDK, Swarms, What's Next

Everything above is what is working today. Here is what is coming — and how to position yourself to use it the moment it arrives.

The Claude Agent SDK

Anthropic's Agent SDK lets you build custom agents that run outside of Claude Code. Think of it as Claude-as-a-library — you write Python or TypeScript, call Claude's API, and build agents that:

• Run on your own server (VPS, cloud function, local machine)
• Have custom tools (your own APIs, databases, services)
• Execute multi-step workflows autonomously
• Hand off to each other (Agent A completes → triggers Agent B)

Swarm Flow — Agents That Feed Each Other

A swarm is the end state: a network of agents where each agent's output is another agent's input. No human in the loop for routine operations.

Astro — The Recommended Framework

When plain HTML is not enough but Next.js is overkill, Astro is the sweet spot. It is the framework that best fits how Claude Code builds things — clean, fast, and minimal configuration.

The Vision

The tools exist today. The question is not "can we build this?" — it is "how fast can we wire it up?"

Your EdgeFinding Your Edge — Making Your First Money with AI

Everything in this guide is a tool. Tools do not make money. You make money by applying tools to problems people will pay to solve. Here is how to find your edge and monetise it.

Audit What You Already Know

Your unfair advantage is not Claude Code — it is your domain expertise combined with Claude Code. A pure techie can build the tool. A pure industry expert can identify the problem. You can do both. That combination is rare and valuable.

• Your industry knowledge: What do you know about your market that a developer does not? What problems do you see every day that could be automated?
• Your processes: Which manual workflows eat the most time? Which ones are repetitive and rule-based? Those are automation candidates.
• Your pain points: What frustrates you most about your current operations? Chances are, your competitors have the same frustrations.

Package It as a Service

Services sell faster than products. Do not build a SaaS on day one. Package your expertise + AI into a done-for-you service first:

• One niche: Pick one industry you understand deeply. "AI-powered Google Ads management for dentists" beats "AI services for everyone."
• One offer: One clear deliverable with one clear outcome. "We manage your YouTube channel end-to-end and grow it to 10k subscribers" is an offer. "We do AI stuff" is not.
• One workflow: Build one automated pipeline that delivers the offer. Claude Code + your APIs + your templates = repeatable delivery.

Price on Value, Not Hours

If Claude Code lets you deliver in 2 hours what used to take 20, do not charge for 2 hours. Charge based on the value the client receives. A competitive analysis that takes you 90 seconds to generate (but would take a consultant a full day) is worth what the consultant charges — or more, because you deliver faster.

Build Proof Fast

1. Do 3 projects at cost. Pick 3 businesses in your target niche. Deliver the service for free or at cost. Focus on producing great results.
2. Collect testimonials. After delivery, ask for a written or video testimonial. Specific results ("doubled our social media engagement in 3 weeks") beat generic praise.
3. Raise the price. With 3 case studies in hand, price at full value. The proof does the selling.

The Unfair Advantage

The people who win with AI are not the ones who learn the most tools. They are the ones who apply the right tool to a real problem, fast, and get paid for it. Everything in this guide exists to make that cycle — identify problem, build solution, deliver result, collect payment — as short as possible.