It's Monday morning in commercial at an AI-drug-discovery tooling startup. A target account you've worked for nine months put out a press release on Friday: positive Phase 2 readout in a second indication, and a new VP of Translational Sciences started three weeks ago. Your old Head of Research contact just moved to a competitor. There's a conference (SCOPE) in five weeks where four of your top-20 accounts are exhibiting. Your inbox has 38 unread threads, two of them technical replies from CSOs that need a scientifically credible answer today, not Thursday.

A generic sales tool sees "biotech, 120 employees, Series C." It does not know what a Phase 2 readout in a second indication means for your deal, that the new VP is the actual economic buyer now, that your warm path just walked out the door, or that the conference is a quarter's worth of pipeline you're about to under-prep for.

Claude Code, pointed at the right context, sees all of it, and can draft the brief, the re-introduction to the new VP, the two technical replies, and the conference target list before your coffee is cold. The thing that makes it good at engineering is long-running, tool-using, context-aware work with a human in the loop. That happens to be the thing life-science GTM has always been missing.

This guide is how to get there. It's long on purpose. You don't have to adopt all of it at once. The five-levels section is built so you can start with one safe folder this afternoon and grow into a full system over a quarter.

A note on scope. This is a guide to Claude Code as a GTM operating surface for teams selling into life sciences: vendors, CROs and CDMOs, data and SaaS companies, agencies, and scientific founders. It is not about HCP targeting, MLR review, Sunshine Act, or field-rep CRM. If you run an internal pharma commercial team, this is the wrong guide; Veeva and IQVIA own that world. Everyone else who has to sell to the PhDs, read on.

Part 1: Understanding Claude Code

What Claude Code actually is

Claude Code is an agent that lives in your terminal, your browser (claude.ai/code), your IDE, and your phone. You give it a goal in plain English. It reads files, calls tools, runs multi-step work, shows you what it did, and waits for your judgment before anything irreversible happens. It was built for software, but nothing about that loop is software-specific. Reading sources, synthesizing across them, drafting an artifact, revising against feedback, and remembering what worked is knowledge work, and it's most of life-science GTM.

What it can do for a commercial team:

• Read and write real files such as your account notes, ICP definition, persona docs, voice guide, and last quarter's winning emails, and treat them as durable memory instead of chat history that disappears.
• Connect to your actual tools through MCP (Model Context Protocol): Gmail, Calendar, Granola or Fireflies transcripts, Slack, your CRM, and life-science data sources like ClinicalTrials.gov, PubMed, and FDA filings.
• Run long, multi-step jobs such as "research these 20 accounts, draft a brief for each, flag the three with active buying signals," without you babysitting every step.
• Remember your standards by reading context files automatically, so it writes like your best rep on their best day, every time.
• Get packaged into repeatable capabilities (skills, slash commands, subagents), so a workflow you perfect once becomes a one-word command your whole team can run.
• Work where you are. Kick off a conference-prep run from your phone in the back of an Uber, then review the output on your laptop.

Why a "coding tool" is the right tool here

There's a reason the best knowledge-work agents came out of coding. Engineering forced three things that generic chatbots never had to solve, and all three matter for selling into science.

1. File-native memory. Code lives in files, so agents that edit code had to learn to read, hold, and update a large body of structured context. Your account intelligence, ICP, and reply corpus are that body of context. A chat window forgets; a file-native agent builds on what came before.
2. Real tool use with a safety gate. Coding agents had to run commands that could break things, so they learned to propose, show a diff, and wait for approval. That same discipline is what keeps an outbound agent from sending an unapproved email to a CSO. The gate is the feature, not a limitation.
3. Long-horizon execution. Shipping a feature takes dozens of steps. So does prepping a conference, working a 14-month multi-stakeholder deal, or running a reply-classification pass across an inbox. The agent that can stay coherent across a long task is the one that can actually do GTM work, not just answer a question.

The features that do the work

Five capabilities do most of the heavy lifting. Learn these and the rest is detail.

