Claude Code for GTM: The Beginner's Build Guide

What GTM Teams Are Actually Building With Claude Code in 2026

Most AI GTM adoption in 2026 is still individual. One operator figures out a workflow, uses it daily, and the insight stays on their machine. The team does not compound. The org does not learn. The advantage evaporates when the person leaves.

The teams creating durable separation are building differently. They have a shared plugin architecture: skills, agents, commands, and MCP configurations packaged and distributed across the revenue team from a single repo. When the workflow improves, every seat improves simultaneously. That is the compounding mechanism that makes Claude Code a revenue infrastructure investment rather than a productivity tool.

This article maps the nine-plugin build sequence in the order it should be implemented, with the exact install commands and AIM-format prompts for each. The sequence is not arbitrary. Each plugin builds on context established by the previous one.

SETUP LAYER
  001 Setup          → Claude Code installed, environment configured
  002 Company Context → Business context injected into every session
  003 CLAUDE.md       → Persistent memory and behavioral rules

EXECUTION LAYER
  004 Git Basics     → Version control for all GTM workflows
  005 Plan Mode      → Structured reasoning before any execution
  006 Skills         → Reusable workflow units (enrichment, scoring)

DISTRIBUTION LAYER
  007 Agents         → Autonomous multi-step GTM tasks
  008 Plugins        → Package + distribute team-wide, via Git
  009 MCPs           → Live CRM, docs, and database connections
                       (Attio MCP, Context7, Supabase MCP)

COMPOUNDING LOGIC:
  Setup + Context + Memory
      → Version-controlled execution
          → Packaged team distribution
              → Live data connections
                  → Feedback loop closes. System improves.

The Behavioral Contract Every GTM Workspace Needs

Before the nine plugins make sense, one file has to exist: CLAUDE.md. It is the persistent instruction layer that turns Claude Code from a blank slate into an opinionated operator. Every session reads it first. Without it, your skills are undirected. Your agents have no behavioral floor. Your plugin compounding is built on sand.

The clearest published example of what a production CLAUDE.md looks like comes from Boris Cherny — a senior engineer at Anthropic and the creator of TypeScript's Flow type system. His CLAUDE.md file, which he has shared publicly, is organized around three layers: Workflow Orchestration, Task Management, and Core Principles. It is worth studying because it solves the exact problems GTM operators run into when Claude starts producing inconsistent output across sessions.

## Workflow Orchestration

### 1. Plan Mode Default
- Enter plan mode for ANY non-trivial task (3+ steps or architectural decisions)
- If something goes sideways, STOP and re-plan immediately
- Use plan mode for verification steps, not just building
- Write detailed specs upfront to reduce ambiguity

### 2. Subagent Strategy
- Use subagents liberally to keep main context window clean
- Offload research, exploration, and parallel analysis to subagents
- For complex problems, throw more compute at it via subagents
- One task per subagent for focused execution

### 3. Self-Improvement Loop
- After ANY correction: update tasks/lessons.md with the pattern
- Write rules for yourself that prevent the same mistake
- Ruthlessly iterate on these lessons until mistake rate drops
- Review lessons at session start for relevant project

### 4. Verification Before Done
- Never mark a task complete without proving it works
- Ask yourself: "Would a staff engineer approve this?"
- Run tests, check logs, demonstrate correctness

### 5. Autonomous Bug Fixing
- When given a bug report: just fix it. No hand-holding.
- Point at logs, errors, failing tests — then resolve them
- Zero context switching required from the user

## Task Management

1. Plan First: Write plan to tasks/todo.md with checkable items
2. Verify Plan: Check in before starting implementation
3. Track Progress: Mark items complete as you go
4. Explain Changes: High-level summary at each step
5. Document Results: Add review section to tasks/todo.md
6. Capture Lessons: Update tasks/lessons.md after corrections

## Core Principles

- Simplicity First: Make every change as simple as possible.
- No Laziness: Find root causes. No temporary fixes.
- Minimal Impact: Only touch what's necessary.

Garry Tan's gstack: What a Distributed Workspace Looks Like in Practice

The fastest way to understand what a fully built-out Claude Code workspace looks like is to study one that is already running in production and open-sourced for inspection. Garry Tan — President and CEO of Y Combinator — open-sourced his personal Claude Code setup in March 2026 under the name gstack. He did not write this article; he built and shared the workspace. It is a direct implementation of the architecture this article describes: a CLAUDE.md behavioral layer, role-specific skills, and a one-command install that distributes the entire setup to a new team member.

The reception was immediate and polarized. A CTO installing gstack reported that the engineering review skill caught a cross-site scripting attack his own team had missed. Critics pointed out that it was, at its core, structured markdown files. Both reactions are correct. The markdown files are the point. Structured, distributed, version-controlled prompt architecture is what separates a team that compounds from one that does not.

# Step 1: Clone gstack into your Claude skills directory
git clone https://github.com/garrytan/gstack.git \
  ~/.claude/skills/gstack && \
  cd ~/.claude/skills/gstack && ./setup

