The Claude Code Bible for GTM Engineers

What you need

• Claude Pro ($20/month), Max ($100 or $200/month), Teams, Enterprise, or Console API account
• macOS 13+, Ubuntu 20.04+, or Windows 10+ with WSL2
• Minimum 4GB RAM (8GB recommended for large projects), stable internet
• All AI processing happens on Anthropic's servers — no GPU needed

Install commands

# Mac
brew install --cask claude-code

# Windows (recommended)
irm https://claude.ai/install.ps1 | iex

# Windows WinGet
winget install Anthropic.ClaudeCode

# Linux/Mac (npm, legacy)
npm install -g @anthropic-ai/claude-code

The native installer is preferred — it auto-updates in the background. Homebrew and WinGet do not auto-update; run brew upgrade claude-code or winget upgrade Anthropic.ClaudeCode manually.

After installing, open any project folder in your terminal and type claude. You'll be prompted to log in on first use. If it doesn't trigger, run /login.

VS Code / Cursor extension

Extensions pane → search "Claude Code" → install the Anthropic-verified extension only (blue checkmark). Unofficial forks have been found to contain malware. Never install unverified versions.

Once installed: Command Palette (Cmd+Shift+P / Ctrl+Shift+P) → type "Claude Code" → Open in New Tab. You get the full experience inside your editor with the file explorer alongside it. This is what most power users prefer over a standalone terminal.

Desktop app

The Claude desktop app has a dedicated Code tab that adds:

• Visual diff review before accepting file changes
• Multiple parallel sessions side by side
• Scheduled recurring tasks (run on Anthropic cloud even when your laptop is off)
• Remote sessions on Anthropic infrastructure — your code stays local, you control it from anywhere
• Computer use — Claude can control your desktop
• Dispatch: a persistent assistant that routes tasks to Claude Code automatically

The agentic loop

When you give Claude a task, it works through three phases that blend together.

Phase 1: gather context. Reads files, searches your codebase, fetches web pages, queries connected MCP tools. Claude decides what it needs to know before acting.

Phase 2: take action. Edits files, runs terminal commands, calls APIs, creates files, pushes to GitHub, sends Slack messages. Claude chains dozens of these together, deciding at each step based on the previous one.

Phase 3: verify results. Runs tests, takes screenshots, checks outputs against the goal, adjusts and retries. This verify-and-correct loop is where Claude Code beats a basic chatbot — it isn't perfect first time, but it iterates extremely fast.

Tools it has out of the box:

• Read, write, edit, create files on your computer
• Run bash/terminal commands
• Search files by pattern (glob) or content (grep)
• Fetch web pages and perform web searches
• Spawn subagents with their own isolated context windows
• Use any MCP server you connect
• Enter and exit Plan Mode programmatically
• Maintain a todo list across a session
• Ask you clarifying questions via a pop-up UI

Permission modes

Toggle in the prompt box bottom-left, or cycle with Shift+Tab.

Mode	Behaviour	When to use
Ask before edits (default)	Asks permission before every file change	First run of any new workflow. Most experienced users move away from this — it interrupts flow constantly.
Edit automatically	Edits existing files without asking, still asks before creating new ones	Good middle ground for trusted workflows
Plan Mode	Read-only. Analyses, reads, reasons, makes zero changes until you approve	The highest-ROI habit in Claude Code
Bypass permissions	Can do anything without asking	Validated, trusted workflows only

To enable bypass: Extensions → Claude Code → Settings → check "Allow dangerously skip permissions".

One documented case exists of Claude in bypass mode deleting everything on a user's hard drive after misinterpreting a request. Always validate new workflows in Plan Mode first.

CLAUDE.md is a markdown file in your project root that Claude reads at the start of every session — before you type anything. It's injected at the top of the conversation as a hidden prompt.

Think of it as the initial trajectory you set. A 1-degree error at departure becomes a massive miss over thousands of kilometres. Get this right and every session starts aligned, with no re-explaining.

Three levels

• Global — ~/.claude/CLAUDE.md — applies across every project on your machine. Personal preferences, tool conventions, default tone.
• Project — /your-project/CLAUDE.md — applies to one project. Commit this to git so the whole team gets it automatically.
• Enterprise — managed system-level file for Enterprise licences.

All three merge at session start. Global provides the base; project overrides or extends it.

Generate one with /init

Run /init inside any project. Claude reads your codebase, detects build systems, frameworks, and tools in use, and writes a starter CLAUDE.md. Refine from there rather than starting from scratch.

Without one, Claude has to re-read all your files every session to understand the project. With a good one, it already knows — which also cuts token cost significantly.

What to put in it for GTM work

ICP and language rules. Define your ICP once and Claude uses it in every piece of content:

• "Our ICP is B2B SaaS GTM engineers at 20-200 person companies"
• "Always say 'engineer', never 'operator'"
• "Assume the reader knows what cold email sequencing, lead scoring, MQL/SQL, and SDR workflows are. Skip beginner explanations."
• "Our clients are GTM agencies. We are their agency partner."