1. CLAUDE.md and context files (the memory). A CLAUDE.md file in a folder is read automatically every time Claude Code works there. It holds the things you'd otherwise re-explain in every prompt: who you sell to, what you sell, how you talk, what's true and what's banned. You can nest them, with a top-level CLAUDE.md for the whole GTM workspace and a per-account CLAUDE.md inside each account folder. This is the highest-leverage setup step, because it's what makes the output sound like you and stay scientifically honest.

2. MCP servers (the connections). MCP is how Claude Code reaches outside its own sandbox: your email, calendar, meeting transcripts, CRM, and life-science data. Each connected source makes every downstream task sharper. An account brief that reads your last three Granola calls and the account's latest ClinicalTrials.gov filings is a different artifact than one written from a company website. Treat connecting these sources as the real setup work, not an afterthought.

3. Skills (packaged expertise). A skill is a reusable capability: a folder with instructions, and optionally scripts and reference docs, that Claude loads only when it's relevant. "Write a cold email to a VP of Clinical Development" is a skill. It carries the framework, the do's and don'ts, the scientific-accuracy checks, and the voice rules, so the output is consistent no matter who runs it or when. Skills are how a workflow stops depending on the one rep who knows how to prompt well.

4. Subagents (parallel specialists). Subagents are separate Claude instances with their own context and their own job that the main agent can dispatch and run in parallel. For GTM this is the difference between "research 20 accounts" taking an hour in sequence and taking minutes: one researcher per account, each returning a structured brief, the main agent synthesizing the portfolio view. They also separate concerns. A "scientific-accuracy reviewer" subagent can have one job, which is to catch a fabricated trial phase or a misstated mechanism of action.

5. Slash commands and hooks (the automation surface). A slash command is a prompt you've saved and named, like /account-brief, /morning, or /conference-prep. A hook runs automatically on an event, for example logging every finished task, or running a compliance check before any send. Together they turn a proven workflow into a button your whole team presses, and they let you enforce a rule ("never send without approval") at the system level instead of hoping everyone remembers.

Supporting players worth knowing: plan mode (Claude proposes a plan and waits for your go-ahead before doing anything, which you should use for any multi-step or irreversible job), plugins and marketplaces (install a packaged bundle of skills, commands, and config in one step), and Claude Code on the web and mobile (start and review work from a browser or phone, not just the terminal).

What Claude Code isn't

• It is not an autonomous SDR that sends on its own. It drafts, proposes, and queues. A human approves anything that leaves your domain. In a market that got burned by autonomous-send tools, that's the right default.
• It is not a CRM. It plugs into the CRM you already have. It won't replace Salesforce, HubSpot, Attio, or Affinity; it makes them more useful by reading from and writing to them.
• It is not a source of scientific truth. It can read ClinicalTrials.gov, PubMed, and FDA sources and cite them, but a model left to free-associate will invent a plausible-sounding trial phase or mechanism. The back half of this guide is about engineering that risk out.
• It is not a "do my whole job" button. It's a power tool. Like any power tool, the operator's judgment is what makes it safe and valuable.

When to delegate, when to collaborate

Good candidates for Claude Code work share three traits.

• The inputs are reachable. The information lives in files, email, transcripts, a CRM, or a connected data source, not only in your head or a colleague's memory.
• The output is a reviewable artifact. A brief, a draft sequence, a target list, a classified inbox: something you can read and judge in minutes, not a one-off action you can't inspect.
• The standard is expressible. You can say what "good" looks like, or point to an example, so the agent has a target and you have a basis for review.

A rough rule:

• Collaborate (you in the loop, turn by turn) for anything net-new, judgment-heavy, or high-stakes: the messaging for your most important account, the positioning for a new product line, the first version of a workflow.
• Delegate (set it running, review the result) for anything you've done enough times to know exactly what good looks like: the weekly account-signal roundup, the inbox triage, the conference target list from attendee data.

Most teams over-collaborate at first, re-prompting things that should be one command, then over-delegate later, trusting output they should still be reading. The skill is moving each task to the right mode as your confidence earns it.

The life-science GTM loop

Every durable use of Claude Code in commercial work runs the same five-step cycle. The point of this guide is to get you running it deliberately.

Connect, contextualize, delegate or collaborate, review, compound.

