The GTM Autonomy Curriculum

What it is: A laminated one-page diagram: the four-layer pyramid (Data Foundation → Outbound → Inbound → Custom plays) with entry criteria per layer, plus a placement worksheet — five questions that locate any proposed Clay project on the pyramid.

The motion, end to end:

1. Draw the four layers with a one-line definition and an entry criterion for each (e.g., Outbound requires a clean account universe first)
2. List your company's current and wished-for Clay use cases in the worksheet
3. Place each use case on a layer; anything at the tip while the base is empty gets re-sequenced
4. Mark the single next project — the lowest incomplete layer wins
5. Institutionalize: every new Clay proposal must name its layer before it's approved

What it is: A one-page reference card: the two meters (Data Credits vs Actions), the complete free-vs-paid ledger, plan tiers with real numbers, and a worksheet that decodes YOUR contract into monthly credits, actions, and dollars.

The motion, end to end:

1. Fill the top strip with your plan: monthly Data Credits, Actions, rollover terms, top-up premium
2. Walk the ledger: mark which of your team's routine operations cost credits, actions, or nothing
3. Compute your effective cost-per-enriched-record from last month's usage
4. Flag the two most expensive recurring operations for review against a cheaper mechanism
5. Post the card where the team builds; it's the 10-second pre-check for any new column

What it is: The 8 Habits rewritten as signed team policy, plus a pre-flight sign-off sheet and a setup guide for budgets and spike alerts — governance as a document people actually initial.

The motion, end to end:

1. Adopt the 8 habits as written policy in one team meeting; each builder initials it
2. Configure workspace credit budgets and spike alerts (or the manual weekly usage review if plan-gated)
3. Institute the pre-flight sign-off: any run over an agreed row threshold needs a second pair of eyes on the checklist
4. Run the Workspace Audit quarterly; the 3 red flags become that quarter's fixes
5. Assign one named Clay owner; document the escalation path when spend spikes

What it is: A printed 15-minute review card: seven checks that expose whether a vendor-built table is disciplined or dangerous, with a pass/flag box per check.

The motion, end to end:

1. Open the vendor's table; check run conditions exist on every paid column
2. Check waterfall order: cheapest provider first, one validator per data type
3. Check model tiers: no premium model on classification-grade tasks
4. Check write-back settings: fill-blanks-only, source/date stamps, no auto-assignment surprises
5. Check hygiene: naming, folder placement, no orphaned columns, no 'N/A' string outputs
6. Ask for the field contract; its absence is itself a finding
7. Score pass/flag per check; three flags = a remediation conversation with receipts

What it is: The maintenance protocol for inherited workbooks: a handover requirements list to demand from any vendor, an ownership map template, weekly/monthly check cadences, and the safe-change procedure for live tables.

The motion, end to end:

1. Inventory every live table: owner, purpose, what it feeds, last run (the ownership map)
2. Demand the handover pack from any departing vendor: field contract, provider list, run schedules, credential transfer
3. Set the cadence: weekly — check error rates and credit burn; monthly — sample outputs, verify syncs
4. Learn the safe-change procedure: duplicate → edit the copy → test 10 rows → swap → archive the original
5. Archive anything unowned after 30 days of silence — an unowned live table is a liability

What it is: A decision tree on one card: for any data need, walks formula → lookup → provider → BYO-key agent → not-Clay-at-all, with the cost logic at each branch and the agency-engagement decision at the end.

The motion, end to end:

1. Start every request at the free branch: can a formula or lookup on data you hold answer it?
2. For purchasable data: provider waterfall for contact data (needs validation), BYO-key agent for public/qualitative research
3. Apply the cost check: estimated rows × cost per successful result, against the value of the answer
4. If the build needs standing infrastructure you lack, decide build-vs-agency with the matrix's four questions
5. When an agency is right: scope with THIS card in hand — you now buy from strength, not blindness

What it is: A 90-day adoption roadmap template: pilot selection, owner assignment, the three ROI metrics, review cadence — plus the role-to-module sheet mapping your team onto the operator track.

The motion, end to end:

