# Gtm Engine

> Designs a complete, brand-specific GTM (go-to-market) engineering system — lead collection, enrichment, segmentation/scoring, nurturing, outbound infrastructure, outbound management, social listening, community-led growth, referral/advocacy loops, partnerships, paid/ABM, PLG motion, tool stack, budgets, and a 90-day build roadmap. Use this whenever the user wants a GTM plan, GTM engine, outbound system, sales pipeline machine, lead-gen system design, cold email infrastructure, signal-based prospecting, social listening system, referral program design, or asks "how do I get leads/meetings/pipeline for {brand}" — even if they don't say "GTM". Also use when the user injects brand details and asks for a custom go-to-market or growth-engineering plan. Do NOT use for writing a single email/post/sequence (content skills), for closing-stage sales work like proposals and objection handling (sales skills), or for pure content/SEO strategy — this skill designs the pipeline SYSTEM, not individual assets.

- Skill: `akachandan1/gtm-engine` (Agent Skill, multi-file: 7 files)
- Install (CLI): `npx skillmds@latest add akachandan1/gtm-engine`
- Raw SKILL.md: https://api.skillmd.com/api/skills/akachandan1/gtm-engine/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Product & Planning
- Author: akachandan1 (https://skillmd.com/u/akachandan1)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/akachandan1/gtm-engine

---


# GTM Engine — Custom Plan Generator

Design a revenue-generating GTM machine for a specific brand, the way a senior GTM engineer at a $100M company would: signals over static lists, systems over headcount, feedback loops over gut feel.

## What you produce

A single, complete **GTM Engine Plan** markdown document following `references/plan-template.md` exactly. It covers: ICP/TAM, signal map, lead collection, enrichment, segmentation & scoring, nurture, outbound engine (infra + cadences + example copy), outbound management, tool stack with budget, metrics/feedback loops, 90-day roadmap, and brand-specific risks.

## Reference files — read before writing

1. `references/playbook.md` — the full GTM engineering system (architecture, all 6 stages, benchmarks, automation blueprints, roadmap, anti-patterns). **Read this first, always.** It is the source of truth for methodology, numbers, and patterns; do not improvise benchmarks or deliverability rules that contradict it.
2. `references/demand-layers.md` — the modules beyond the core engine: social listening, community-led growth, referrals/advocacy/reviews (the warm layer), partnerships/nearbound, paid/ABM, PLG/PQL motion. Read whenever any module applies (its selection cheat-sheet tells you which do — for most brands at least 2 apply; an outbound-only plan is usually incomplete).
3. `references/tool-stack.md` — tool choices by budget tier. Read when writing the Tool Stack section.
4. `references/plan-template.md` — the exact output structure and quality bar. Read before drafting.
5. `references/example-plan.md` — a condensed worked example (fictional brand) showing the quality bar per section: derivation from the Step-2 forks, vertical-specific signals, consistent volume math, passing email copy. Skim before drafting your first plan in a session; match its density, not its content.
6. `references/b2c-dtc.md` — the full stage re-mapping for brands whose end buyer is a consumer (DTC/ecommerce, apps, consumer services): list growth, zero-party data, RFM/lifecycle segmentation, lifecycle flows, creator/wholesale outbound, retention ops. **Mandatory read for any B2C or hybrid brand — it replaces playbook §4–9 for the consumer side.**

## Step 1 — Gather brand inputs

Required inputs (collect from the user's message, an attached brand doc, brand memory, or the current project context):

| Input | Why it matters |
|---|---|
| What the brand sells + pricing model | Determines motion (sales-led vs PLG) and deal-size math |
| Who buys it (best guess at ICP) | Seeds the ICP hypotheses |
| Average deal size / ACV | Dictates how much touch each lead can afford |
| Geography of buyers | Compliance routing (GDPR/CASL) + tool choices |
| Current state: existing leads/list, website traffic, content, CRM, any outbound history (incl. burned domains) | The 90-day roadmap builds on assets, skips what exists |
| Monthly tooling budget (or stage: bootstrap / funded) | Selects the tool-stack tier |
| Goal: meetings/mo or pipeline target | All volume math works backward from this |
| Team: who runs this (founder solo? GTM hire?) | Ops design + SLA realism |

If the user provided a brand profile (e.g., via the `brand-context`/`brand-memory` skills or a pasted doc), extract these from it. **Ask for missing inputs only if 3+ of them are unknown and can't be reasonably inferred** — otherwise proceed and state assumptions inline in the plan. A plan with clearly-labeled assumptions beats an interrogation.

## Step 2 — Derive the shape of the motion

Before writing, decide (and let these decisions drive every section):

1. **TAM size class** → volume strategy (playbook §3.2): <2k accounts = low-volume high-touch; 2k–20k = hybrid; >20k = programmatic. This is the single most important fork — a small-TAM brand given a volume plan is malpractice.
2. **Deal-size class** → touch budget: ACV <$3k = automation-only + PLG-ish; $3k–25k = hybrid; >$25k = human-heavy fast lanes, phone layer.
3. **Buyer geography** → channel + compliance posture (EU-heavy → LinkedIn-first consideration, Cognism).
4. **Budget tier** → tool stack (tool-stack.md Tier 1/2/3).
5. **The brand's 5–8 strongest signals** from playbook §4.3, plus any vertical-specific signals you can identify for their market.
6. **Which demand-layer modules apply** — use the selection cheat-sheet at the end of demand-layers.md (e.g., PLG brand → PQL motion mandatory; DTC tool vendor → listening + platform partnerships; founder-led → build-in-public community + manual warm layer).

## Step 3 — Write the plan

Follow `plan-template.md` section by section. Anchor everything in the playbook's patterns and benchmarks. Brand-specificity checks:

- Volume math must chain correctly: goal → prospects → sends/day → inboxes → domains → cost (playbook §8.1).
- Example emails: write them in the brand's plausible voice, each anchored to a specific signal from the signal map. 50–90 words, per playbook §8.3.
- Suggest actual lookalike domain names for the brand.
- Tool stack: every pick gets a brand-tied reason. **Prices and tool capabilities in tool-stack.md decay** — if web search is available, spot-check current pricing for the 3–4 most expensive picks before quoting a budget; if not, label the budget "verify current pricing" and date it. If a listed tool seems to have been discontinued or renamed, substitute the current category leader and say so.
- Risks section: name the failure modes *this* brand is most exposed to, not generic ones.

## Step 4 — Deliver

- Save the plan as a markdown file named `GTM-ENGINE-PLAN-{brand}.md` in the working directory (or where the user asks).
- In chat, give a tight summary: the motion in 3 sentences, the volume math, total budget, and the first 3 actions for this week.
- Offer natural next steps: draft the full sequences, build the Clay/n8n blueprint specs, or generate the ICP query for a specific database.

## Scope notes

- If the user only wants ONE stage (e.g., "just design my cold email infrastructure"), read the playbook and produce only that section at full depth — don't force the whole template.
- If the user asks to *execute* (actually send emails, build Clay tables, launch campaigns), this skill produces the design + specs; hand off execution to the relevant tools/skills (e.g., Apollo MCP, the `email` skill for copy variants) and say so.
- B2C/DTC brands: read `references/b2c-dtc.md` and use its stage re-mapping — do not force the B2B template. Hybrid brands (DTC + wholesale/creator motion) get both: the B2C file for the consumer side, the core playbook for the business side.
- **Not this skill's job** (defer to more specific skills/tools when the user wants only that): writing a single piece of content or one email sequence (content/email skills), post-meeting sales process — discovery, proposals, closing (sales skills), pure content/SEO strategy. This skill owns the *system design* that connects them.