1. Connect your tools and data through MCP so the agent works from reality, not guesses.
2. Contextualize with CLAUDE.md and context files so it knows your ICP, your science, your voice, and your bans.
3. Delegate or collaborate on the actual work, in the right mode for the task.
4. Review every time, with scientific accuracy and approval gates as non-negotiable checkpoints.
5. Compound by feeding what worked back into context files and skills, so next week starts ahead of this week.

The teams that win with this don't have better prompts. They have a tighter loop.

Part 2: Setup

Connect your systems

The biggest determinant of output quality is what the agent can see. A connected Claude Code that reads your real calls and your real pipeline is a much better assistant than a blank one. Connect these in roughly this order:

Two principles:

• Connect read-only first, write second. Let the agent read your CRM and inbox for a week before you let it write anything back. You'll learn its judgment cheaply.
• A bundle beats a pile of point connections. Wiring several MCP servers and writing your own scientific-accuracy checks by hand is real work. A marketplace plugin can install a set of connections and skills at once, which is worth doing once your workflow stabilizes.

How Claude Code reaches your tools

There are a handful of access paths, and you'll use several:

1. MCP servers for live tools and data (above).
2. Files in your workspace: notes, exports, prior artifacts, context.
3. The web for public pages such as a company site, a press release, or a conference exhibitor list.
4. Slash commands for your saved, named workflows.
5. Skills for packaged expertise it loads when relevant.
6. Plugins for bundles of all of the above, installed in one step.

Build your GTM workspace

Give Claude Code a deliberate folder structure. This is the memory architecture. The agent navigates it the way a sharp new hire navigates a well-organized shared drive.

gtm-workspace/
├── CLAUDE.md                  # who we are, who we sell to, how we talk, what's banned
├── context/
│   ├── icp.md                 # ideal customer profile, sub-segments, disqualifiers
│   ├── personas.md            # CSO, VP Clinical Dev, BD lead, academic PI: pains, language
│   ├── product.md             # what we sell, proof points, case studies, claims we CAN make
│   ├── voice.md               # tone, structure, examples of great and bad copy
│   └── competitors.md         # who we run into, how we're different
├── accounts/
│   ├── _template.md
│   ├── acme-bio/
│   │   ├── CLAUDE.md          # account-specific context
│   │   ├── brief.md           # living account intelligence dossier
│   │   ├── stakeholders.md    # the buying committee, every touch, what's stale
│   │   └── calls/             # transcript exports / links
│   └── ...
├── campaigns/
│   ├── q3-scope-conference/
│   └── series-c-signal-play/
├── messaging/
│   ├── winners/               # emails & posts that got replies
│   └── drafts/
├── conferences/
│   └── scope-2026/
└── commands/                  # saved slash commands (or .claude/commands/)

You don't need all of this on day one. Start with CLAUDE.md, context/, and one account folder. The structure earns its place as you grow.

What to put in your context files

This is where output quality is won or lost. Be specific. Vagueness in, vagueness out.

CLAUDE.md (the top-level brain):

• One paragraph on what you sell and to whom, in the buyer's vocabulary, not yours.
• The non-negotiable rules. Never invent a clinical trial, phase, mechanism of action, publication, or metric. Cite a source for every scientific claim. Never draft a send that goes out without my approval. Match the voice in context/voice.md.
• Where to find things. "Account intelligence lives in accounts/<name>/brief.md. Winning copy lives in messaging/winners/."

context/icp.md:

• Your real ICP and sub-segments (for example, "clinical-stage biotech, Series B to C, oncology or immunology, lead asset in Phase 1 to 2") and your hard disqualifiers. The sharper this is, the less time you waste on bad-fit accounts.

context/personas.md:

• Per persona: their actual job pressure, the language they use, what makes them trust a vendor, and what makes them delete your email. A CSO and a VP of Clinical Development are not the same buyer, and the file should make that obvious.

context/voice.md:

• Two or three examples of copy you're proud of and one or two you'd never send, with a sentence on why for each. Examples teach voice far better than adjectives.

context/product.md:

• The claims you're allowed to make, with their proof. This is your fabrication firewall. If a proof point isn't in this file or a cited source, the agent shouldn't assert it.

The discipline: anything you'd correct twice belongs in a context file. Every correction you bank is a correction you never make again.