1. Pick ONE pilot from the Quick-Wins Bank or Project Menu — lowest incomplete pyramid layer, highest visible pain
2. Name the owner (builder) and the sponsor (you); put both names on the roadmap
3. Choose 3 metrics: typically speed-to-lead, cost per enriched record, credits saved vs baseline
4. Sequence days 1–30 (pilot built + scored), 31–60 (tuned + second use case), 61–90 (scaled + governance live)
5. Map each team member to their operator-track milestones; set the weekly review slot
6. Day 90: read the metrics against baseline; decide scale, adjust, or stop — with evidence

What it is: The same Use Case Pyramid as L1, sized for builders: the four layers, entry criteria, and the placement worksheet used in this milestone's exercise.

The motion, end to end:

1. Learn the four layers and what qualifies a project for each
2. Practice placement on the six scenario cards until layer-assignment is reflexive
3. Keep the pyramid open when planning any build; name the layer before naming the table

What it is: The Credit Ledger Card: every Clay operation classified as Data Credits / Actions / free, on one page, with the 'you only pay for successful results' rule and BYO-key economics highlighted.

The motion, end to end:

1. Memorize the free list: formulas, filters, imports, lookups, manual edits, exports
2. Classify your last five builds' columns against the ledger
3. Mark the BYO-key rows — where your own API key turns a data-credit cost into an action-only cost
4. Use the card in every exercise: pre-declare what each column will cost before it runs

What it is: The Workspace Starter: an importable folder skeleton (motions + team folder + Archive) plus the naming convention card (Nest · Number · Describe · Separate).

The motion, end to end:

1. Create the folder set: one per motion, one team folder, one Archive
2. Number your first workbook and its tables (1, 1.1, 1.2…)
3. Write two-sentence descriptions on every table: what it does, what feeds it
4. Move any dead or duplicate tables to Archive immediately
5. Adopt the send-picker test: if you can't pick the right table in 3 seconds, fix names

What it is: The Quick-Wins Bank: 50 build ideas on cards, each tagged function (sales/marketing/RevOps) × effort (hour/day/project) × cost (free/pocket-change/budget), with a one-line build sketch per card.

The motion, end to end:

1. Filter the bank to your function + under-an-hour + low cost
2. Pick 3 candidates; sanity-check each against the pyramid (no tip-of-pyramid picks in week one)
3. Scope ONE with the Pre-Flight Calculator: rows, columns, estimated credits/actions
4. Build it small (50–100 rows), show the result to one stakeholder
5. Log what it cost vs the estimate — your first calibration data point

What it is: Table Anatomy: the column-ordering standard (sources → inputs → free logic → paid enrichment → extraction formulas → AI → exports) as a poster, with the reasoning per zone.

The motion, end to end:

1. Import the provided CSV; map every input column
2. Order columns by the standard zones, left to right
3. Name each column for what it HOLDS ('Verified Work Email'), not what made it
4. Verify the table reads like a sentence: inputs flow left, decisions middle, outputs right

What it is: The Import Recipes: per-source setup cards (CSV, CRM import, Find Companies/People, Google Maps, HTTP API source, scheduled sources) plus the Normalization Recipes applied at entry.

The motion, end to end:

1. Pick the source by what you HAVE: a file → CSV; records → CRM import; criteria → Find Companies/People; local businesses → Maps; anything else → HTTP source
2. Map inputs on entry; never rename downstream of logic
3. Apply the normalization preamble immediately: domain, name, title
4. For recurring feeds, schedule the source instead of re-importing by hand
5. Verify 20 rows against the source of record before building on top

What it is: The Formula Library: the 15 formulas that appear in real production builds — classification by keyword/suffix/TLD, null-safe extraction, conditional gates, date math — as copy-paste snippets with when-to-use notes.

The motion, end to end:

1. Scan any planned AI or paid column and ask: which library formula does this free?
2. Install the three classifier formulas (keyword, name-suffix, domain-TLD) as your default pre-AI gate
3. Use null-safe extraction patterns so downstream columns never break on empty
4. Contribute back: any formula you write twice goes into your team's copy of the library

What it is: The 97%-Validity Email Waterfall: an importable table template — provider sequence ordered by cost, one validator pairing, run conditions pre-wired — plus the per-provider cost/match-rate reference sheet and reorder rules.

The motion, end to end:

1. Import the waterfall template into your workspace (one click via the course toolkit)
2. Map the four inputs: company name, domain, full name, LinkedIn URL
3. Review the provider order against the cost sheet; reorder cheapest-plausible-first for YOUR list's geography/segment
4. Confirm every finder is gated ('only run if empty') and the validator fires on every found address
5. Run 20 test rows; check hit rate and cost per verified email
6. Release on the full list within the exercise budget; log validity % achieved

What it is: The Match Ladder: the free CRM-lookup chain run before any paid enrichment — account ID → normalized domain → normalized name → create-new — as an importable column set with the fill-rate expectations per rung.

The motion, end to end:

1. Install the ladder columns at the head of any CRM-adjacent table
2. Rung 1: exact ID match against the CRM (free, definitive)
3. Rung 2: normalized-domain match; log the match source
4. Rung 3: fuzzy name match, tightened until one candidate returns
5. Only unmatched rows proceed to paid enrichment; measure the ladder's fill rate (40%+ is normal)

What it is: The Thin-Webhook pattern card: inbound webhook setup (ID-only payloads, rehydrate via lookup), outbound webhook push, and the fire-on-transition rule with its 5-event test.

The motion, end to end:

1. Create the inbound webhook; configure the CRM/form to send only the record ID
2. Fire on the TRANSITION into the qualifying state, never on every edit
3. Rehydrate all fields fresh via lookups — payload data is stale by definition
4. Run the 5-event test: qualify, re-edit, disqualify, requalify, unrelated update
5. For outbound: push results by webhook only where a native sync doesn't exist

What it is: The BYOK Playbook: key setup walk-throughs (OpenAI/Anthropic for agents and content at zero Data Credits), HTTP column templates for common email/data/validation APIs you already pay for, the marketplace-vs-direct comparison worksheet, and the key-safety checklist.

The motion, end to end:

1. Connect your own AI key; route agent and content columns through it (one Action, zero Data Credits)
2. Inventory the data subscriptions you already pay for (email finders, validators, providers)
3. Wire one as an HTTP column from the template pack; map inputs and parse the response
4. Run the comparison worksheet: cost per successful result, marketplace vs direct — keep whichever wins per data type
5. Doctrine: BYOK agents for public/qualitative research; validated provider waterfalls for contact data
6. Key hygiene: workspace-level storage, limited access, budget alarms on each external account

What it is: The Field Contract: the one-page agreement filled BEFORE building — every output field with its CRM destination, overwrite rule, format, and consumer — plus the write-back settings checklist (fill-blanks-only, stamps, no auto-assignment).

The motion, end to end:

1. List every field the build will produce; one row each in the contract
2. For each: destination object/field, overwrite rule (fill-blanks-only is default), who consumes it
3. Route discovered data to DEDICATED fields (work_email ≠ email) — never overwrite identity fields
4. Validate picklist values character-for-character against the CRM's allowed values
5. Configure the write: fill-blanks flags on, source+date stamps on, auto-assignment off, click-to-run first
6. Get the contract initialed by the CRM owner before the first write fires

What it is: The Prompt Template Pack: four ready prompts (one per tier) in the house format — role, {{input}} variables, strategy/rules/confidence checks, exact output schema — each with its JSON schema attached and the 'return empty, never N/A' rule wired in.

The motion, end to end:

1. Start from the tier template matching your task class — never from a blank prompt
2. Declare every input as a {{variable}} at the top; reference only those
3. Write rules that constrain: sources allowed, confidence threshold, empty-on-uncertain
4. Attach the JSON schema (objects closed, all fields required, null via anyOf)
5. Test on 10 sandbox rows; read outputs word by word before release

What it is: The Source-Hierarchy Research Prompt: the production pattern for AI research columns — an ordered source ladder (official filings → regulators → investor pages → press), confidence levels, null-on-low-confidence — plus the two-column gathering/processing pattern.

The motion, end to end:

1. Column 1 (cheap research tier): gather raw findings with the source ladder in the prompt
2. Column 2 (stronger model, gated on Column 1 non-empty): synthesize, validate, format
3. Encode the ladder explicitly: 'prefer sources in this order; report which was used'
4. Demand a confidence field; null everything below your threshold
5. Reconcile against any value you already hold (CRM wins within tolerance)

