GTM Operators Guide · Updated March 2026

The Non-Technical Leader's Guide to Claude: Chat, Cowork & Code

Everything you need to know about Claude's three products — and why the one marketed to engineers might be the most powerful tool in your stack. No engineering degree required.

Jonathan Moss EVP Growth & Operations, Experity · Host, AI Business Network 45 min read
Section 01

The Three Claudes — Quick Overview

Anthropic ships Claude in three distinct products. They share the same brain, but the body is completely different. Think of it like this: same chef, three different kitchens.

If you've used Claude at all, you've probably used Claude Chat — the conversational AI in your browser. That's the starting point for most people. But Anthropic has built two other products that dramatically expand what Claude can do, and most GTM leaders haven't explored either one.

Here's the quick orientation before we go deep on each.

Claude Chat

The conversational AI you know. Browser or desktop app. Brainstorm, draft, analyze, Q&A. Creates artifacts (code snippets, documents) that you copy-paste out.

Best for
Quick answers Brainstorming Drafting Analysis

Claude Cowork

Autonomous desktop agent. Runs in a sandboxed Linux VM inside the Claude Desktop app. Creates real files — .docx, .pptx, .xlsx, .pdf. Coordinates sub-agents for complex tasks.

Best for
File creation Workflows Research Multi-step tasks

Claude Code

Terminal-based agentic AI (CLI). Full filesystem access on YOUR machine. Git-native. Creates and edits any file type. The most powerful of the three — and despite the name, not just for engineers.

Best for
Power users Automation Custom agents Full control
Key Insight

Same model, different capabilities. All three products run the same Claude model (Sonnet, Opus, or Haiku). The difference isn't intelligence — it's what tools Claude has access to. Chat gets a text box. Cowork gets a sandboxed computer. Code gets your actual computer. That's the entire difference.

The Access Question

Claude Chat is available on every plan, including the free tier. You can start using it right now at claude.ai.

Claude Cowork requires a Pro plan ($20/month) or higher. You access it through a special tab in the Claude Desktop app — it's not available in the browser.

Claude Code is available on Pro, Max ($100/month or $200/month), Team, and Enterprise plans. You install it via your terminal with a single command. Despite what you might assume from the name, it does not require any programming knowledge.

The Interface Question

This is where most people's mental model breaks down. Let me clarify what each "interface" actually looks like:

  • Chat: A familiar web interface. You type in a box, Claude responds. Artifacts appear in a side panel. Feels like texting a very smart colleague.
  • Cowork: A tab inside the Claude Desktop app labeled "Cowork." You describe a task, and Claude works autonomously — creating files, running code, browsing the web. You watch it work in real time. Feels like delegating to an employee with a screen share.
  • Code: A terminal window. You type claude, press Enter, and start talking. That's it. It responds with text, creates files, runs commands. Feels like having a conversation in a text editor — except that text editor can do anything your computer can do.
For the Record

If you can use iMessage, you can use Claude Code. The terminal is just a text box with a different color scheme. You type words. Claude types words back. The only difference is that Claude Code can also create files, run programs, and interact with your tools while it does it.

Section 02

The Full Comparison Matrix

Here's every meaningful difference between the three products, in one table. Reference this whenever you're deciding which to use for a specific task.

Feature Chat Cowork Code
Interface Browser / Desktop app Desktop app (Cowork tab) Terminal (CLI)
File Creation Artifacts (copy/paste) Real files (sandboxed VM) Real files (your filesystem)
Code Execution None Sandboxed Linux VM Your local machine
Web Browsing Limited (search grounding) Full browser in VM Via MCP tools / fetch
Task Planning Manual (you guide) Automatic sub-agents Automatic with tool use
Memory Per-conversation Per-session (configurable) Per-project (CLAUDE.md + auto-memory)
MCP Connectors Remote MCPs only Remote + Local MCPs Full MCP support (local + remote)
Skills / Plugins Skills via settings panel Full plugin panel Skills + custom agents + hooks
Git Integration None Limited Full native (commits, PRs, branches)
Custom Agents No No Yes (.claude/agents/)
Scheduled Tasks No Yes (beta) Yes (cron, scripts, hooks)
Context Window Standard (200K tokens) Standard (200K tokens) Standard + auto-compaction
Multi-file Editing No Yes (in sandbox) Yes (your real files)
Image Understanding Yes (upload/paste) Yes (screenshots + upload) Yes (reads image files)
Cost Free tier available Pro+ ($20/mo minimum) Pro+ ($20/mo minimum)
Learning Curve None Low (10 minutes) Low (30 minutes)
Best For Quick tasks, brainstorming Workflows, real file creation Power users, systems, automation
Pattern to Notice