Part 3: The five levels of Claude Code use

You grow into Claude Code in stages. Each level has a mental model, a default mode, the best first tasks, a prompt pattern, a review habit, and a signal that you're ready for the next level. Each level builds the muscle the next one needs.

Level 1: One-off knowledge work

Mental model: A sharp, fast analyst who's read your context files and is sitting next to you. Mode: Collaborate. Best first tasks:

• Draft a single account brief from a company URL and a recent press release.
• Rewrite a cold email into your voice.
• Summarize a Granola call into next steps and open questions.

Prompt pattern:

Read context/icp.md, context/personas.md, and context/voice.md.
Then draft a one-page account brief for [Company] using their website
[URL] and this press release [URL/paste].
Cover: pipeline and lead asset, recent scientific/clinical news, likely
buying committee, why we're relevant, and the single sharpest reason to
reach out now. Cite a source for every scientific claim. Flag anything
you're unsure about rather than guessing.

Review habit: Read every line. You're learning its defaults and it's learning your corrections. Correct in the chat and bank the durable corrections into your context files. Move to Level 2 when: you find yourself pasting in sources you wish it could fetch itself.

Level 2: Multi-source workflows

Mental model: An analyst who can now reach your tools, not just your pastes. Mode: Collaborate, loosening toward hybrid. Best first tasks:

• "Brief me on my meetings this week" (Calendar, CRM, last call transcripts).
• "What's the latest on Acme Bio?" (their site, ClinicalTrials.gov, your email history, last Granola call).
• "Draft replies to the three technical threads in my inbox that need answers."

Prompt pattern:

Look at my calendar for this week. For each external meeting, pull the
account from the CRM, read our last two email threads and the most recent
call transcript, check ClinicalTrials.gov for any status changes on their
lead asset, and give me a half-page prep: where the deal stands, what
changed since we last talked, who's in the room, and my one objective for
the call. Cite sources for clinical claims.

Review habit: Spot-check the connected data. Did it pull the right account, the right trial? Connection errors are the new typos. Move to Level 3 when: you've run the same multi-source task three weeks running and you're tired of re-typing the prompt.

Level 3: Recurring workflows