Tone and formatting rules:

• "No em dashes. Use short dashes, commas, or split into two sentences."
• "No metaphors. No fluff. Simple, tangible language."
• "No bullet points in LinkedIn posts unless explicitly requested."
• "Banned words: revolutionary, game-changer, leverage (as verb), synergy, circle back, touch base, seamless, robust, cutting-edge"
• "Write like explaining something to a senior colleague. Not presenting to a board."
• "Short sentences. One idea per sentence. Break for readability."

Active tools and integrations — tell Claude what's in your stack so it builds for your tools:

• "We use Instantly for cold email. Do not suggest Lemlist, Apollo, or Smartlead."
• "CRM is HubSpot. All lead data flows there."
• "Content calendar is in Notion. Database ID: [your ID]"
• "We distribute on LinkedIn and X only. Not Instagram, not TikTok."
• "Lead enrichment tool is Clay."

Workflow conventions:

• "LinkedIn CTA convention: 'Follow me + comment [KEYWORD]' with 'must follow' in brackets. Keywords are always single-word, all-caps."
• "Asset briefs always include: goal, audience, key message, visual direction, CTA"
• "When writing for LinkedIn, match the post format to the content structure (listicle vs carousel vs single insight vs data drop)"

Guardrails — put these at the TOP. Claude has primacy bias: it remembers the beginning and end of a prompt better than the middle, so your most critical rules go first.

• "Never send emails, post content, or push to any live platform without explicit written approval from me"
• "Never delete records from any database"
• "Never create paid campaigns or modify ad spend without asking first"
• "If you are unsure whether to proceed, stop and ask. Do not guess."
• "Never store API keys, passwords, or credentials in any file"

Rules that actually work

Do:

• Run /init first, then refine the output
• Keep under 200 lines. Beyond that, instruction-following degrades measurably. Claude Code's own system prompt already occupies roughly 50 instruction slots; you have 100–150 left.
• Write specific rules with counterexamples: "Sentences under 20 words ❌ don't write long compound sentences that try to cover multiple ideas ✅ one idea per sentence"
• Add a new rule every time Claude makes the same mistake twice
• Prune it regularly. Treat it like technical debt — delete rules Claude now follows naturally.
• Commit to git so the whole team benefits
• Import other files with @path/to/file.md — useful for pulling in a tone guide or client brief without bloating the main file

Don't:

• Don't dump entire API docs, style guides, or brand documents into it. Token cost every session adds up fast.
• Don't write vague rules like "be professional" or "write clearly". Claude doesn't know what that means for your context.
• Don't rely on it for everything. If Claude ignores a rule more than twice, it's too vague.
• Don't add rules you can't verify. If you can't tell from the output whether Claude followed a rule, it's too abstract.

The delivery caveat

CLAUDE.md is delivered as a user message, not a forced system-level config. Claude actively judges whether each rule is relevant to the current task and may skip rules it deems irrelevant.

The fix: write rules so specific and concrete that their relevance is obvious. "No em dashes" beats "write clearly". "Never exceed 150 words for LinkedIn hook paragraphs" beats "keep it concise".

Splitting into rules files

For larger setups, split into separate files inside .claude/rules/, each covering one domain:

• tone.md — voice, banned phrases, sentence rules
• workflow.md — how to handle tasks, when to stop and ask
• tools.md — which tools to use and which to never use
• clients.md — ICP definitions, client naming, channel conventions

Claude merges them all at session start, so different team members can own their area without editing a shared monolithic file.

Skills are SOPs for your AI. You write a workflow once, save it as a skill file, and Claude follows it reliably every time — the same way you'd train a new hire with a process document, except the agent actually reads and follows it.

The difference from prompting: a skill is permanent, reusable, and gets better every time you run it and add to it. Your 10th run is meaningfully better than your first because you've added every edge case.

Skills can run Python or JavaScript scripts, call APIs, scrape and process data, write and edit files, spawn subagents, be invoked by other skills, and trigger via slash command or natural language. They aren't passive prompt templates — Claude reads the skill and then acts.

Anatomy of a skill

A skill is a folder with a SKILL.md file inside, at .claude/skills/your-skill-name/SKILL.md.

Top section (YAML frontmatter):

---
name: linkedin-post-writer
description: Generates LinkedIn posts in Conigma format. Use when asked to write a LinkedIn post, create content for the feed, or draft a post about [topic].
---

Body section — step-by-step instructions in plain markdown:

# linkedin-post-writer
## Goal
Write a LinkedIn post that matches Conigma's format and ICP.
## Process
1. Ask: what's the post about? What format (listicle, insight, data drop, story)?
2. Read the tone rules from @.claude/rules/tone.md
3. Draft the post following the format guide below
4. Check against banned phrases list
5. Output final post + CTA in the correct convention
## Rules
- Never use em dashes
- CTA always: Follow me + comment [KEYWORD]