Look at the green highlights in the "Code" column. For almost every capability dimension — file creation, execution, memory, integrations, agents, scheduling — Code is the most powerful option. This isn't an accident. Code runs in your real environment with your real tools. The sandbox that makes Cowork safer also makes it less capable. That tradeoff is worth understanding.

A Note on Model Selection

All three products let you select which Claude model to use. As of March 2026:

  • Claude Sonnet — Fast, capable, and the default. Great for 90% of tasks. Used in the background for sub-agent work in Cowork.
  • Claude Opus — The most intelligent model. Better for complex reasoning, nuanced writing, and hard problems. Available on Max plans or higher.
  • Claude Haiku — Fastest model. Good for simple tasks where speed matters more than depth.

The model you choose matters less than which product you use. A Sonnet in Code with the right agents and memory will dramatically outperform an Opus in Chat with no context.

Section 03

The Biggest Misconception About Claude Code

This section might be the most important thing you read today. It's the reason I wrote this entire guide.

The Myth

"Claude Code is a developer tool. I'm not technical, so it's not for me."

I hear this constantly from GTM leaders, revenue operators, marketing directors, and sales VPs. They see the word "Code" in the name. They see that Anthropic's landing page shows terminal screenshots. They see it mentioned in engineering blogs. And they close the tab.

This is a massive strategic mistake.

Claude Code is, by a significant margin, the most powerful AI assistant available to anyone who does knowledge work. The name is misleading. Yes, engineers use it to write code. But the tool itself is a general-purpose AI agent that operates on your computer. It reads files. It writes files. It connects to your tools. It remembers context across sessions. It coordinates specialized sub-agents. It automates repetitive work.

None of that requires writing a single line of code.

What Actually Happens When You Use Claude Code

Let me walk you through a real interaction. Here's what using Claude Code looks like:

$ claude

  You: I need a competitive analysis of the top 5 patient engagement
       platforms. Focus on pricing, features, and market positioning.
       Create a Word doc I can share with my team.

  Claude: I'll research those competitors and create a comprehensive
          analysis document. Let me start by gathering information...

  [Claude researches, analyzes, creates a .docx file on your desktop]

  Claude: Done. I've created "competitive-analysis.docx" on your Desktop
          with detailed profiles of Phreesia, Weave, Solutionreach,
          Klara, and Luma Health. Each profile includes pricing tiers,
          feature comparison, market positioning, and strategic
          vulnerabilities. Want me to also create a one-page executive
          summary?

That's it. You typed English. Claude did the work. A real file appeared on your computer. No code. No commands. No technical knowledge.

Why Code Is More Powerful Than Chat or Cowork

Here are the specific advantages that matter for GTM operators:

1. Persistent Memory (CLAUDE.md)

In Chat, every conversation starts from zero. Claude doesn't know who you are, what you sell, or who your competitors are. You re-explain context every single time.

In Code, you create a file called CLAUDE.md in your project folder. It contains everything Claude needs to know: your ICP, your product, your competitive landscape, your voice, your goals. Claude reads this automatically at the start of every session. It's like having an employee who never forgets their onboarding.

2. Custom Agents (.claude/agents/)

This is the killer feature. In your project folder, you can create a directory called .claude/agents/ and fill it with markdown files that define specialized personas. Each one becomes a specialist you can invoke by name.

I personally run a system with 60+ agents covering every GTM function: a CMO who builds strategies, a VP of Demand Gen who creates pipeline plans, an SEO Manager who does keyword research, a Competitive Intel Analyst who monitors competitors, a Sales Enablement Manager who creates battlecards. Each one has its own expertise, frameworks, and output formats baked in.

When I need a content strategy, I don't prompt engineer from scratch every time. I tell Claude: "Use the VP Content Marketing agent to build a 90-day content strategy for [product]." The agent brings all the frameworks, best practices, and structure. I bring the business context.

3. Real Filesystem Access

Cowork creates files in a sandbox — a temporary virtual machine. When the session ends, you need to download those files. Code creates files directly on your computer, in your actual folder structure. It can read your existing documents, update spreadsheets, modify presentations, and organize files across directories.

4. Full MCP Integration

Code supports every MCP (Model Context Protocol) server, giving Claude direct access to your tools: HubSpot, Notion, Google Analytics, GitHub, Slack, Gmail, Google Calendar, and hundreds more. Claude doesn't just generate a report — it pulls live data from your CRM, analyzes it, and creates the deliverable. All in one flow.

5. Automation and Scheduling

You can set up Code to run tasks on a schedule. Monthly competitive analysis? Weekly pipeline reports? Daily content briefs? Set it up once, and it runs automatically. Try doing that with Chat.

