Growth Master Agents

Requirements: Python 3 (stdlib only) + bash + Claude Code, no Docker, no API keys, no account — full walkthrough in SETUP.md.

Four marketing agents for Claude Code, each backed by a real harness and a real verification gate — not a prompt that hopes for the best. Together they form one growth engine: psychology designs the funnel, copy writes it, email sequences it, CRM wires it.

What's in here

agents/                          Claude Code agent definitions (drop into .claude/agents/)
  funnel-psychologist.md
  master-copywriter.md
  email-strategist.md
  crm-automator.md

growth-masters/                  the harness each agent reads from
  funnel-psychology/
  copywriting/
  email-marketing/
  crm-automation/

Each harness directory follows the same eight-file pattern:

The four agents

1. funnel-psychologist — conversion-path architect

Designs the funnel from psychological first principles — stages, order, offer at each rung, matched to prospect awareness and market sophistication. Owns the skeleton: every stage's single job, single primary CTA, quantified conversion assumptions, instrumentation, and failure exits. Ten named playbooks (Value Ladder, PLF, tripwire, webinar, application, CVJ, challenge, free-tool, book funnel, flywheel). Deliverable types: funnel-blueprint, offer-stack, landing-page-spec, funnel-audit, split-test-plan.

2. master-copywriter — conversion copy

Writes the words for a single persuasion surface — sales pages, VSL scripts, ad sets, subject-line banks, landing hero variants. Operates from six lead types, a proof equation, and ten named playbooks (Kennedy, Sugarman, Ogilvy, Halbert, and others). Deliverable types: sales-page, vsl-script, ad-set, email-subject-bank, landing-hero-variants.

3. email-strategist — the inbox channel

List architecture, deliverability, sequence design, cadence, lifecycle communication from welcome to winback. Deliverable types: welcome-sequence, launch-sequence, ecom-flow-set, daily-email, reactivation-campaign, deliverability-audit.

4. crm-automator — data, triggers, orchestration

Builds (not just describes) the CRM layer: lead-scoring models, automation specs, lifecycle journey maps, segmentation plans, pipeline audits, integration runbooks. Deliverable types: automation-spec, lead-scoring-model, segmentation-plan, journey-map, pipeline-audit, integration-runbook. Its linter hard-fails on anything that looks like an inline secret (API key, token, password pasted directly into a doc) — every credential must be an env-var or vault reference instead.

How the four chain together

funnel-psychologist  ->  master-copywriter  ->  email-strategist  ->  crm-automator
   designs the             writes the              builds the           wires it into
   skeleton                copy for it              sequences            your CRM

• funnel-psychologist never writes copy, sends, or triggers — it hands a blueprint downstream.
• master-copywriter writes to the blueprint's stages; it doesn't restructure the funnel.
• email-strategist sequences the copy into lifecycle arcs; it doesn't rewrite the sales page.
• crm-automator turns everything above into concrete CRM specs — properties, events, scores, triggers — it doesn't invent new stages or copy.

Quickstart

1. Copy agents/*.md into your project's .claude/agents/ directory.
2. Copy growth-masters/ into your project root (or anywhere — the agent files reference it as growth-masters/<discipline>/ relative to your working directory).
3. Confirm python3 is on your PATH — the gates are plain Python 3 with no dependencies.
4. Run each gate once to prove it holds before trusting it:

cd growth-masters/funnel-psychology && ./init.sh
cd ../copywriting && ./init.sh
cd ../email-marketing && ./init.sh
cd ../crm-automation && ./init.sh

Every gate should print PASS — the linter correctly passes the samples/good/ file and correctly fails the samples/bad/ file for that discipline.

1. In Claude Code, invoke an agent directly: "Use the funnel-psychologist agent to design a funnel blueprint for [your offer]." Or spawn it as a subagent via the Task tool.

The "no bullshit" contract

This is the actual discipline these harnesses enforce, and it's why the gate exists:

1. The linter (verify_*.py) encodes the discipline's rubric as executable checks — not vibes.
2. init.sh runs the linter against samples/good/* (must PASS) and samples/bad/* (must FAIL). If it ever passes the bad sample or fails the good one, init.sh exits nonzero — the linter is decorative and must be fixed before any deliverable in that discipline is trusted.
3. Every session starts by re-running ./init.sh. Never trust a prior "done" claim — the harness's AGENTS.md mandates re-verification from the gate, not from prose.
4. No deliverable is marked done in feature_list.json without the linter passing it.

Make it your own

• Swap the worked examples. The manuals and playbooks use a specific illustrative CRM scenario (a warm buyer list with zero re-engagement emails sent) to show the playbooks applied to a real decision. Replace those numbers with your own list size, revenue, and channel state wherever you see them — the playbooks are the reusable part, the numbers are just the demonstration.
• Add a fifth master. Clone the harness pattern (the same eight files), write a verify_<discipline>.py linter that encodes your rubric as executable checks, build samples/good/ and samples/bad/, and write an init.sh gate that passes the good sample and fails the bad one. Then write the agent file at agents/<agent-name>.md describing what it owns and what it hands off. The master is real the moment ./init.sh goes green — and not one moment before.
• Tighten or loosen the linters. verify_*.py in each harness is plain, dependency-free Python — read it, adjust the rubric thresholds (word caps, required sections, banned words) to match your own house style, then confirm ./init.sh still holds.

Requirements

• Python 3 (no external packages — the linters use only the standard library)
• Claude Code, to run the agents (agents/*.md are standard Claude Code subagent definitions)