Why the description is the most critical part

Claude scans skill descriptions (roughly 100 tokens per skill) at session start to decide which skill to load. The full body only loads when relevant.

If your description is vague, the skill won't load when you need it. If it's too narrow, it won't load for variations of the same request.

• Good: "Generates LinkedIn posts in Conigma format. Use when asked to write a LinkedIn post, create content for the feed, or draft a post about any topic."
• Bad: "LinkedIn post"

Reference files

Point to additional files from inside a skill — Claude only loads them if the task requires it:

• @.claude/rules/tone.md — your tone guide
• @references/linkedin-formats.md — your post format library
• @scripts/scrape-leads.py — a Python script the skill should run
• @data/icp-definitions.md — ICP breakdown the skill should reference

Storing reference data separately keeps SKILL.md lean (under 500 lines) while giving Claude everything it needs.

How to build a skill: the feedback loop

Don't try to write a perfect skill upfront. Build iteratively.

Step 1: do the task manually with Claude. Walk Claude through it step by step in a normal conversation. When you get a result you're happy with, say: "This is great. This is something I do regularly. Turn this into a skill I can invoke anytime. Ask me any questions you need to get the instructions right."

Step 2: run it on a fresh session and watch. Invoke the skill and observe every step without intervening. Note anything that:

• Took too long — Claude was doing unnecessary work that could be hardcoded
• Was wrong — a rule you forgot to specify
• Was right but fragile — worked this time, might not next time

Step 3: update the skill with your observations. Add every failure to a ## Gotchas section at the bottom:

## Gotchas
- The Notion API returns pagination tokens. Always handle these — don't assume one call gets all records.
- Instantly rate limits at 100 requests/minute. Add a 1-second delay between calls.
- LinkedIn posts must not exceed 3000 characters or they get cut off in feed.

If a step always takes too long, hardcode its output. If Claude spends tokens looking up your Notion database ID every run, put the ID in the skill file.

Step 4: repeat until the error rate drops below 5%. First run maybe 60% correct, fifth run 85%, tenth run 95%+. Most knowledge-work skills hit reliable accuracy within 5–10 iterations.

GTM skills worth building first

LinkedIn post writer. Trigger: "Write a LinkedIn post about [topic]". Process: read tone rules → identify post format → draft → check against banned phrases → add CTA in correct format → output. Hardcode your CTA convention, keyword capitalisation rule, and character limits per format.

Asset brief generator. Trigger: "Write a brief for [asset type] promoting [topic]". Process: identify asset type → match to correct Figma template → fill in goal, audience, key message, visual direction, CTA, copy elements → output. Hardcode your template selection logic, brief structure, and design rules.

Content calendar card writer. Trigger: "Create a content calendar card for [topic] in status [X]". Process: read the card schema from Notion → generate post text → generate boosting comment → write asset brief anchor → push to Notion via MCP. Hardcode your Notion DB ID, card property names, boosting comment format, and the empty-block anchor string.

Lead scraper and classifier. Trigger: "Scrape [N] [job title/company type] in [location/vertical]". Process: test scrape 25 leads → verify quality → full scrape in parallel batches → LLM classify by ICP fit → enrich emails → upload to Google Sheet or Instantly. Hardcode your source, quality thresholds, ICP scoring criteria, and destination. Result: what used to take 60–90 minutes runs in under 2 minutes.

Cold email sequence writer. Trigger: "Write a [N]-step cold email sequence targeting [ICP] about [offer]". Process: read ICP definition → identify pain point angle → write subject lines and body per step → check against deliverability rules → format for Instantly import. Hardcode your sequence structure, character limits, CSV format, and CTA type.

Morning pulse check. Trigger: "Run morning pulse check" or "What do I need to action today?". Process: query ClickUp/Notion for open tasks → check Gmail for anything needing response → pull lead gen metrics from yesterday → summarise what needs attention, prioritised. Hardcode your specific list IDs — this saves significant tokens versus having Claude search for them every time. Delegate heavy data retrieval to a searcher subagent to keep the main session context clean.

Boosting comment generator (bulk). Trigger: "Generate boosting comments for all Review script cards in the content calendar". Process: query Notion for all cards in that status → read each post text → generate a boosting comment in your format → write it back to the card field.

Global vs project-level skills

Project-level (.claude/skills/) — only available in this project, checked into git so the whole team gets them. Keep to 3–5 per repo.

Global (~/.claude/skills/) — available in every project on your machine. For skills you use across all clients: your LinkedIn post format, your tone checker, your email writer.

Distribute team skills as plugins through a shared GitHub repo. Developers don't need the content writer's LinkedIn skills, and content writers don't need the developer's code review skills.