What it is: The Sandbox Testing Protocol: the iterate-free workflow — draft in Sculptor, validate in Sandbox Mode, release only what passed — so prompt iteration stops costing money.

The motion, end to end:

1. Describe the column to Sculptor in plain language; let it draft the config
2. Switch to Sandbox Mode; run the draft on your 10-row test set at zero cost
3. Iterate the prompt IN sandbox until outputs are clean — every rewrite is free here
4. Release to the live table only after sandbox passes; run conditions still on
5. Log the final prompt into your team's prompt pack

What it is: The Signal Taxonomy: a 17-row worksheet — signal, category, weight, source, decay window — pre-filled with the standard B2B set (job change 60d, funding 90d, hiring, tech change, engagement), ready to prune to YOUR motion.

The motion, end to end:

1. Prune to the 5–7 signals your team can actually act on (start with ONE live)
2. Set weights (1–10) and decay windows per signal — stale signals must expire
3. Name the data source per row; a signal without a source is a wish
4. Configure the first signal (job change on champions) with 90-day lookback, weekly recurrence
5. Track conversions per signal monthly; kill what doesn't convert

What it is: The Audiences IEAE Playbook: the Import → Enrich → Action → Export operating loop for Audiences — CRM connection, gap segments, continuous + scheduled enrichment, and the action layer that stops enriched data from being decoration.

The motion, end to end:

1. Import: connect the CRM; verify objects and field mapping
2. Build gap segments — enrich ONLY missing fields, never the whole base
3. Test on 10–20 records; check field mapping and spend before enabling anything continuous
4. Enable continuous enrichment for new records; schedule refresh for existing (per the Hygiene Cadence)
5. Action layer: quality-filtered segments that alert, route, or hand to tables — enriched data nobody acts on is waste
6. Export: 24-hour write-back of only the fields reps use, fill-blanks-only