# Step 2: Add the gstack section to your CLAUDE.md
## gstack
Use /browse from gstack for all web browsing.
Available skills: /plan-ceo-review, /plan-eng-review,
/plan-design-review, /design-consultation, /review,
/ship, /browse, /qa, /qa-only, /qa-design-review,
/retro, /document-release.

# Step 3: Distribute to a teammate (2nd install command)
git clone https://github.com/garrytan/gstack.git \
  .claude/skills/gstack

# Step 4: Verify skills are loaded in Claude Code
claude
/plan-ceo-review   # CEO strategic lens
/review            # Engineering review — catches bugs, XSS
/qa                # QA against current branch diff
/ship              # Release workflow

Nine Plugins. Exact Commands. In Order.

Each plugin below includes the install command, the GTM use case, and an AIM-format Claude prompt you can run immediately. AIM = Action, Input, Model behavior. It is the cleanest prompt structure for GTM operators who need reliable, repeatable outputs rather than conversational responses.

# Install Node.js 18+ first (required by Claude Code)
# https://nodejs.org

# Install Claude Code globally
npm install -g @anthropic-ai/claude-code

# Verify install
claude --version

# Launch in your project folder
cd ~/gtm-workspace && claude

# Create a context directory in your project
mkdir -p ~/gtm-workspace/context
touch ~/gtm-workspace/context/company.md

# Open and fill in with your GTM context
# Minimum required fields:
## ICP
## Persona titles we sell to
## Core pain we solve
## Top 3 competitors + differentiation
## Current messaging pillars
## Deals we have lost and why

# CLAUDE.md — GTM Workspace Rules

## Tone
- Direct. No filler sentences. No motivational language.
- Write like a senior AE, not a content marketer.

## Output Format
- Always return structured output (JSON or markdown table)
  unless I ask for prose copy.
- Flag confidence level on any enrichment or scoring output.

## GTM Rules
- Never fabricate company data. If unknown, return null.
- Personalization must reference a specific, verifiable signal.
- Do not use em dashes.

## Files to Read First
- context/company.md
- context/icp.md (if present)

cd ~/gtm-workspace
git init
git add .
git commit -m "initial: CLAUDE.md + company context"

# Connect to shared team repo (replace with your org URL)
git remote add origin https://github.com/YOUR-ORG/gtm-workspace
git push -u origin main

# When a workflow improves, commit the change
git commit -am "improve: enrichment skill v2 — higher match rate"

# Toggle Plan Mode with Shift+Tab before running complex tasks
# Or prefix any prompt with:

"Before executing, show me a step-by-step plan.
 Do not run anything until I approve the plan."

# Plan Mode output will show:
# Step 1: Read [file]
# Step 2: Query [API]
# Step 3: Write to [CRM field]
# Then wait for your approval before proceeding

# Skill: CSV Domain Enrichment

## Purpose
Take a list of domains, find contacts matching
target job titles, run waterfall email enrichment.

## Inputs Required
- accounts.csv (columns: domain, company_name)
- target_titles: read from context/icp.md

## Steps
1. Read accounts.csv
2. For each domain, query Instantly.ai API for
   contacts matching target_titles
3. For any contact without email, run waterfall:
   Apollo → Hunter → Dropcontact
4. Return enriched CSV with columns:
   domain, full_name, title, email, source, confidence

## Output Format
- enriched_accounts.csv
- enrichment_log.json (match rate, source breakdown)

# Agent: Outbound Preparation Agent

## Trigger
Run when accounts.csv is updated with new domains.

## Task Sequence
1. Run skill: csv-enrichment (get contacts + emails)
2. Run skill: icp-scoring (score each contact 1-10)
3. Filter: keep contacts with score >= 7
4. Run skill: signal-research (find 1 verifiable
   trigger per contact from public sources)
5. Run skill: copy-generation (write 3 subject line
   variants + 1 opening line per contact)
6. Output: outbound_ready.csv

## Error Handling
- If enrichment match rate < 30%: flag domain, skip
- If no signal found: flag contact, do not generate copy
- Log all skips to prep_exceptions.json

# Plugin directory structure
mkdir -p .claude/plugins/gtm-core

# plugin.json defines what is bundled
{
  "name": "gtm-core",
  "version": "1.0.0",
  "skills": ["csv-enrichment", "icp-scoring", "copy-generation"],
  "agents": ["outbound-prep-agent"],
  "mcps": ["attio", "context7"]
}

# Commit and push to team repo
git add .claude/plugins/
git commit -m "plugin: gtm-core v1.0 — enrichment + outbound prep"
git push origin main

# Teammate installs with one command
claude plugin install https://github.com/YOUR-ORG/gtm-workspace \
  --plugin gtm-core

# Add to your Claude Code MCP config
# File: ~/.claude/mcp_settings.json