MCP (Model Context Protocol) is an open standard that lets Claude connect to external tools and services. Instead of copy-pasting data between systems, Claude reads and writes to them directly. It's the difference between telling Claude about your Notion database and Claude actually querying it live.

Anthropic, OpenAI, and Google have all adopted MCP. It's governed by the Linux Foundation, and the ecosystem has over 6,000 integrations.

How it works, and how to install one

An MCP server is a process that runs locally (or remotely). Claude sends it JSON-RPC messages; the server executes functions and returns results. You never see any of this — you just say "check what's in my Notion content calendar" and Claude does it.

1. Find the MCP server — Anthropic's official list, MCP Market, or the tool's own docs
2. Copy the JSON config snippet from its documentation
3. Tell Claude: "Install this MCP in my local workspace" and paste the JSON
4. For user-level installs available everywhere, run the install command with the --scope user flag
5. Open a new session and run /mcp to confirm it's connected

Most take under 2 minutes. Some require an API key or OAuth login — Claude will prompt you.

GTM-relevant MCPs

MCP	Key GTM use cases
Notion	Content calendar management, lead magnet library updates, client deliverable tracking, writing asset briefs straight to cards
HubSpot	Qualifying inbound leads against ICP, updating deal stages after calls, pulling pipeline data for weekly reporting, creating contacts from a CSV
Gmail	Labelling your inbox by category, drafting replies to standard enquiries, extracting lead info from inbound emails
Slack	Posting weekly performance summaries to client channels, pulling context from a sales thread, automating standup reports
Google Sheets	Lead list management, campaign performance tracking, content calendar data, client reporting
GitHub	Pushing changes, creating PRs, managing issues for any GTM tooling code
Linear / Asana / Monday / ClickUp	Pulling your task list for the morning pulse check, creating tasks from email summaries, updating project status
Supabase / Postgres	Querying tables, creating records, executing SQL for internal tools you build

Two notes worth acting on:

• Gmail: after prototyping with the MCP, convert high-frequency workflows to skills that call the Gmail API directly. Skills consume ~60 tokens; the Gmail MCP consumes thousands.
• ClickUp and similar: hardcode your specific list IDs in the skill file rather than having Claude search for them every time. One developer observed this cut token cost by ~80%.

The token cost warning

This is the biggest mistake people make with MCPs. Some MCP servers have enormous tool definitions that consume thousands of tokens before you type a single message.

Run /context to see exactly what's consuming your context window:

• System tools (Claude's built-in tools): ~17,000 tokens, unavoidable
• MCP tools: varies wildly. A single ClickUp search tool definition is 1,600 tokens. All ClickUp tools combined: ~20,000 tokens — more than the built-in system tools.
• Skills (front matter only): ~60 tokens each
• CLAUDE.md: depends on length

With a bloated MCP, you can start a session already 40–50% through your context window before doing any actual work.

The MCP-to-skill conversion strategy

1. Use the MCP to prototype and prove a workflow works — fast setup, 2 minutes
2. Once validated, say: "This worked. Now build a skill that calls the API directly instead of using the MCP. Find the specific API endpoints we need and write scripts for them."
3. Claude builds scripts that call the API natively. The skill now replaces the MCP for this workflow.
4. Remove the MCP if you no longer need it for other purposes

Result: same capability, 50–100x lower token footprint.

Chrome DevTools MCP (the exception)

The Chrome DevTools MCP is worth keeping permanently despite its token cost. It lets Claude control a live Chrome browser: navigate pages, take screenshots, click buttons, fill forms, extract data from pages with no API.

This is how you scrape LinkedIn, pull competitor data, and test landing pages automatically. The native browser tool in Claude is slow; Chrome DevTools MCP is significantly faster and supports building reusable browser automation scripts.

Running parallel sessions

Claude Code sessions are independent. You can run as many as you have tokens for, and each works on its own task simultaneously. Total time for 4 tasks is the duration of the longest single task, not all four added together.

1. Open 4 separate terminal windows or Claude Code tabs
2. Each in its own project folder or with its own task context
3. Assign each a different task: one writes LinkedIn posts, one scrapes leads, one drafts briefs, one runs a morning pulse check
4. All four run simultaneously

The practical limit is 3–4 sessions. Beyond that you spend more time context switching between windows than the parallelisation saves. The signal you have too many open: any agent has been idle waiting for your instructions for more than 10–20% of the session.

Set up a hook that plays a different chime when each window completes, so you always know which session needs attention without watching screens.

Subagents: offloading without polluting context

Subagents solve a specific problem. When Claude does heavy research, reads many web pages, or processes large datasets inside a main session, all of that fills the context window — and your main agent gets dumber the more it reads.

The fix: delegate heavy tasks to a subagent. The subagent works in its own isolated context, then returns only a summary. A research run that consumed 80,000 tokens in the subagent might return a 2,000-token summary. That's a 40x token saving.

Research subagent. For competitor intel, trending content, researching a new vertical, summarising industry news. Your main session sends a query; the subagent searches, reads, cross-references, then returns a structured summary. Use Sonnet or Haiku — high volume, lower reasoning. Configure in .claude/agents/research.md.

Reviewer subagent. For quality checking content before it goes out. The key advantage: the reviewer has no context about how the content was created. The main agent is biased toward its own output — it just wrote the thing, so it thinks it's good. A fresh agent with no history catches what the main agent rationalises away.

QA subagent. For running a checklist against any output. Give it your exact criteria: "Check that this post has no em dashes, uses the correct CTA format, is under [X] characters, doesn't use banned phrases, and addresses the ICP pain point." Having QA at the end of your pipeline catches formatting errors before they reach Notion or a client.

Subagent definitions live in .claude/agents/:

---
name: research
description: Research agent. Use when the main task requires gathering information from the web, summarising competitors, or pulling industry data. Returns a structured summary.
model: sonnet
---
# Research Agent
You are a research specialist. You receive a research query. You:
1. Search for information across relevant sources
2. Read and synthesise key findings
3. Return a structured summary with: key facts, sources, relevant quotes, confidence level
Always return in the format the requesting agent specifies. Be concise — your output should be the minimum needed to answer the question.

Start a new session after creating them for the subagents to become available.

Agent teams (experimental)

A team lead agent orchestrates multiple independent Claude instances. Each teammate maintains its own full context window and they can communicate with each other, not just report back to the lead.

Worth it for:

• Building 3 variations of a design simultaneously for comparison
• Parallel research with competing hypotheses
• Large codebase analysis split across modules
• Generating multiple iterations of a campaign concept in parallel

The cost warning: agent teams consume roughly 7x the tokens of a standard session, because every teammate runs its own full context window. One practitioner spent ~$80 on a single agent team session analysing a large codebase. For GTM content work, standard parallel sessions or subagents are more cost-effective.

Enable in settings.json: {"env": {"CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"}}

Git worktrees for parallel development

If you run parallel sessions in the same project folder, agents can step on each other's file changes. Git worktrees give each agent its own isolated working directory sharing the same git history.

Agent 1 works in /project-feature-a/, agent 2 in /project-feature-b/. Same repo, never conflicting. When both are done you merge their branches back into main, and Claude can handle the merge including conflicts.

Add a CLAUDE.md rule to activate this: "For parallel development work, use git worktrees. Create separate worktrees for each independent feature or task branch."

For pure content work — posts, briefs, emails — standard parallel sessions are fine, because you're not editing shared files.

Plan mode

Plan Mode forces Claude to think before it acts. It can read files, explore your project, and reason — but cannot write, edit, or run commands. It produces a step-by-step plan and waits for your approval.

A 5-minute plan prevents 30 minutes of undoing mistakes. A planning session also costs significantly fewer tokens than a building session, because reading is cheaper than executing.

To activate: Shift+Tab twice, type /plan, or select it from the mode picker.

When to use it for GTM work:

• Before running a skill for the first time
• Before any workflow that touches a live system (CRM, email platform, ad account, client Notion workspace)
• Before a multi-step automation (scrape → classify → enrich → upload), to verify the logic before any data moves
• When building a new internal tool
• Any time you'd normally nervously watch Claude to make sure it doesn't do something wrong

The explore-plan-execute pattern is the highest-ROI workflow in Claude Code:

1. Explore — let Claude read your project and understand what exists. No changes.
2. Plan — activate Plan Mode, give the task, review and iterate on the plan in this read-only space. Changes to a plan cost nothing; changes to built output cost time and tokens.
3. Execute — switch to Bypass permissions and let Claude build off the approved plan.

Without a plan: 15 min build + 5 min test + discover wrong approach + 15 min rebuild = 35+ minutes. With a plan: 5 min plan + catch problem + 5 min revised plan + 5 min build = 15 minutes.

The context window

Everything in your current session — every message, file read, tool call result, MCP response — accumulates as tokens. When it fills up, performance drops: Claude starts forgetting earlier instructions and making more mistakes.

Run /context for a live breakdown. A typical session start:

• System tools: ~17,000 tokens, fixed
• CLAUDE.md files (global + project): depends on length
• MCP tools: varies. A badly written MCP can add 20,000+ tokens before you type anything.
• Skills (front matter only): ~60–100 tokens each
• Memory file: usually under 200 tokens
• Your conversation messages: grows as you talk

Larger context window does not mean better performance. Opus with a clean 30% context often outperforms Sonnet with a cluttered 90% context. The quality of what's in the context matters more than how much space is available.

Context management commands

Command	What it does
/context	Full breakdown of what's consuming your window. Run when a session feels slow or Claude forgets earlier instructions.
/compact	Compresses conversation history into a high-density summary. Run at 70% context usage.
/compact [instructions]	Compact while preserving specifics: "compact this but keep all the Notion DB IDs and the final approved brief"
/clear	Wipes context entirely. Use when switching to a completely unrelated task.
/cost	Tokens used in the current session and estimated cost

Claude also auto-compacts as you approach the limit, running continuously in the background on newer versions.

Keeping sessions clean

Start each major task in a fresh session. Don't do all your GTM work in one marathon session. Carry-over context from unrelated tasks degrades quality.

Voice transcripts are context-expensive. You can speak at ~200 words per minute vs type at ~60, but transcripts include ums, ahs, restarts, and redundancy. Run the dump through a cheaper model first: "Summarise this voice transcript into a tight task brief", then pass that brief to your main agent.

Tell Claude to respond concisely. Add to CLAUDE.md: "Respond as concisely as possible. Use extended thinking when you need to reason, but keep your actual output to the minimum needed. If I need more detail, I'll ask." This trades longer thinking (which doesn't consume permanent context) for shorter output (which does).

Use skills to avoid re-explaining. Anything you find yourself explaining more than twice — your ICP, tone rules, workflow conventions — belongs in CLAUDE.md or a skill.

The three models

Sonnet 4.6 — your default (80% of tasks). The workhorse. Fast, cost-effective, handles writing, research, standard automation, and content work well. 79.6% on SWE-bench. 5x cheaper than Opus. Developers who use Claude Code daily report preferring Sonnet over Opus 59% of the time.

Use it for: writing posts, drafting emails, running skills, research subagents, content calendar work, building straightforward tools, anything you'll iterate on multiple times.

Opus 4.6 — for complex reasoning (20% of tasks). Deeper reasoning, better at architectural decisions, catches subtler issues. 5x more expensive than Sonnet. 80.8% on SWE-bench.

Use it for: designing a multi-step automation from scratch, critical decisions about how to build internal tools, any task where being wrong is expensive, complex analysis where you need to trust the reasoning chain. Opus fast mode is 2.5x faster at 3x the price — worth it for long sessions where you're actively steering.

Haiku 4.5 — for cheap repetitive tasks. Fastest, cheapest, lower reasoning capability.

Use it for: subagents doing classification, lead scoring, email labelling, data formatting — anything high-volume and low-complexity. When you're classifying 1,000 leads, Haiku is right. Using Opus for this is like hiring a senior consultant to file invoices. Don't use it for anything requiring nuanced judgment or complex writing.

Switching models mid-session

Run /model at any point to get a picker.

The dynamic switching pattern:

1. Start a complex task in Plan Mode with Opus — deep reasoning for planning
2. Approve the plan, switch to Sonnet for execution — fast and cheap for implementation
3. If you hit an unexpected hard problem, switch back to Opus for that step
4. Switch to Haiku for any bulk classification or formatting at the end

This gets you Opus-quality decisions at Sonnet-level average cost.

In subagent definition files, specify the model directly so your parent Opus session doesn't spawn Opus subagents at 5x the cost:

---
name: research
model: sonnet
---

Cheaper models aren't always cheaper

A less capable model requires more tokens to do the same task. It is not obvious that using a cheaper model is actually cheaper. Often, the most capable model is cheaper and less token-intensive because it completes the task faster with less correction.

— freeCodeCamp Claude Code Handbook

For complex tasks requiring multiple correction loops, Opus is sometimes cheaper in total token cost despite being more expensive per token. Choose based on task complexity, not reflex.

Extended thinking

A toggleable mode where Claude does significantly more internal reasoning before responding. The thinking process doesn't consume permanent context.

Use for complex strategy questions, multi-variable analysis, catching subtle errors, and architectural decisions. Don't use it for simple content tasks or quick questions — it's slower and you're paying for thinking you don't need.

The difference in practice: without extended thinking, Claude says "Your open rates are low, try personalising subject lines." With it: "Looking at your data, the 18% open rate isn't the core problem. Your CTR from openers is 12%, which is solid. But your bounce rate on the landing page is 67%. The people opening are qualified, but your offer positioning is misaligned with the pain points in your emails. Here are three specific tests..."

Via /model you can set the thinking budget. For most GTM work the default is fine.

Hooks are shell scripts that run automatically before or after Claude takes a specific action. You define them in .claude/settings.json, and they fire on events you configure — session start, before a file is written, after a tool call completes, when the session ends.

A hook specifies the triggering event (SessionStart, PreToolUse, PostToolUse, Stop), an optional tool name to match, the shell command to run, and the return value (exit 0 = continue, exit 2 = block the action).

GTM-relevant hooks

Chime notifications for parallel sessions. Play a sound when a session completes so you know when to check it. Set different chimes for different windows and you know immediately which session needs attention.

"hooks": {
  "Stop": [{
    "command": "afplay /System/Library/Sounds/Glass.aiff"
  }]
}

(Mac only. On Linux use aplay /path/to/sound.wav.)

Block writes to sensitive files. Even in Bypass mode, prevent Claude touching credentials, live configs, or production settings:

#!/bin/bash
# block-sensitive-files.sh
if [[ "$TOOL_INPUT_PATH" =~ \.env$|\.env\.|secrets/|prod-config|credentials ]]; then
  echo "BLOCKED: sensitive file path"
  exit 2
fi

This is the minimum security hook for any professional setup. Ten minutes to set up, and it prevents the class of accident where Claude modifies a file it shouldn't touch.

Auto-format on file write. Run a formatter every time Claude writes a file. For markdown and content files, run a custom linting script that checks for banned phrases, em dashes, or other violations and logs them.

Session logging. Log every session to a file. Over time you can search your history to find workflows you've already built, retrieve prompts that worked, and audit what Claude did in any past session.

Notification when long tasks finish. For overnight or background runs, trigger a Slack message or email when the session completes.

The Ralph-Wiggum loop (autonomous completion)

The ralph-wiggum plugin from the official Anthropic repo creates a self-referential loop using a Stop hook. When Claude tries to exit, the hook catches it, feeds the original task back, and forces it to continue until it outputs a specific completion string.

/ralph-loop "Your task description here" --completion-promise "DONE"

GTM use cases: running an overnight lead scrape and classification without babysitting it, batch-processing a large content calendar backlog, running quality passes on a large set of briefs. Set it going before you leave for the day.

Install: /plugin marketplace add anthropics/claude-code → install ralph-wiggum

The hookify plugin

The hookify plugin lets you create custom hooks by describing the behaviour you want in plain language, without writing shell scripts manually.

• /hookify — start the hook creation wizard
• /hookify:list — see all active hooks
• /hookify:configure — modify existing hooks

Describe what you want — "Run a script that checks for banned phrases any time Claude writes a markdown file" — and hookify creates the hook definition and the script.

Lead scraping pipeline

The full workflow from zero to a qualified lead list ready to upload to Instantly, running in under 2 minutes.

1. Test scrape of 25 leads from your source (Apify, Apollo, etc.) to verify quality
2. LLM-based quality check against your ICP definition
3. If quality passes, full parallel scrape (4 batches of 250 running simultaneously)
4. LLM classification of each lead against your ICP scoring criteria
5. Email enrichment on leads that pass
6. Upload to Google Sheet or Instantly CSV format

What used to take 60–90 minutes of manual work runs in 87 seconds.

What to hardcode in the skill: your scraping source and API key reference, ICP scoring criteria, quality threshold, Google Sheet destination ID and tab name, Instantly CSV column format, and the parallelisation strategy (4 batches of 250 runs in the same time as 1 batch of 250).

Turning it into an endpoint. Once the skill works reliably, deploy it as a URL using Modal — expose it as an API endpoint with a simple web form. Enter job title, location, count, click submit. The pipeline runs in the background and outputs a CSV download link, making the workflow accessible to anyone on the team without Claude Code installed.

Content multiplication system

Take one insight or client result and turn it into every format you need in one session.

1. Brief Claude with the raw material: "Here's a client result: [describe it]. I need this adapted for: 1) LinkedIn post, 2) cold email sequence (3 steps), 3) asset brief for a carousel."
2. Specify channel-level tone: "LinkedIn is conversational and direct. Cold email is shorter and outcome-focused. The carousel brief should specify what each slide covers."
3. Reference context already in the project: "Use the style guidelines in this project. Match the client's vertical context from the uploaded brief."
4. Claude generates all three simultaneously, adapted for each format.
5. Iterate individually: "Make the LinkedIn post 20% shorter" or "Email 2 needs a stronger objection handling angle."

One piece of source material → three polished formats → 15 minutes total. Once you've run this 2–3 times manually and refined the output, turn it into a skill.

Client deliverable factory

Generate professional client-facing reports in minutes, not hours.

Context: Use everything you know about [Client Name] from this project.

Deliverable type: .pptx presentation.

Contents:
- Slide 1: Executive summary of this month's results
- Slide 2: Key metrics with month-over-month comparison
- Slide 3: Channel breakdown with specific insights
- Slide 4: Wins and learnings
- Slide 5: Next month's strategy and priorities

Data: [paste this month's performance numbers]

Style: Professional but not corporate. Use charts, not tables. Insights must be specific
and include exact numbers. No generic observations.

What used to take 2 hours takes 20 minutes.

Setting up the project context so this works. Create a dedicated Project in Claude for each major client and upload their ICP brief, historical performance data, campaign results to date, brand voice and preferences, and any call notes. Every conversation in that project then has full context automatically.

Email inbox automation

Claude reads 100 emails, classifies each, and applies labels — in 36 seconds using direct Gmail API calls.

Default label scheme: Action Required, Reference, Waiting On. For GTM work, add Inbound Lead, Client, Partner, Platform Notification, Invoice.

Scaling it up. Convert to a subagent-based parallelised skill: spawn 10 subagents each handling 100 emails simultaneously, processing 1,000 emails in roughly 60 seconds. Subagents only return labels to the parent, not full email text, so context stays clean. Then extend it to draft replies for anything labelled Action Required.

Building and deploying internal tools

You don't need a developer. The explore-plan-execute pattern is enough.

1. Activate Plan Mode and describe what you want in plain language: "I want a tool where I enter a company name and it pulls their LinkedIn, website, employee count, and recent news into a one-pager brief."
2. Claude asks clarifying questions (tech stack, where it should live, who else uses it). Answer in plain language.
3. Claude produces a plan. Review, approve, or iterate.
4. Switch to Bypass permissions. Claude builds while you do other work.
5. Test the output, give feedback in plain language, iterate.

Building a full-stack web app with login, database, and clean UI takes roughly 15–30 minutes of active involvement.

Free deployment options:

Platform	Best for
Netlify	Static sites and simple web frontends
Vercel	Web apps (Next.js, React) — better for anything with a backend
Railway	Full-stack apps with databases
Modal	API endpoints and automation scripts — the most useful for GTM automation

Modal: turning any skill into a URL. Modal deploys any Python script as a publicly accessible URL. Take your lead scraping skill, deploy it as an endpoint, create a simple web form. Claude handles the entire setup: "Take my lead scraping workflow and deploy it as a Modal endpoint with a simple web form."

The endpoint is also compatible with n8n, Make, Zapier, and any webhook-based tool, so you can trigger GTM workflows from a Notion button, a Slack command, or an inbound lead event.

Security before making anything public. Claude Code-built tools are excellent for internal use. Before anything goes public-facing or in front of clients:

• Don't use obvious or short URLs — bots scan DNS ranges constantly
• Don't charge money through vibe-coded apps without a developer reviewing the authentication and payment logic
• Have someone with security knowledge review any app handling user data, passwords, or payment details

For internal team tools only, the risk is minimal and the productivity gain is immediate.

Session and context

Command	What it does
/help	Show all available commands
/clear	Wipe the entire context. Use when switching tasks completely.
/compact	Compress conversation history into a high-density summary. Run at 70% context.
/compact [instructions]	Compact with specific preservation instructions
/context	Full breakdown of what's consuming your context window
/cost	Token spend for the current session
/status	Current context fill percentage
/resume	Continue a previous conversation, across sessions

Configuration

Command	What it does
/model	Switch between Opus, Sonnet, and Haiku mid-session
/thinking	Toggle extended thinking, or adjust the thinking budget
/permissions	Manage what Claude can and cannot do in this session
/config	Open configuration settings
/login	Re-authenticate or switch accounts
/mcp	Show all connected MCP servers and their status
/mcp [server-name]	Details on a specific MCP connection

Project setup

Command	What it does
/init	Analyse your project and generate a starter CLAUDE.md. Run in every new project first.
/memory	View or edit Claude's persistent memory file

Workflow modes

Command	What it does
/plan	Enter Plan Mode (read-only, no file changes)
Shift+Tab	Cycle through permission modes (ask → auto → plan → bypass)
Shift+Tab twice	Jump directly to Plan Mode
/web-setup	Connect GitHub using your local gh CLI credentials and set up Claude Code on the web
/teleport (/tp)	Pull a web or cloud session back into your local terminal
/remote-control (/rc)	Monitor and steer a terminal session from your phone or browser
/tasks	See all active sessions and their status
/schedule	Schedule recurring tasks on Anthropic cloud infrastructure

Diagnostics and insights

Command	What it does
/doctor	Full diagnostic on your installation — PATH, authentication, version, config issues. Run this first if anything behaves unexpectedly.
/insights	Usage report: sessions, parallel sessions, most-used tools, where Claude performs well and struggles. Run monthly to identify where to build new skills.
/bug	Report an issue directly to Anthropic
/status-line	Customise the status bar — token percentage, model name, git branch

For the status line, run /status-line then tell Claude "Show a loading bar with tokens used as a percentage of total context". Note this only works in terminal mode, not the GUI extension.

Plugins

Command	What it does
/plugin marketplace add [owner/repo]	Add a plugin marketplace from a GitHub repo
/plugin install [plugin-name]	Install a plugin from a connected marketplace
/plugin list	See installed plugins

Official Anthropic marketplace: /plugin marketplace add anthropics/claude-code

Community marketplace: /plugin marketplace add quemsah/awesome-claude-plugins

Key plugins worth installing:

• code-review — automated PR review using 4 parallel agents
• frontend-design — improves design quality for UI work, auto-invoked on frontend tasks
• context7 — fetches up-to-date documentation for any library so Claude doesn't use deprecated APIs
• ralph-wiggum — autonomous loop until completion, for overnight or background tasks
• hookify — create hooks by describing what you want in plain language
• feature-dev — guided feature development workflow with specialist agents