TL;DR: You can run GTM in Claude Code by splitting the work into one board task per stage: ICP filters, a rules file, qualification, people search, email finding and verification, signals, and outreach. An agent runs each data task with Treg as the data layer. A person owns the rules file and approves every first line before anything is sent.
Running GTM in Claude Code sounds like one long prompt: “find me 50 good accounts and write to the buyer.” It works for a demo. It breaks the week a finder runs out of capacity or nobody can say who approved an email.
Treg’s GTM engineering playbook covers the data half: 16 chapters from ICP to rollout, built on six recorded runs, 502 logged calls and $5.03 metered. Every number here is Treg’s own recorded result, not yet reproduced independently, so test it on your rows.
The other half is coordination: an owner for the stop, a person on outreach, row counts per stage. A single session can’t hold that. This post shows how to lay the playbook out as tasks on Sharkly, with agents running each stage in Claude Code or Codex and a human at the two gates the playbook calls for.
Why GTM in Claude Code needs a board, not one session
A long agent session hides three failures that GTM work can’t afford.
- Spend without a checkpoint. Paid enrichment on rows that should have been dropped.
- Silent breakage. Treg lists what broke in its own runs without stopping them: a finder out of capacity, a buying-group endpoint out of capacity, 3 rate-limited accounts, and a parser bug that cost a $1.08 re-run.
- No owner for the send. The playbook’s outreach rule is blunt: “nothing is sent that a person has not read.”
Each is a team problem, fixed with ownership, status, and a record per stage. It’s the model from human ownership of agent work, applied to a lead list.
The stack: where each piece runs
Three layers, each with one job.
| Layer | Tool | Job |
|---|---|---|
| Execution | Claude Code or Codex | Runs the prompts, reads the rules file, writes CSVs |
| Data | Treg | Company and people search, enrichment, email finding and verification, hiring and funding signals, metered per call |
| Coordination | Sharkly | One task per stage, an Assignee per task, review states, and the run record |
Set Treg up once on the Computer where your agents run. From Treg’s setup file:
# install the CLI and the treg skill for every agent it detects
curl -fsSL https://treg.to/install.sh | sh
# browser sign-in (GitHub, Google, or an emailed code)
treg login
# headless Computer: pass a token instead of a browser
curl -fsSL https://treg.to/install.sh | sh -s -- --token "$TREG_TOKEN"
Or paste one line into the agent: set up treg - https://treg.to/llms.txt. Treg says new verified accounts get $1.00 of free credit once, calls bill at the provider’s own rate with 0% markup, and misses bill $0.00.
The GTM pipeline as board tasks
Here’s the playbook mapped to tasks. The third column is Treg’s recorded run for that stage.
| Task (playbook chapter) | Assignee | Treg’s recorded run |
|---|---|---|
| ICP as filters + free count (1-2) | Agent | CompanyEnrich, B2B+SaaS, 51-200 staff, US: 10,403; funded 2024+: 1,357 |
| Rules file (3) | Person | Human-owned gate: thresholds, drops, spend caps, who can stop the run |
| Lookalikes (4) | Agent | 71 candidates for $0.006; 8 of 71 passed the 50% ICP check |
| Qualify before paying (5) | Agent | 50 companies: 27 passed, 21 dropped; $2.33 total, $0.12 per deliverable lead |
| People by role (6) | Agent | “marketing” at 8 accounts: 20 people, $0.00 (contacts are the paid step) |
| Email waterfall + verify (7-8) | Agent | 60 people: 32 deliverable, 16 risky, 4 unknown, 8 invalid, $0.65 |
| Signals (9-10) | Agent | 27 accounts: 16 had open GTM roles in 60 days, $1.35 |
| Outreach (11-12) | Agent drafts, person approves | 4 of 19 news-based first lines rated decent or better |
| Tagging, metrics, rollout (14-16) | Agent + person | Row counts per stage, raw responses stored, spend cap per run |
How do you write an ICP an agent can filter on?
Split it into filters and checks. Filters are fields a provider can search: country, headcount, category, funding. Checks are judgement calls per row, and they run before any paid step.
The task description can carry Treg’s prompt: “Using treg, turn the ICP in icp.md into filters for two company-search providers. Use their free count endpoints only.” The acceptance criteria come from the playbook: no list is bought until two free counts roughly agree and ten sample rows look right.
Why does the rules file need a human owner?
The threshold changes the list. In Treg’s run, 27 of 48 companies passed at a 50% ICP threshold; at 60%, only 14 would have. That’s a business decision, so a person owns the task that writes it.
Put the rules where every stage reads them. A Sharkly Skill packages reusable instructions for Agent work, so the rules file becomes one Skill bound to every GTM agent instead of a paragraph pasted into nine prompts.
# gtm-rules.md (owner: the person who can stop the run)
icp_threshold: 0.50
max_spend_per_run_usd: 3.00
drop_if: [no_usable_domain, headcount_outside_51_200]
send_only: verifier_verdict == "deliverable"
stop_owner: "growth lead"
every_stage_reports: [rows_in, rows_out, metered_cost]
Stages 3 to 7: qualify before you pay
These are the cheap-first data tasks. Link them with the blocks / is blocked by relation so qualification finishes before people search starts. The ordering matters for cost: Treg qualified 50 companies for $2.33 and estimated $4.12 to enrich all 48 with a usable domain.
Two playbook rules become acceptance criteria. Lookalikes pass the same size filter and ICP check as any row. Only a verified-deliverable address enters the sequence: in Treg’s 60-person study the finder returned 60 addresses, and the verifier passed 32.
Each data task ends with an agent comment: rows in, rows out, Treg’s metered cost. With the run record, that’s the stage’s receipt.
How do you keep a person on the send button?
The outreach task is where the agent researches and drafts, then stops. In Treg’s run, only 4 of 19 news-based first lines scored decent or better. So the agent leaves the task waiting for human review, and the reviewer approves, edits, or rewrites. We covered this pattern in human-in-the-loop coding agents; it carries over to email without changes.
How Sharkly holds the playbook’s rules in place
- One task per stage gives each stage a status, an Assignee (Agent, Crew, or person), and acceptance criteria.
- Review states route attention. An Agent can leave a task waiting for a human reply or for human review, and those signals feed Inbox for the responsible person.
- The run record shows when a run started and ended, its tool calls and Runtime events, and failure details: the audit trail the rollout chapter asks for.
- Parent tasks hold the outcome. “Q4 marketing-buyer list” is the parent; the nine stages are sub-tasks.
If you’d rather not hand out nine tasks yourself, a Crew leader can split the parent and delegate the stages, as described in Sharkly Crews. Sharkly is free to start, and model usage runs on the Claude Code or Codex plan already attached to your Runtime.
Signals: no source link, no signal
The signals task needs the strictest acceptance criteria. Treg found 16 of 27 accounts with open GTM roles in the last 60 days, but 355 of 675 postings returned were already closed.
Job changes are worse. In Treg’s study of 148 people who had announced a new role, contact databases missed the new employer 68% of the time on average. A live profile read found only 49 of the 148, but it was right on 47 of them. The rule stays the playbook’s own: no source link, no outreach.
Treg’s test of hiring before a raise didn’t separate the groups, so check any timing signal on your own wins and losses before it gets a weight.
What Treg’s numbers say, and what they don’t
Treg publishes two comparisons worth reading closely on its people-search page.
- Cost per correct email: on 100 leads in October 2026, Treg reports 92 correct work emails at $0.58 per 100 correct, against 84 at $3.77 for Clay.
- Agent accuracy: on the B2B prospecting tasks of LessieAI’s 119-task People Search Bench, Treg reports Claude Code alone at 43% and Claude Code with Treg at 78.2%, with a finished list in 1.4 minutes instead of 2.8.
These are vendor-run results at list prices on the day, and Treg notes a gap of a few rows is a tie. Use them to pick what to test on 50 of your own rows.
Roll out like software
The last chapter’s rule: nothing goes autonomous until it has run in shadow. On a board that’s three phases.
- Shadow. Agents run every data task; the outreach task stays in review and nothing sends.
- Small segment. One tier, one week. Watch row counts and cost per deliverable lead against the rules file.
- Autonomy for data, never for sending. Data tasks run on a schedule through an Automation. The send stays a human decision.
To watch several runs at once, see how to monitor coding agents running in parallel.
Start with one stage
GTM in Claude Code works when each stage is small, priced, and owned, and the board says who stops the run and who approves the send. Start small: create the ICP task and the rules-file task in Sharkly, run the free count, and only then open the paid stages.
FAQ
What is GTM engineering?
Treg’s playbook defines it as designing, building, and maintaining systems that turn a go-to-market strategy into repeatable workflows: account targeting, lead enrichment, scoring, signal monitoring, research, and inbound routing, with human review before outbound messages are sent.
How much does Treg cost per lead?
In Treg’s own 23 September 2026 run, qualified leads cost $0.12 per deliverable lead, $2.33 for the whole list. Calls are metered per use, and misses bill $0.00.
Should an AI agent send cold emails without review?
No. Treg’s playbook says nothing is sent that a person has not read, and only 4 of 19 agent-researched first lines scored decent or better in its run.
Where do the rules for a GTM agent live?
In a rules file with numeric thresholds, explicit drops, a spend cap, and one named person who owns the stop. In Sharkly you can package it as a Skill so every agent reads the same rules.
Does this work with Codex instead of Claude Code?
Yes. Treg’s setup covers Claude Code, Codex, and Cursor, and a Sharkly Agent can run on either Runtime from the same board. See AI task manager: assign, track, and review agent work for the general setup.