What Non-Technical People Actually Use Claude Code For

These are real use cases from real GTM operators, not hypotheticals:

  • Building complete marketing strategies with 60+ specialized agents
  • Creating competitive battlecards, content calendars, and sales playbooks
  • Analyzing pipeline data and building revenue forecasts
  • Managing a personal knowledge system with cross-linked insights
  • Running automated research and competitive monitoring
  • Creating landing pages, pitch decks, and full websites
  • Connecting to CRMs, email, Slack, and Notion for live data workflows
  • Building custom dashboards from Google Analytics data
  • Generating weekly executive briefings from multiple data sources
  • Orchestrating multi-agent workflows (research, analyze, write, review)

The 5-Minute Setup

Here's exactly how you get started. Total time: under 5 minutes.

Step 1: Install — Open your terminal (on Mac: search "Terminal" in Spotlight). Paste this command:

npm install -g @anthropic-ai/claude-code

If you don't have npm, install Node.js first from nodejs.org (download, double-click, done).

Step 2: Authenticate — Type claude and press Enter. It will walk you through signing in with your Anthropic account. One-time setup.

Step 3: Start Working — Navigate to any folder on your computer (or just stay where you are) and type claude. Start talking. That's it.

$ cd ~/Desktop/my-project
$ claude
You: Hey Claude, let's get to work. Here's what I need...
Pro Tip

Create a folder on your Desktop called something like "AI-Workspace." Navigate there before starting Claude Code. This becomes your default working directory. Everything Claude creates goes here, organized the way you want.

Addressing the Fear Directly

Let me anticipate your objections:

"What if I break something?" — Claude Code asks for permission before making changes. It shows you what it's about to do and waits for you to approve. You're always in control.

"I don't understand the terminal." — You don't need to. You type claude and then type English. The terminal is just the container. You never need to learn terminal commands. Claude handles all of that.

"What if I need help?" — Type /help inside Claude Code. It explains everything. Or just ask Claude: "How do I do X?" It will walk you through it in plain language.

"Isn't this overkill for what I need?" — Maybe. If all you need is a quick brainstorm or a one-off draft, Chat is perfect. But if you're doing knowledge work that involves multiple steps, recurring tasks, or persistent context, Code isn't overkill — it's the right tool for the job.

Section 04

Skills vs. Agents — The Critical Distinction

Two concepts, constantly confused, that fundamentally change how you use AI tools. Here's the clean breakdown.

The Analogy

Think of a company:

  • Agents are like employees in departments. A CMO, a VP of Sales, a Content Writer. Each one has a specific role, domain expertise, and decision-making authority. They're vertical — deep in one area.
  • Skills are like apps those employees use. Salesforce, Google Analytics, a writing style guide, a competitive analysis framework. Skills are horizontal — multiple people use the same skill in different contexts.

An agent IS someone. A skill is something someone USES.

Agents in Detail

An agent is a full decision-making entity. In Claude Code, agents are markdown files (like cmo.md) stored in .claude/agents/. Each file defines:

  • Identity — Who is this agent? What's their role and expertise?
  • Domain knowledge — What frameworks, best practices, and mental models do they bring?
  • Output format — How do they structure their deliverables?
  • Tools — What capabilities do they have access to?

When you invoke an agent, it takes over the conversation. It has its own system prompt, its own expertise, and its own way of approaching problems. It makes decisions. It asks clarifying questions. It structures its work.

Example: A "VP of Demand Gen" agent might know the SiriusDecisions demand waterfall, understand ABM tier strategies, and automatically structure output into campaigns, channels, budget allocation, and pipeline projections. You don't need to specify any of that — the agent brings it.

Skills in Detail