Mental model: A junior teammate with a standing set of weekly responsibilities. Mode: Hybrid. It runs, you review. The move: Turn your best Level 2 prompts into slash commands. Save /morning (today's meetings, overnight account signals, inbox triage), /account-brief [name], and /weekly-signals. Now the workflow is a word, not a paragraph, and anyone on the team can run it identically. Best first tasks:

• /morning as your daily standup.
• A weekly signal roundup across your top accounts (funding, trial readouts, exec moves, new publications).
• A standing inbox-triage pass that sorts, drafts, and queues.

Prompt pattern (saved as /weekly-signals):

For every account in accounts/, check for new signals since last Monday:
funding rounds, clinical trial status changes, executive moves,
new publications, and press releases. Rank by deal relevance. For the
top 5, draft a one-line "why now" and a suggested next touch. Output a
single digest I can skim in three minutes. Cite every signal's source.

Review habit: Trust the routine, verify the surprises. When a signal looks deal-changing, click through to the source before acting. Move to Level 4 when: you want a workflow to enforce your framework, including voice rules, accuracy checks, and persona-specific structure, not just your prompt.

Level 4: Custom tools

Mental model: You're no longer just using the assistant. You're teaching it your trade. Mode: Hybrid. The move: Build skills and subagents.

• A draft-outreach-vp-clinical-dev skill that encodes how you write to that persona (structure, proof requirements, banned claims, tone), so every rep's draft to that buyer is consistently good.
• A scientific-accuracy-reviewer subagent whose only job is to read a draft and flag any clinical claim that isn't cited or is overstated. Run it on everything before it reaches a human reviewer.
• A score-account-fit skill that grades a company against icp.md and explains the score.

Best first tasks:

• Convert your single best email framework into a skill.
• Stand up the accuracy-reviewer subagent and route all messaging through it.
• Build a conference-prep skill that takes an exhibitor or attendee list and produces a ranked target list and a per-target opener.

Review habit: Review the skill, not just its output. When the skill is wrong, fix the skill. That's a fix that carries across every future run. Move to Level 5 when: you have several skills and commands and you want them to share one memory and reinforce each other.

Level 5: A compounding GTM system

Mental model: Not a tool you use, a system that gets smarter every week you run it. Mode: Hybrid, with delegation expanding as trust is earned.

At this level the pieces connect. Your skills read and write a shared set of context: your ICP, personas, account intelligence, and a reply corpus that records which messages actually got responses. Outcomes feed back. A reply that lands updates the messaging. A deal that closes sharpens the ICP. An exec who churns gets tracked to their new company. Hooks enforce your rules at the system level so nothing irreversible escapes the gate.

The four compounding habits:

1. Bank every correction. A correction made once in chat is help. A correction written into a context file or skill is leverage. Do the second one.
2. Promote winners. When an email gets a reply or a brief nails a meeting, move it to messaging/winners/ and point the relevant skill at it.
3. Track people, not just companies. Biotech exec churn is constant. Keep a record that follows the human, so the Head of Clinical you sold at Company X is your warm intro at Company Y next year.
4. Close the loop on outcomes. Feed replies, edits, and won/lost back into the system on a cadence. The context that ingests outcomes is the one competitors can't copy, because it's your own year of accumulated commercial reality.

You can hand-roll Level 5 in folders. A dedicated GTM platform can get you there faster, with a versioned, evidence-graded record, governed approvals, and the integration depth that makes the loop real instead of aspirational. Either path runs the same loop.

Part 4: The workflow library

Sixteen production-ready workflows, each in the same shape: Best for (the job to be done), Inputs, Output, First prompt (copyable), Review step, and How to compound. Use what fits.

1. The 90-second account brief

Best for: Walking into any meeting or first touch knowing the science, the pipeline, and the angle. Inputs: Company URL, CRM record, ClinicalTrials.gov/PubMed, last call transcript. Output: A one-page dossier in accounts/<name>/brief.md. First prompt:

Build an account brief for [Company]. Cover: lead asset(s), indication,
modality, trial stage and any recent status changes; recent funding;
likely buying committee with names where findable; our relevance in one
sentence; and the single sharpest "why now." Read our CRM record and last
call first. Cite every clinical/scientific claim. Flag unknowns explicitly.

Review: Verify the trial stage and lead asset against the cited source. These are the facts a buyer will catch. Compound: Save as /account-brief. Let it append to a living brief.md so each run builds on the last instead of starting over.

2. Pre-conference target list

Best for: Turning a 600-name exhibitor or attendee list into a ranked 25-account hit list before BIO, JPM, SCOPE, or AACR. Inputs: Exhibitor or attendee list (paste/CSV), your ICP, CRM. Output: Ranked target list with per-account rationale and an opener. First prompt:

Here's the [Conference] attendee/exhibitor list [paste/file]. Score each
org against context/icp.md. Cross-reference our CRM for existing
relationships. Return the top 25 ranked by fit x signal, each with: why
they fit, current relationship status, and a one-line meeting-request
opener tailored to their pipeline.

Review: Confirm the top 10's fit logic and that "existing relationship" calls are right. Compound: Build a conference-prep skill so every event runs identically. Feed booked-meeting outcomes back to sharpen the scoring.

3. Scientifically credible cold email

Best for: Outreach that reads like a peer wrote it, not a spam cannon. Inputs: Account brief, persona doc, product/proof file, voice guide. Output: A 3-step sequence draft, queued for review. First prompt:

Draft a cold email to [Name], [Title] at [Company]. Use accounts/<name>/
brief.md, context/personas.md, context/product.md, and context/voice.md.
Lead with something true and specific about their science. Make only
claims supported by context/product.md or a cited source. No fluff, no
fake familiarity. Then write two short follow-ups. Show your sources.

Review: Check every assertion against product.md or a citation. Kill anything unsupported. Compound: When one lands, move it to messaging/winners/ and point the persona skill at it.

4. The morning standup

Best for: Starting the day knowing exactly what changed and what needs you. Inputs: Calendar, CRM, account signals, inbox. Output: A three-minute digest. First prompt:

Give me my morning brief: today's external meetings with a one-line prep
each; any overnight signals on my top-20 accounts (funding, trial news,
exec moves, publications); and my inbox sorted into "needs a reply today,"
"FYI," and "can wait." Cite signal sources.

Review: Skim, then click through deal-changing signals. Compound: Save as /morning. Run it as a daily habit.

5. Technical reply drafting

Best for: Answering a CSO's technical question fast without sacrificing credibility. Inputs: The email thread, product/proof file, relevant sources. Output: A drafted reply, queued, never auto-sent. First prompt:

Read this thread [paste/link]. The buyer asked a technical question.
Draft a reply that answers it precisely and credibly using only what we
can support (context/product.md and cited sources). If we genuinely can't
answer something, say so and propose how we'll get them an answer. Match
context/voice.md. Do not send. Queue for my approval.

Review: This one always gets human eyes. Scientific overreach here costs deals. Compound: Add recurring question types to a reply-templates skill. Track which answers advance deals.

6. Inbox triage queue

Best for: Inbox zero without missing the thread that matters. Inputs: Email (MCP), CRM. Output: A sorted, summarized queue with drafted replies where appropriate. First prompt:

Triage my unread email. Group into: high-value account replies (draft a
response for each, queued), internal/FYI (one-line summary), and noise
(list, no action). For account replies, pull the CRM context so the draft
is informed. Nothing sends without my approval.

Review: Approve or edit drafts. Trust the noise bucket after a week of spot-checks. Compound: A hook that logs which drafts you heavily edited tells you where the voice guide needs work.

7. Multi-stakeholder deal tracker

Best for: 12 to 24 month cycles with 5 to 9 person buying committees, where the risk is a stakeholder going cold unnoticed. Inputs: CRM, email history, call transcripts, stakeholders.md. Output: A per-account committee map with last-touch and staleness flags. First prompt:

For [Account], map the buying committee: every stakeholder, their role in
the decision, our last touch with each (date and channel), and what's gone
stale. Flag anyone we haven't engaged in 30+ days and draft a re-engage
touch tailored to each. Update accounts/<name>/stakeholders.md.

Review: Confirm the committee map matches reality. You know things the CRM doesn't. Compound: Run weekly. The staleness flags become a standing prompt to act.

8. Signal-triggered play

Best for: Reacting to a trial readout, funding round, or exec hire within hours, not weeks. Inputs: Signal source (web / your data sources), account brief, persona doc. Output: A drafted, signal-specific touch, queued. First prompt:

[Company] just [signal: e.g., announced positive Phase 2 / raised Series C
/ hired a new VP Clinical Dev]. Given accounts/<name>/brief.md and
context/personas.md, draft outreach that references this credibly and
connects it to why we're relevant now. Keep it short and specific. Cite
the signal source. Queue for approval.

Review: Verify the signal is real and recent before anything goes out. Compound: Wire it to your signal feed so the draft is waiting when the signal fires.

9. Post-call follow-up

Best for: Sending the follow-up that proves you listened, within the hour. Inputs: Call transcript (Granola/Fireflies), CRM. Output: A follow-up email, CRM notes, and next steps. First prompt:

Read the transcript of my call with [Account] [link]. Draft a follow-up
that references the specific things they raised, answers any open
questions we can support, and proposes a clear next step. Also write the
CRM update: summary, stakeholders present, objections, next action and date.
Queue the email; write the CRM note directly.

Review: Skim the draft. Confirm next-step framing. Compound: Save as /follow-up. Let CRM hygiene become automatic.

10. Scientific content engine

Best for: LinkedIn posts and newsletter sections that earn credibility with technical buyers. Inputs: A recent paper, readout, or trend, voice guide, product context. Output: A drafted post or newsletter section with real citations. First prompt:

Draft a LinkedIn post reacting to [paper/readout/trend, with link]. Make
it genuinely insightful to a CSO or VP of Clinical Dev, with no platitudes.
Cite the actual source. Tie it loosely to our POV from context/product.md
without being salesy. Match context/voice.md. Give me two angles.

Review: Verify the citation and that the science is stated correctly. Compound: Keep a content/winners/ folder. Teach a draft-post skill from what performs.

11. Account-fit scoring

Best for: Spending your week on the 20 accounts worth it, not the 200 that aren't. Inputs: A company list, icp.md. Output: Scored, sorted list with rationale. First prompt:

Score each company in [list] against context/icp.md. For each: a fit score
0 to 100, the two strongest fit signals, the biggest disqualifier if any,
and a one-line verdict (pursue / nurture / pass). Sort by score. Be honest
about poor fits. A confident "pass" is as valuable as a "pursue."

Review: Sanity-check the top and bottom. Recalibrate icp.md if scores feel off. Compound: A score-account-fit skill. Feed closed-won and closed-lost back to tune the criteria.

12. Warm-path discovery

Best for: Finding the relationship route in, because cold rarely wins in life sciences. Inputs: Target account, your network/CRM, public sources. Output: Ranked paths in (advisors, mutual investors, prior colleagues, co-authors, conference overlap). First prompt:

For [target account], find warm paths in. Look for: shared investors,
scientific advisors or board members we can reach, people who worked at
companies we know, co-authors on relevant papers, and conference overlap.
Rank by reachability and strength. For the top 3, suggest exactly how to
ask for the intro.

Review: Confirm the connections are real and current. Compound: Maintain a people graph that follows execs across companies. Warm paths regenerate as people move.

13. Competitive displacement brief

Best for: Walking into a deal where an incumbent is entrenched. Inputs: competitors.md, account brief, public sources. Output: A displacement angle and objection-handling sheet. First prompt:

[Account] likely uses [competitor]. Using context/competitors.md and
their public footprint, build me: where the incumbent is probably weak
for this account specifically, our two strongest differentiators that map
to their situation, and the three objections they'll raise with credible
responses. No trash-talk, substance only.

Review: Pressure-test the differentiators against what you actually deliver. Compound: Update competitors.md with every real objection you hear in the field.

14. Territory and book planning

Best for: Quarterly planning that's grounded in signal, not gut. Inputs: Account list, signals, CRM, ICP. Output: A ranked quarter plan with focus accounts and rationale. First prompt:

Build my Q[X] plan. From my account list, rank accounts by fit x active
signal x deal stage. Identify the 10 I should focus on, why each, and the
single highest-leverage action for each this quarter. Flag accounts to
deprioritize and say why. Output a one-page plan.

Review: Apply your judgment on the 10. The agent ranks, you decide. Compound: Re-run monthly. The plan becomes a living document, not a quarterly ritual.

15. Shared team review queue

Best for: A manager reviewing the team's outbound for quality and accuracy before it ships. Inputs: Drafts folder, voice guide, accuracy rules. Output: A reviewed queue with flags and suggested edits. First prompt:

Review every draft in messaging/drafts/. For each, run the
scientific-accuracy check (flag any uncited or overstated clinical claim),
check it against context/voice.md, and rate it ready / needs-edit /
rework. For needs-edit, suggest the specific fix. Output a review summary
ranked worst-first.

Review: Spot-check the "ready" pile. Trust but verify the flags. Compound: Run it as a hook on every new draft so nothing reaches a human reviewer unchecked.

16. The compounding context update

Best for: Making sure the system actually gets smarter, not just busier. Inputs: The week's replies, edits, outcomes, new account learnings. Output: Proposed updates to context files, queued for approval. First prompt:

Review this week's activity: replies received, drafts I edited heavily,
deals that moved or died, and anything new I learned about accounts.
Propose updates to my context files: ICP refinements, new persona
language, winning messages to promote, account intelligence to record,
and exec moves to track. Show each proposed change with its evidence;
I'll approve before anything is written.

Review: Approve the changes that match your read. Reject the rest. Compound: This is the compounding. Run it every Friday. It's the difference between a tool and a system.

Part 5: Operating Claude Code well

How to steer it

• Give it the standard, not just the task. "Draft an email" gets you generic. "Draft an email that opens with a true, specific observation about their Phase 2 program, makes only claims in product.md, and matches voice.md" gets you yours.
• Point at examples. "Like the ones in messaging/winners/" teaches more in five words than a paragraph of instructions.
• Use plan mode for anything multi-step or irreversible. Let it propose the plan, then approve before it acts.
• Let it say "I don't know." Explicitly invite it to flag uncertainty instead of guessing. In a domain where a confident wrong answer about a trial phase can cost a deal, "I'm not sure" is useful.
• Iterate in the same session. It holds context across a conversation, so refine ("tighten the second paragraph, the proof point is too strong") rather than starting over.

The three review questions

Before anything ships, ask:

1. Is every scientific claim true and cited? This is the one that can actually hurt you. A fabricated trial phase, a misstated mechanism, an invented publication: these end credibility with a technical buyer permanently. Never let a clinical claim through that you haven't traced to a source.
2. Does it sound like us? Not like AI, not like a competitor, like your best rep. If it doesn't, the voice guide needs work.
3. Is this the right action? Right account, right person, right moment. The agent optimizes the artifact; you own the judgment that it's the right artifact at all.

Safety, trust, and risks

Six failure modes, and how to engineer each one out:

The human ownership standard: every artifact that leaves your company carries a human's name and judgment. The agent drafts; a person decides. In a market that watched autonomous-send tools damage sender reputations and buyer trust, disciplined human-in-the-loop is the competitive posture, not a brake on it.

From personal to team

What changes when you go from one operator to a team:

• Context files become shared assets. Your icp.md, voice.md, and persona docs are now the team's single source of truth. Version them, review changes, and treat them like the strategic documents they are.
• Skills and commands become the standard. A draft-outreach-vp-clinical-dev skill means every rep's outreach to that buyer clears the same bar. The team's floor rises to your best rep's framework.
• Approval and review move up a level. A manager-run review queue (workflow 15) and accuracy-reviewer subagents enforce quality before anything ships, at scale.
• The shared record is the team brain. Account intelligence, the reply corpus, and exec moves stay in one shared, growing record, so a rep who picks up an account inherits everyone's accumulated knowledge of it.

Three ways to spread it: one person proves a workflow and packages it as a skill or command; the team adopts the command, not the prompt, so it's identical everywhere; outcomes feed back into the shared record so the whole team's system improves, not just one individual's. This is the point where a dedicated GTM platform earns its place, since a shared record, governed approvals, audit trails, and deep integrations are a lot to hand-roll, and they're the parts that make team-scale compounding real.

Part 6: Getting started

The seven-day power-user plan

Day 1: Open one safe folder. Create gtm-workspace/, write a first-draft CLAUDE.md and context/icp.md. Run workflow 1 (account brief) on one real account. Read every line.

Day 2: Connect email and calendar. Wire the two MCP connections you'll use most. Run workflow 4 (morning standup). Notice what it gets wrong and fix your context files.

Day 3: Add voice. Write context/voice.md with two great examples and one bad one. Re-run an email draft (workflow 3). Feel the difference examples make.

Day 4: Connect a data source. Add ClinicalTrials.gov and PubMed. Re-run the account brief, now with cited science. This is the moment it starts to feel different.

Day 5: Save your first command. Turn your best prompt into /morning or /account-brief. You've gone from Level 2 to Level 3.

Day 6: Triage your inbox. Run workflow 6. Connect a transcript source and run workflow 9 (post-call follow-up). Let it handle real volume.

Day 7: Run the Friday loop. Run workflow 16 (context update). Bank the week's corrections into your context files. You've closed the loop once, and the system is now building on itself.

The 30-day extension

• Week 2: Live in Levels 2 and 3. Get /morning and /weekly-signals reliable enough to trust daily. Connect your CRM read-only.
• Week 3: Reach Level 4. Build your first skill (your best email framework) and your scientific-accuracy reviewer subagent. Route all messaging through it.
• Week 4: Start Level 5. Wire outcomes back into the shared record, promote your winners, and turn on the conference-prep and signal workflows. Bring in one teammate and share your first command.

By day 30 you're not using a tool. You're operating a system that started the month as an empty folder and now holds your ICP, your voice, your account intelligence, and a month of banked corrections. That's a head start no competitor's blank-slate chatbot can match, and it widens every week you run the loop.

The whole thing starts with the smallest possible step. Open one safe folder in Claude Code and write down who you sell to. Everything else builds from there.