{
  "mcpServers": {
    "attio": {
      "command": "npx",
      "args": ["-y", "@attio/mcp-server"],
      "env": {
        "ATTIO_API_KEY": "your_attio_api_key_here"
      }
    },
    "context7": {
      "command": "npx",
      "args": ["-y", "@upstash/context7-mcp"]
    }
  }
}

# Verify MCPs are loaded
claude mcp list

# Context window note: each MCP loads tool defs on startup.
# Keep only essential MCPs always-on.
# Enable Attio per-session for pipeline work only.

Why the Sequence Order Matters in 2026

The nine plugins are not independent. Each layer depends on the one before it. CLAUDE.md rules govern how skills behave. Skills are what agents orchestrate. Agents are what plugins distribute. MCPs are what give agents live context to act on. Build out of sequence and the compounding breaks.

Session starts
      |
      v
CLAUDE.md rules loaded          [Episode 003]
      |
      v
Company context injected        [Episode 002]
      |
      v
MCP connections active          [Episode 009]
 - Attio: live CRM data
 - Context7: live documentation
      |
      v
Plan Mode evaluates task        [Episode 005]
      |
      v
Agent runs skill sequence       [Episode 007 + 006]
 - csv-enrichment skill
 - icp-scoring skill
 - copy-generation skill
      |
      v
Git commits output + skill diff [Episode 004]
      |
      v
Plugin updated in shared repo   [Episode 008]
      |
      v
All teammates get updated       [Episode 008]
workflow on next session

FEEDBACK LOOP:
  Output quality observed by team
       |
       v
  Skill or CLAUDE.md updated
       |
       v
  Plugin version bumped + pushed
       |
       v
  Entire team improves simultaneously

Three Metrics That Indicate the Architecture Is Actually Compounding

If a new hire takes more than one command to replicate the team's Claude Code setup, the plugin layer is not deployed. If a workflow improvement sits on one operator's machine for more than 24 hours, the distribution mechanism is broken. If any GTM workflow change required a vendor support ticket, the stack has not replaced point-and-click dependency.

Chat, Signals, and Creating the Campaign

The architecture above is the engine. This is the moment it produces revenue output. Once your workspace is running — CLAUDE.md written, skills built, gstack or equivalent installed, MCPs connected — the workflow shifts from setup to execution. The question becomes: what signals are your target accounts giving you right now, and how fast can you turn those signals into personalized outbound?

The pattern that AI-native GTM teams are running in 2026 looks like this: Claude monitors signal sources (LinkedIn activity, job postings, funding announcements, product launches) via the MCP layer, scores each signal against your ICP, and drafts a campaign sequence — subject lines, opening lines, call-to-action — before a human even opens their CRM. The human reviews, approves, and the sequence fires. The entire loop from signal to send can run in under 15 minutes.

"Research the following 10 accounts and find one
 verifiable, recent signal per account that our ICP
 persona would care about. Use context/icp.md for
 relevance criteria. Sources: LinkedIn company pages,
 recent press releases, job postings on their site.

 For each account return:
 - Company name
 - Signal type (hiring, funding, launch, expansion)
 - Signal summary (1 sentence, specific)
 - Why this signal matters to our ICP
 - Confidence: High / Medium / Low

 Flag any account where no credible signal exists.
 Do not fabricate. Return null if uncertain."

"Using signals_output.json and context/company.md,
 generate a 3-touch outbound sequence for each account.

 Per account, per touch:
 - Subject line (under 8 words, no clickbait)
 - Opening line (references the specific signal)
 - CTA (one clear ask, no options)

 Rules from CLAUDE.md apply:
 - No em dashes
 - No motivational language
 - Write like a senior AE, not a content marketer
 - If confidence is less than High on signal,
   do not reference it

 Output: campaign_sequences.json
 Format: {account, touch_1, touch_2, touch_3}"

# X (Twitter) is one of the highest-signal sources
# for GTM triggers: launches, hiring, frustrations,
# competitive commentary. Build your ICP signal
# network on X systematically.

AIM Prompt — Build X Signal List:

Action: "From accounts.csv, generate a list of the
 likely X handles for each company and their key
 decision-makers. Draft a Claude Code skill that
 monitors their public posts for signals matching
 our ICP trigger criteria."

Input: accounts.csv, context/icp.md (trigger criteria:
 hiring SDRs, raising Series B+, launching new product,
 posting about a pain we solve)

Model: Return a SKILL.md file for x-signal-monitor
 that can be added to .claude/skills/ and run
 on demand to surface new triggers weekly.

Architecture analysis based on practitioner implementation patterns across AI-native GTM teams, Q1 2026. Plugin sequence follows the Claude Code for GTM series by Nick Grantham on LinkedIn (Episodes 001-009). CLAUDE.md framework based on Boris Cherny's published workspace (Anthropic). gstack workspace by Garry Tan, open-sourced March 2026 at github.com/garrytan/gstack. AIM prompt format: Action / Input / Model behavior. All install commands tested against Claude Code CLI current release. InGrow GTM Intelligence, Volume 07, March 2026.