A skill is a modular package of procedural knowledge. Think of it as a playbook or a how-to guide that any agent (or Claude itself) can follow. Skills are:

  • Declarative — They describe how to do something, not who does it
  • Portable — The same skill works across Claude Code, Cowork, Cursor, Windsurf, and other AI tools
  • Progressive — They load metadata first, then instructions, then resources (only what's needed)
  • Passive — They don't activate on their own. They're invoked when needed.

Example: A "UI/UX Design" skill might contain 50 design styles, font pairings, color palette rules, accessibility guidelines, and component patterns. Any agent — or Claude with no agent — can use that skill to produce professional design work.

The Head-to-Head

Dimension Agents Skills
Orientation Vertical (domain-specific) Horizontal (cross-domain)
Autonomy High — makes decisions Low — passive until invoked
Context Loading Always loaded (full system prompt) Progressively loaded (on demand)
Portability Agent-product specific Cross-platform compatible
Scope Orchestrates entire workflows Packages specific knowledge
Identity Has a persona and role No identity — pure capability
Output Ownership Owns the deliverable end-to-end Enhances someone else's deliverable
Analogy Department employee Cross-functional app

The Competence Gap

Here's why this distinction matters in practice. Consider this equation:

The Key Equation

Raw Capability + Procedural Knowledge = Competence

Claude has massive raw capability — it can write, analyze, reason, create. But capability is not competence. A medical school graduate has the capability to practice medicine, but they're not competent until they've done residency. Skills are the residency. They fill the gap between "can do" and "does well."

Without skills, you get generic output. With the right skill loaded, you get output that follows best practices, uses the right frameworks, and meets professional standards. The difference is night and day.

Where Each Lives

Agents

  • Claude Code: .claude/agents/ directory. Full support. You can have dozens of specialized agents and invoke them by name.
  • Claude Cowork: No custom agents. Cowork creates its own sub-agents internally for task decomposition, but you can't define or customize them.
  • Claude Chat: No custom agents. You can simulate agent behavior with detailed system prompts in Projects, but it's not the same thing.

Skills

  • Claude Code: Full support. Skills can be installed via the /install-skill command or placed in .claude/skills/.
  • Claude Cowork: Skills are accessible through the plugin/settings panel. Limited but growing library.
  • Claude Chat: Skills available through the settings panel. Primarily first-party skills from Anthropic.

Cross-Compatibility: The Portability Promise

One of the most underappreciated aspects of skills is their portability. A well-built skill works across:

  • Claude Code
  • Claude Cowork
  • Cursor (AI code editor)
  • Windsurf (AI code editor)
  • Codex CLI (OpenAI's terminal tool)
  • Any tool that supports the skill file format

This means your investment in skills isn't locked into one product. Build a skill once, use it everywhere. Agents, by contrast, are typically specific to one product's agent system.

Section 05

Plugins & Skills for GTM Operators

The skill and plugin ecosystem is expanding rapidly. Here's what's available now and where to find it.

What a Plugin Actually Is

In Claude's ecosystem, a plugin is a packaged bundle of capabilities that extends what Claude can do. This can include:

  • Skills — Procedural knowledge and best practices (design patterns, writing frameworks, analysis methods)
  • MCP Servers — Connections to external tools (CRM, email, analytics, databases)
  • Custom tools — New capabilities like web browsing, file conversion, or data processing

In Cowork, you access plugins through the desktop app's settings panel. In Code, you install them via command line or by placing files in your project directory.

GTM-Relevant Skills Available Now

Content & Writing

  • Content Strategy — Editorial calendars, content pillars, distribution planning, SEO integration
  • Copywriting Frameworks — AIDA, PAS, Before-After-Bridge, StoryBrand, and dozens more
  • Brand Voice — Consistent tone, style guides, terminology management
  • Email Marketing — Subject line optimization, sequence design, A/B testing frameworks

Research & Analysis

  • Competitive Intelligence — Competitor profiling, SWOT analysis, battlecard generation
  • Market Research — TAM/SAM/SOM analysis, customer segmentation, trend analysis
  • Win/Loss Analysis — Deal pattern recognition, objection mapping, competitive positioning

Design & Creative

  • UI/UX Design Intelligence — 50+ design styles, typography pairing, accessibility rules, responsive patterns
  • Presentation Design — Slide frameworks, data visualization, storytelling structures
  • Landing Page Optimization — Conversion patterns, hero types, CTA strategies, social proof placement

Sales Enablement

  • Battlecard Builder — Structured competitive comparison with handling strategies
  • Discovery Call Frameworks — MEDDPICC, BANT, SPIN, Challenger methodology
  • Proposal Generation — Modular proposals with pricing, ROI, and implementation plans

Where to Find Skills

Skill Sources

Anthropic's Official Directory — Growing collection of first-party and verified third-party skills. Accessible in Cowork's plugin panel and Code's /install-skill command.

GitHub — Search for "claude skills" or "claude agents." The community is building rapidly. Look for repositories with clear documentation and recent updates.

Build Your Own — A skill is just a markdown file with structured knowledge. If you have domain expertise, you can create a skill in 30 minutes. Claude Code will even help you write it.

Building a Custom Agent Team (Claude Code Only)

This is where Claude Code becomes a legitimate force multiplier. Here's the agent team structure I use for GTM work:

.claude/agents/
  Marketing/
    cmo.md                    — Master strategy, positioning, budget
    vp-demand-gen.md          — Pipeline, campaigns, ABM
    vp-content-marketing.md   — Editorial, thought leadership
    vp-product-marketing.md   — Messaging, battlecards, launches
    seo-manager.md            — Keywords, site architecture
    paid-media-manager.md     — Ad spend, channels, creative
  Sales/
    cro.md                    — Revenue strategy, forecasting
    sales-enablement.md       — Training, playbooks, tools
    competitive-intel.md      — Competitor monitoring, analysis
  RevOps/
    revops-director.md        — Process, systems, metrics
    data-analyst.md           — Pipeline analysis, dashboards

Each of these files is 100-150 lines of markdown. They define the agent's role, expertise, frameworks, and output format. When you ask Claude Code to "use the CMO agent to build a go-to-market strategy," it reads that file and becomes that specialist.

The result: instead of one generalist AI, you have a bench of 60+ specialists, each with deep domain knowledge, ready to work on demand. No hiring. No management. No salary.

Section 06

MCPs — Connecting Claude to Your GTM Stack

MCP (Model Context Protocol) is how Claude talks to your existing tools. Think of it as USB ports for AI — a standard way to plug in any data source or service.

What MCP Actually Does

Without MCP, Claude is smart but isolated. It can think, write, and reason — but it can't see your data. With MCP, Claude can:

  • Pull pipeline data from your CRM in real time
  • Read and create pages in your Notion workspace
  • Query your Google Analytics for traffic and conversion data
  • Search and respond to emails in Gmail
  • Create and manage events in Google Calendar
  • Read and post messages in Slack channels
  • Create issues and pull requests in GitHub
  • Query databases for custom reporting

The key word is live. Claude isn't working from a data export you uploaded three days ago. It's querying your actual systems in real time.

MCP Availability by Product

MCP Type Chat Cowork Code
Remote MCPs Yes Yes Yes
Local MCPs No Yes Yes
Custom MCPs No Limited Yes
Multiple MCPs Yes (limited) Yes Yes (unlimited)

Remote MCPs are hosted by third parties and available across all Claude products. Think of these as cloud connectors. Local MCPs run on your machine and are available in Cowork and Code. Custom MCPs are servers you build yourself for proprietary data sources.

The GTM MCP Ecosystem

Here are the MCP connections most valuable for GTM operators:

HubSpot
CRM, deals, contacts, pipeline
Salesforce
CRM, opportunities, reports
Notion
Docs, databases, wikis
Google Analytics
Traffic, conversions, reports
Gmail
Email search, drafts, threads
Google Calendar
Events, scheduling, free time
Slack
Messages, channels, threads
GitHub
Issues, PRs, code, repos
Linear
Project tracking, issues
Canva
Design, templates, assets
Vercel
Deploy, domains, hosting
PostgreSQL
Direct database queries

Setting Up MCPs

In Claude Code

MCP servers are configured in your project's .claude/settings.json or ~/.claude/settings.json (global). Here's a simplified example:

{
  "mcpServers": {
    "notion": {
      "command": "npx",
      "args": ["-y", "@notionhq/notion-mcp-server"],
      "env": {
        "NOTION_API_KEY": "your-key-here"
      }
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "your-token-here"
      }
    }
  }
}

Once configured, Claude can directly interact with those tools. You don't need to do anything special — just ask Claude to "check my Notion for the latest meeting notes" or "pull last month's deals from HubSpot."

In Claude Cowork

MCPs are configured through the Claude Desktop app's settings panel. Navigate to Settings, find the MCP section, and add your connections. The desktop app handles the server management for you.

In Claude Chat

Remote MCPs are available through the integrations panel. These are managed by Anthropic and don't require local setup. The selection is more limited but growing.

Security Note

MCP connections give Claude access to your real data and real systems. Always review what permissions an MCP server requests. Use read-only access when you just need data. Store API keys securely (environment variables, not hardcoded). Start with one or two connections, then expand as you build trust.

The Power of Combined MCPs

The real magic happens when you combine multiple MCP connections. Here's a real workflow:

  1. "Pull all deals from HubSpot that closed-lost in Q4" (HubSpot MCP)
  2. "Cross-reference with the competitive intel in our Notion database" (Notion MCP)
  3. "Create a win/loss report with patterns and recommendations"
  4. "Email the report to the sales team" (Gmail MCP)
  5. "Add a follow-up task to my calendar for next week" (Calendar MCP)

One prompt. Five tools. A deliverable that would have taken you half a day.

Section 07

Memory Systems — How Each Product Remembers

Memory is the single biggest differentiator between casual AI use and AI that actually compounds value over time. Here's how each product handles it.

Every time you re-explain your company, your ICP, your competitive landscape, or your preferences, you're wasting tokens and time. The quality of AI output is directly proportional to the quality of context it has. Memory is how you give it that context without repeating yourself.

Chat Memory

  • Scope: Per-conversation only
  • Persistence: Gone when you close the tab (conversation history is saved, but context doesn't carry to new chats)
  • Projects: Some continuity via Projects feature (pinned instructions, attached files)
  • Workaround: Start each conversation by pasting your context, or use Projects with custom instructions
  • Rating: Basic. Functional for single tasks, frustrating for ongoing work.

Cowork Memory

  • Scope: Per-session by default
  • Persistence: Session ends when you close the tab. Files persist in the VM until reset.
  • Desktop Commander: With the Desktop Commander MCP, Cowork can read/write files on your local machine, enabling memory persistence
  • Workaround: Create a memory.md file in the VM and instruct Cowork to read it at session start
  • Rating: Moderate. Better than Chat, but requires manual setup for persistence.

Code Memory

  • Scope: Per-project, automatic
  • CLAUDE.md: Project instructions file. Always loaded at session start. You write it once, Claude reads it forever.
  • Auto-memory: .claude/memory/ — Claude automatically stores key facts and preferences here
  • Custom files: Create any file structure for memory — context/competitors.md, context/icp.md, etc.
  • Rating: Excellent. The strongest memory system of any AI tool on the market.

Why Code's Memory System Is a Game-Changer

Let me make this concrete. Here's what a CLAUDE.md file looks like for a GTM operator:

# CLAUDE.md

## Company Context
- Company: Acme Health (B2B SaaS, patient engagement platform)
- Stage: Series B, $15M ARR, 120 employees
- Primary ICP: Multi-location medical practices (10-50 locations)
- Secondary ICP: Dental groups, Veterinary chains

## Competitive Landscape
- Primary competitor: Weave (broader but shallower)
- Also competing with: Phreesia, Solutionreach, Klara, NexHealth
- Our edge: Deeper clinical integration, better multi-location support

## My Role & Preferences
- I'm the VP of Marketing. I report to the CRO.
- I prefer data-driven recommendations with clear rationale
- Deliverables should be executive-ready (no raw notes)
- Use MEDDPICC for deal qualification references
- Default output: Google Docs-compatible markdown

## Current Priorities (Q1 2026)
- Launch ABM program targeting top 500 accounts
- Rebuild website with new positioning
- Hire Content Marketing Manager
- Hit 850 MQLs/month target

Every single conversation starts with this context loaded. Claude knows who you are, what you sell, who you compete with, and what you're working on. From the first word of every session.

Compare that to Chat, where you'd need to explain all of this every time. Or to Cowork, where you'd need to manually recreate it each session.

Building Your Memory System (Claude Code)

Here's the structure I recommend for GTM operators:

your-project/
  CLAUDE.md               — Master context (always loaded)
  .claude/
    memory/               — Auto-memory (Claude writes here)
    agents/               — Your specialist agents
    settings.json         — MCP connections, preferences
  context/
    icp.md                — Detailed ICP profiles
    competitors.md        — Competitive landscape detail
    product.md            — Product features, pricing, roadmap
    brand-voice.md        — Tone, style, terminology
    metrics.md            — Current KPIs, targets, actuals

Claude can read any of these files on demand. When you ask it to "build a competitive battlecard for Weave," it reads competitors.md and product.md automatically. When you ask for a blog post, it checks brand-voice.md. The context is always there, always accurate, and always up to date (because you control the files).

Memory Maintenance Tip

Update your CLAUDE.md once a month. Update competitors.md after every competitive event (pricing change, feature launch, funding round). Update metrics.md weekly. Think of these files as your AI employee's briefing book. The more current it is, the better the output.

Section 08

When to Use What — The Decision Framework

Stop guessing. Here's a clear decision tree for choosing the right Claude product for any task.

The goal isn't to use Code for everything. Each product has a sweet spot. Here's how to think about it.

The Quick Decision Tree

Need a quick answer, brainstorm, or one-off draft?
Chat
Need a real file created (.docx, .xlsx, .pptx, .pdf)?
Cowork or Code
Need a multi-step workflow with research, analysis, and deliverables?
Cowork or Code
Need custom agents or specialized personas?
Code
Need persistent memory across sessions?
Code
Need to connect to your full tool stack (CRM, analytics, Notion)?
Code (most flexible)
Need files created but want a safe sandbox?
Cowork
Need automated/scheduled tasks that run without you?
Code
Non-technical and just getting started with AI?
Start Chat, grow to Code

The Cowork vs. Code Decision

When you've decided you need more than Chat, the question becomes: Cowork or Code? Here's the deciding factor:

The Rule of Thumb

Use Cowork when: You want a sandboxed, visual experience. You prefer watching Claude work in real time. You want file creation without giving Claude access to your full system. You're exploring a one-off task.

Use Code when: You want persistent context. You need custom agents. You want to connect to multiple tools. You're building a repeatable workflow. You want maximum power and control.

The short version: Cowork is safer and simpler. Code is more powerful and persistent. Start with Cowork if you're cautious. Graduate to Code when you're ready for the full experience.

The Progressive Adoption Path

You don't have to jump to Code immediately. The most sustainable approach is progressive adoption:

  1. Phase 1: Chat — Get comfortable with Claude's capabilities. Learn how to prompt effectively. Build intuition for what AI can and can't do well.
  2. Phase 2: Cowork — Start creating real deliverables. Learn about sub-agents, file creation, and autonomous task execution. Get comfortable watching AI work independently.
  3. Phase 3: Code — Set up your first CLAUDE.md. Install 2-3 MCP connections. Try a custom agent. Build a repeatable workflow. This is where the compounding starts.

Most people can complete this progression in a week. Some do it in a day. There's no wrong pace.

Section 09

Getting Started — Your First Week

A practical, day-by-day plan for going from "I've used ChatGPT a few times" to "I have a full AI operating system." No technical background required.

D1

Day 1: Get Comfortable with Chat

Go to claude.ai and have a real conversation. Don't test it with trivia. Give it an actual work task: "Draft 3 variations of a cold email for [your ICP]" or "Analyze this competitive landscape and identify our top 3 advantages." Push it. Ask follow-up questions. See how it handles nuance. The goal today is to internalize that Claude is genuinely useful for your real work.

D2

Day 2: Explore Chat Projects

Create a Project in Chat. Add custom instructions (your company name, ICP, competitors, what you care about). Attach a few key documents (product one-pager, competitive overview). Start a conversation inside that Project and notice how much better the output is with context. This is your first taste of what persistent context does.

D3

Day 3: First Cowork Session

Open the Claude Desktop app. Navigate to the Cowork tab. Give it a file creation task: "Create a competitive battlecard comparing us to [competitor]. Output as a Word document." Watch it work autonomously — planning, researching, writing, formatting. Download the file. This is your first experience with agentic AI that creates real deliverables.

D4

Day 4: Push Cowork Further

Try a multi-step task: "Research the top 5 patient engagement platforms, create a comparison spreadsheet (.xlsx), and write a one-page executive summary (.docx) with my recommendation." Notice how Cowork breaks this into sub-tasks, coordinates between them, and produces multiple deliverables. This is sub-agent orchestration in action.

D5

Day 5: Install Claude Code

Open Terminal (Mac: Cmd+Space, type "Terminal"). Run npm install -g @anthropic-ai/claude-code. Create a folder on your Desktop: mkdir ~/Desktop/AI-Workspace && cd ~/Desktop/AI-Workspace. Type claude. You're in. Ask it to do something simple: "Create a file called hello.md with a brief introduction to our company." See the file appear in your Finder. That's it — you're using Claude Code.

D6

Day 6: Create Your CLAUDE.md

This is the day everything changes. Ask Claude Code: "Help me create a CLAUDE.md file with my company context. My company is [name], we sell [product], our ICP is [description], our competitors are [names]." Claude will create the file. From now on, every session starts with that context loaded. Try closing and reopening Claude Code — notice it already knows who you are.

D7

Weekend: Level Up

Three missions for the weekend. First: set up 2-3 MCP connections (Notion and Google Analytics are great starting points). Second: create your first custom agent — ask Claude to "create a competitive intelligence analyst agent in .claude/agents/competitive-intel.md." Third: run a full workflow using that agent with MCP data. By Monday, you'll have a system that most knowledge workers won't have for another year.

What You'll Have After One Week

A working AI workspace with persistent memory (CLAUDE.md), at least one custom agent, connections to your key tools (MCPs), and hands-on experience with all three Claude products. You'll know exactly which product to reach for in any situation. And you'll have a foundation you can build on for months.

Section 10

Real GTM Use Cases

Concrete examples for each product. Not hypotheticals — these are tasks real GTM operators run regularly.

Claude Chat Use Cases

Chat excels when the task is quick, self-contained, and doesn't need file output.

Chat
"Draft 3 variations of cold outbound email for CFOs at mid-market healthcare companies. Our product reduces claim denials by 40%."
Output: Three complete emails with subject lines, different angles (pain-focused, outcome-focused, social proof), ready to paste into your sequencer.
Chat
"I'm presenting to the board next week. Our ARR grew 47% but net retention dropped to 108%. Help me frame this story in 3 slides."
Output: Slide-by-slide narrative with headlines, talking points, and data visualization recommendations. Copy into your deck.
Chat
"Analyze this pricing page [screenshot]. What's working, what's not, and how would you restructure it for better conversion?"
Output: Detailed UX critique with specific recommendations for anchoring, tier naming, feature emphasis, and CTA placement.
Chat
"Our competitor just raised $50M. Here's their press release. What moves should we expect in the next 6 months, and how should we respond?"
Output: Scenario analysis with likely competitive moves, defensive strategies, and proactive positioning recommendations.

Claude Cowork Use Cases

Cowork shines when you need real file output and multi-step workflows, but don't need persistent context or custom agents.

Cowork
"Build me a competitive battlecard as a Word doc comparing us to Weave. Include positioning, pricing, feature comparison, objection handling, and trap questions for discovery calls."
Output: Professional .docx file with formatted tables, comparison matrices, and sales-ready talk tracks. Downloaded to your machine.
Cowork
"Research the top 8 patient engagement platforms. Create an Excel spreadsheet with columns for company, founded, funding, pricing, key features, target market, and estimated revenue. Then write a 2-page analysis doc."
Output: .xlsx with structured data AND a .docx executive analysis. Cowork coordinates both tasks with sub-agents.
Cowork
"Create a 12-slide pitch deck in PowerPoint for our Series B fundraise. Use our brand colors. Include market size, traction metrics, competitive moat, team, and financial projections."
Output: Complete .pptx with professional formatting, charts, and speaker notes. Ready for refinement, not starting from scratch.
Cowork
"Take this 45-page PDF whitepaper and create: (1) a 2-page executive summary, (2) a LinkedIn post announcing the key findings, (3) a Twitter thread with the top 5 insights."
Output: Three separate files — summary .docx, LinkedIn post .md, Twitter thread .md. Multi-format content repurposing in one task.

Claude Code Use Cases

Code is the choice when you need agents, persistent context, tool integration, or repeatable systems.

Code
"Using the CMO agent, build a complete go-to-market strategy for our new discharge management product. Include positioning, ICP refinement, channel strategy, budget allocation, and a 90-day launch plan."
Output: 15-20 page strategy document with the depth and structure of a real CMO deliverable. Agent brings frameworks (STP, demand waterfall, channel mix models) without you specifying them.
Code
"Pull our last 6 months of Google Analytics data, identify the top 20 pages by conversion, cross-reference with our SEO keyword rankings, and build an optimization roadmap."
Output: Data-driven analysis using live analytics data (via GA MCP), with specific page-by-page recommendations, estimated traffic impact, and implementation priority. Not generic advice — YOUR data.
Code
"Set up a monthly competitive monitoring workflow. On the 1st of every month, check our 6 key competitors for pricing changes, new feature announcements, and leadership changes. Create a report and save it to our competitive-intel folder."
Output: Automated cron job that runs Claude Code monthly, executes the competitive intel agent, generates a timestamped report, and stores it in your project. Zero manual effort after setup.
Code
"Build a complete landing page for our virtual waiting room product. Use the Designer skill, our brand palette, and optimize for conversion. Include hero, features, testimonials, pricing, and CTA sections."
Output: Production-ready HTML file with responsive design, brand-consistent styling, accessible markup, and conversion-optimized layout. Viewable immediately in your browser, deployable to Vercel with one command.
Code
"Review all our closed-lost deals from Q4 in HubSpot. Identify the top 3 loss reasons, which competitors we lost to most, and create a sales enablement plan to address the gaps."
Output: CRM data analysis (via HubSpot MCP), pattern identification, and a complete enablement plan with training topics, content needs, and competitive counter-strategies. Live data, not guesses.

The Compound Effect

The individual use cases above are impressive on their own. But the real power emerges when you combine them into a system:

  1. Your CLAUDE.md holds persistent context about your company, market, and priorities
  2. Your agents bring specialized expertise for every function (marketing, sales, analytics, content)
  3. Your MCP connections provide live data from your actual tools
  4. Your skills ensure professional-quality output (design, writing, analysis)
  5. Your automated workflows handle recurring tasks without intervention

The result is an AI operating system that knows your business, has access to your data, employs specialized expertise, and improves with every session. That's not a tool. That's a competitive advantage.

The Bottom Line

Most GTM leaders are using Chat — the least powerful option — for 100% of their AI work. Cowork and Code aren't harder to use. They're just different. And the delta between a Chat-only workflow and a Code-powered system is the difference between "AI is a nice productivity boost" and "AI fundamentally changed how I operate."

Ready to Level Up Your AI Game?

Join thousands of GTM operators learning to build AI-powered revenue systems. New frameworks, use cases, and agent architectures every week.