What it is: The Segment Pattern Card: the three segment archetypes — gap (enrich only what's missing), quality (gate what may act), action (trigger alerts/syncs/handoffs) — with naming conventions and examples.

The motion, end to end:

1. Design gap segments per field family; wire enrichment to the segment, never the whole audience
2. Design the quality gate: the conditions a record must meet before ANY activation touches it
3. Design action segments: signal + fit conditions → alert, sync, or table handoff
4. Name segments by archetype prefix (GAP-, GATE-, ACT-) so intent reads at a glance
5. Review monthly: a segment nobody consumes is clutter; retire it

What it is: The Workflow Patterns Card: trigger types, step/branch patterns, Slack approval gates, scheduling, and the workflow-vs-table-chain decision rule.

The motion, end to end:

1. Identify the trigger: schedule, webhook/event, or manual
2. Sketch steps on paper first; every branch needs a named condition
3. Insert an approval gate before anything destructive or outbound
4. Rebuild one existing delay-chained table pair as a workflow; compare observability
5. Rule: multi-step + trigger-driven = workflow; single-stage data shaping = table

What it is: The Function Library starter: the email waterfall and the classifier packaged as reusable Functions with tests, plus the function-vs-formula-vs-table decision card and the team-standard publishing convention.

The motion, end to end:

1. Take your proven M1 waterfall; package it as a Function with named inputs
2. Attach test cases (known-good rows) so changes are verifiable
3. Call it from two different tables; confirm identical behavior
4. Publish under the team convention (name, version, owner, changelog)
5. Migrate the classifier next; from now on, twice-built logic becomes a Function

What it is: The Sequencer Setup Card: domains/inboxes (bought with credits), warm-up schedule, sequence structure, reply-handling rules — plus the sequencer-vs-external decision note (when Smartlead/Instantly/Outreach stays).

The motion, end to end:

1. Buy/connect sending domains and inboxes; start warm-up BEFORE you need them (2 weeks)
2. Set daily caps with a ramp; never start at full volume
3. Build the sequence with steps + waits; personalization variables carry fallbacks
4. Wire reply handling: positive → CRM task, OOO → pause/retry, negative → suppress
5. Decision note: committed external sequencer + deliverability history = stay put; don't confuse the stack story

What it is: The MCP Setup Guide: connecting Clay to AI assistants, per-user credit budgets, and the three starter task recipes (find contacts at an account, enrich a list, account brief) as copy-paste asks.

The motion, end to end:

1. Enable the Clay MCP connection for the assistant your team already uses
2. Set per-user credit budgets BEFORE announcing the capability
3. Run the three starter recipes yourself; adjust wording to your data
4. Distribute recipes + a 20-minute walkthrough; route ad-hoc asks here first
5. Review usage monthly; heavy users are future builders

What it is: The Pre-Flight Checklist: the 8 habits compressed into a 30-second printed ritual card, run before ANY table goes live.

The motion, end to end:

1. Auto-update off while building?
2. Run condition on every paid column?
3. Free logic (filters/DQ) runs before paid steps?
4. Data you already own looked up, not re-bought?
5. Prompts tested on 10 rows in sandbox first?
6. Waterfall ordered by cost? Dedupe done?
7. Row count that will ACTUALLY run confirmed, × cost estimated?
8. Anything big or unfamiliar: second pair of eyes before release

What it is: The Pre-Flight Calculator: the course tool where you input row count and pick your columns, and it returns estimated Data Credits, Actions, and dollars — plus the scoping worksheet that turns any request into a budget.

The motion, end to end:

1. Enter the true run count (rows that will actually fire, after filters — not table size)
2. Add each planned column; the registry prices it per successful result
3. Read the estimate; if >10 credits/row appears, suspect a unit error
4. Run 20 rows live; compare actual vs estimate and adjust provider assumptions
5. Attach the estimate to your exercise submission — estimates are mandatory from here on

What it is: Normalization Recipes: copy-paste formula snippets for the recurring cleanups — domain extraction/normalization, full-name derivation, title normalization — plus the dedupe pass procedure.

The motion, end to end:

1. Normalize domains first (strip protocol/www, lowercase) — the join key everywhere
2. Derive full name from first + last; never trust a pasted full-name field
3. Run title normalization so persona filters don't miss 'VP Sales' vs 'V.P. of Sales'
4. Dedupe on the normalized domain + person key BEFORE any paid column exists
5. Save the recipe columns as your standard import preamble

What it is: The Hygiene Cadence: the standing refresh system — gap segments per field family, scheduled re-enrichment frequencies (contacts quarterly, firmographics monthly), and the status-stamp fields that make it observable.

The motion, end to end:

1. Build gap segments per field family: 'Prospect AND Industry is blank', etc.
2. Wire enrichment to the SEGMENT, so only gaps ever get bought
3. Set schedules: fast-decaying data (title, company) quarterly; slow data (industry, size) monthly-to-quarterly
4. Stamp every processed record: enrichment status + date — the engine's heartbeat
5. Review monthly: disagreement rate between refreshed values and CRM values is a finding, not noise

What it is: The Warehouse Connection Guide: BigQuery/Snowflake as a Clay source — least-privilege service account setup (from a production PLG build), the Source-of-Truth Map deciding which fields come from warehouse vs CRM vs enrichment, and the sync patterns into tables and Audiences.

The motion, end to end:

1. Map the source of truth: for each of your 10 key fields — warehouse, CRM, or enrichment?
2. Create the service account with minimum roles (data viewer + job user; nothing more)
3. Connect the warehouse source; validate with a 100-row pull before anything recurring
4. Sync product/billing signals (usage, PQL events) into the scoring and audience layers
5. Document the blockers you'll hit (key-creation policies, org restrictions) and their fixes — they're in the guide

What it is: The Thin-Webhook Intake: an importable intake table — webhook source carrying only the record ID, rehydration lookups, and the dual-path design (live webhook + batch import produce identical downstream columns).

The motion, end to end:

1. Configure the CRM to fire on the TRANSITION into the qualifying state only
2. Send only the record ID in the payload; everything else rehydrates fresh via lookup
3. Build the dual-source intake formulas so batch imports flow through identical logic
4. Test fire/no-fire on five events: qualify, re-edit, disqualify, requalify, unrelated update
5. Document the qualifying event definition in the table description — it's the build's constitution

What it is: The Inbound Enrichment Playbook: the flagship six-stage spine (qualify → rehydrate → resolve person → resolve company → match-or-create → write back) decoded from three production builds, with cost gates at every stage.

The motion, end to end:

1. Stage the table on the six-stage spine; sales-led runs company-first, PLG person-first
2. Gate everything on one cheap check first (e.g., email-validity decides if any finder runs)
3. De-anonymize with the waterfall + cross-provider dedupe accumulator (rejected candidates skip re-validation)
4. Resolve company once per company — the shared company table is the biggest cost saver at volume
5. Free DQ logic before any paid step: spam patterns, competitors, students, junk domains
6. Match-or-create via the ladder; write back under the field contract
7. Pilot 20 rows: measure per-field match rate and cost per record before opening the firehose

What it is: The Scoring Model Pack: importable fit + intent scoring columns with a weighting worksheet — firmographic weights, signal weights with decay, combined A/B/C tiering — designed to stay explainable to sales.

The motion, end to end:

1. Define fit: 4–6 firmographic criteria, weighted in the worksheet (sum to 100)
2. Define intent: the 3–5 signals you actually collect, each weighted × recency multiplier
3. Combine into tiers with visible sub-scores — a rep must be able to see WHY it's an A
4. Backtest on 10 recent wins and 10 losses; adjust weights until winners score high
5. Sanity-check tier sizes (500 accounts in tier A = thresholds too loose)
6. Write tiers to the CRM with the score components alongside — no black boxes

What it is: The Routing Recipe Book: importable routing logic for the three models (round-robin, territory, ICP-based) plus SLA/escalation patterns and the Slack-alert payload that arrives with full context.

The motion, end to end:

1. Choose the routing model your org actually runs (or hybrid); import that recipe
2. Wire owner assignment with active/inactive rotation so vacations don't need a rebuild
3. Set the SLA: what happens at 1 hour, 1 day, 3 days unworked — escalation is part of routing
4. Compose the alert payload: who, company, score, why-routed-here, one-click links
5. End-to-end test: a form-fill must land routed, alerted, and CRM-complete with zero manual touches

What it is: The TAM Sourcing Playbook: building the account universe from ICP filters (or a Sculptor description), draft-mode refinement, LinkedIn-URL dedupe on commit, and lifecycle staging that keeps sourced records out of pipeline metrics.

The motion, end to end:

1. Translate the ICP into filters (firmographic + growth + technographic, including exclusions)
2. Refine in DRAFT mode — drafts are free, commits cost; spot-check 20–30 companies
3. Commit; dedupe on LinkedIn URL as the primary key (catches name-variant duplicates)
4. Enrich the committed universe via gap segments, not blanket enrichment
5. Stage sourced records in their own lifecycle stage — never let them pollute conversion metrics
6. Keep the filter live as a self-updating segment; review the ICP quarterly

What it is: The Job-Change Play Recipe: the champion-mover motion end to end — monitoring segment, signal config, new-company enrichment, owner alert with context, linked contact creation, and the handoff into outreach.

The motion, end to end:

1. Build the monitoring segment: closed-won contacts + past champions, deduped
2. Configure the job-change signal (60–90d lookback, weekly recurrence) writing to its own column
3. On fire: enrich the NEW company (fit check) before anyone gets excited
4. Alert the owning rep with full context: who moved, where, old relationship, fit score
5. Create the linked contact at the new account; preserve the relationship history
6. Feed qualified movers into the outreach table with the 'old friend' angle — highest-converting play in B2B

What it is: The Ads Activation Pattern: CRM-connected ad audiences with dynamic exclusion architecture (customers, open opps, partners), lookalike seeds from won business, sync cadence, and match-rate monitoring.

The motion, end to end:

1. Build the target audience segment from ICP fit + intent conditions
2. Build the EXCLUSION segment first: customers, open opportunities, partners, DQ — applied across every campaign
3. Seed lookalikes from real closed-won accounts, not raw traffic
4. Sync daily; platforms need ~48h to process — patience before judgment
5. Monitor match rates (LinkedIn 90–95% target; investigate below 80%); refresh seeds quarterly

What it is: The Quality Gate spec: the segment definition that nothing crosses unsequenced — verified email + first name + signal present — plus the handoff map for Clay Sequencer and the big third-party sequencers with deliverability guardrails.

The motion, end to end:

1. Define the gate segment: every condition a record must meet to deserve a send
2. Wire the sequencer handoff (native or push) so ONLY the gate segment can flow
3. Set deliverability guardrails: warm domains, daily caps, ramp schedule
4. Test with 25 records: confirm zero ungated leakage
5. Publish the gate definition to the team — it's the contract between data and sending

What it is: The Personalization Prompt Pack: the base prompt governing tone/length/structure, the 1–2-data-point rule, and the review-loop protocol with its two health metrics (edit rate >30% = fix prompt; skip rate >10% = fix targeting).

The motion, end to end:

1. Write the base prompt once: voice, length, structure, banned phrases
2. Feed at most two personalization data points per message — restraint reads human
3. Run the review step at 100% for weeks 1–2; track edit and skip rates
4. Diagnose by the metrics: high edits = prompt problem, high skips = targeting problem
5. Graduate proven campaigns to automation gradually; new campaigns always start reviewed

What it is: The MCP Setup Guide: connecting Clay to the team's AI assistants with per-rep credit budgets, plus the rep task recipes (find contacts at an account, enrich a list, account brief) written as copy-paste asks.

The motion, end to end:

1. Enable the Clay MCP connection for rep-facing AI assistants
2. Set per-rep credit budgets BEFORE announcing it exists
3. Distribute the three starter recipes; run a 20-minute rep session on them
4. Route rep 'can Clay do X' asks through MCP first — most never need a seat
5. Review rep usage monthly; heavy users are your future builder candidates

What it is: The Campaign Telemetry Kit: the six-component spec as buildable pieces — campaign object schema, member-status ladders per channel, UTM/source taxonomy, influence-model config, routing SLA, and the scorecard template.

The motion, end to end:

1. Create the campaign object: type, channel, motion, owner, spend, dates
2. Define one member-status ladder per channel so progression is comparable
3. Lock the UTM/source taxonomy that survives the MAP→CRM handoff
4. Configure first/last/multi-touch influence on the same opportunity
5. Wire routing SLA: who gets the lead, how fast, what happens when they don't work it
6. Build the scorecard: cost, conversion, velocity, pipeline — per CAMPAIGN, not channel

What it is: The Defect Taxonomy + 15-Minute Table Review: the catalog of real production defects (uncompiled run conditions, prompt/schema drift, orphaned columns, computed-never-written fields, whitespace names, 'N/A' strings, wrong model tiers) with the triage method — the same card leaders get in L4.

The motion, end to end:

1. Run the seven checks in order; log pass/flag per check
2. For each flag: classify against the taxonomy and estimate its cost impact
3. Practice the 60-minute incident drill: 'reply rates dropped 50% — check sends, then gates, then data freshness, then deliverability'
4. Keep the taxonomy updated: every new defect found in the wild gets a row

What it is: The complete template library, indexed: every importable table, prompt, checklist, and card from M0–M7, organized by the five capstone tracks (Inbound / Outbound / RevOps / Marketing / Sales) so your capstone assembles from proven parts.

The motion, end to end:

1. Pick your function's track; open its assembly list
2. Import the track's templates in dependency order (the list gives it)
3. Adapt each to your ICP/CRM under the field contract
4. Wire telemetry from the 7.1 kit on top
5. Run within budget; submit with the scorecard reading

What it is: The Demand Gen Project Menu + Vault Index: 20+ scoped project cards organized by motion (Create / Capture / Target / Expand) × channel, each tagged effort/credit-cost/teaching-milestone — plus the master index of every numbered artifact in the course.

The motion, end to end:

1. Filter the menu by your weakest motion (where's the pipeline gap?)
2. Shortlist 5 projects; check each card's effort and cost tags against your quarter's capacity
3. Pick 3; sequence them easiest-win-first
4. Budget each with the calculator; sum against your credit plan
5. Write the one-page quarter plan: projects, owners, budgets, review dates — that's your submission and your actual Q-plan

What it is: The Course Plugin: a one-command install that puts the toolkit inside Claude Code — table builder, house-format prompt generator, pre-flight estimator, submission packager — plus the agent recipes for driving Clay from the terminal.

The motion, end to end:

1. Install with the single command from the course portal
2. Rebuild a known table by INSTRUCTING the agent instead of clicking — feel the leverage shift
3. Use the prompt generator for every new AI column from now on
4. Estimate before running, from the same chat
5. Package and submit exercises through the plugin — the grader reads its output natively