# Setup

This repo is a set of four Claude Code subagent definitions (`agents/*.md`) plus the
"harness" each one reads from (`growth-masters/<discipline>/`) — a manual, playbooks,
a linter, sample good/bad deliverables, and an `init.sh` gate that proves the linter
actually discriminates good work from bad. Everything here is plain text and plain
Python 3. Nothing here talks to the network, spawns another binary, or reads an API
key — the gates only ever run `python3` against files that live in this repo.

## What you need (checklist table)

| Requirement | Why | Have it already? |
|---|---|---|
| macOS, Linux, or WSL with a bash shell | `init.sh` in each harness is a bash script (`#!/usr/bin/env bash`) | Run `bash --version` |
| Python 3 (any recent version — no minimum version is enforced by the code; tested here on 3.14) | The linters (`verify_*.py`) are plain-stdlib Python 3, invoked as `python3` | Run `python3 --version` |
| Claude Code | The `agents/*.md` files are Claude Code subagent definitions — you invoke them from inside Claude Code | Run `claude --version` |
| Git | To clone this repo | Run `git --version` |

**NOT needed:**
- No Docker. Nothing here is containerized.
- No paid API key, no `.env` file, no external service account. The `crm-automator`
  agent's linter specifically hard-fails any deliverable that contains an inline
  secret — every credential in the playbooks is written as an `env.SOME_VAR`
  reference, never a real value.
- No GPU.
- No npm/Node, no Ruby, no other language runtime — the only interpreter used is
  Python 3, and only its standard library (`re`, `sys`, `argparse`, `pathlib`,
  `__future__`) — no `pip install` of anything.
- No account/signup of any kind to run or verify this repo locally.

## Install, step by step

Assume a fresh machine with nothing installed yet.

### 1. Install Homebrew (macOS only, skip if you already have it or are on Linux)

```bash
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
```
Installs the Homebrew package manager, used below to install Python if you don't have it.

Check it worked:
```bash
brew --version
```
Expected output: a line like `Homebrew 4.x.x`.

### 2. Install Python 3

macOS (Homebrew):
```bash
brew install python3
```
Windows: download the installer from https://www.python.org/downloads/ and run it (check
"Add python.exe to PATH" during install).

Linux (Debian/Ubuntu):
```bash
sudo apt-get update && sudo apt-get install -y python3
```

What it does: installs the Python 3 interpreter the linters run under.

Check it worked:
```bash
python3 --version
```
Expected output: `Python 3.x.x` (any recent 3.x — nothing in this repo requires a
specific minimum version).

### 3. Install Claude Code (needed to actually run the agents; not needed to run the gates)

macOS/Linux:
```bash
curl -fsSL https://claude.ai/install.sh | bash
```
Windows: see https://docs.claude.com/en/docs/claude-code for the current installer.

What it does: installs the `claude` CLI that reads `.claude/agents/*.md` subagent
definitions.

Check it worked:
```bash
claude --version
```
Expected output: a version string, e.g. `1.x.x (Claude Code)`.

### 4. Clone this repo

```bash
git clone <this-repo-url> growth-master-agents
cd growth-master-agents
```

Check it worked:
```bash
ls agents growth-masters
```
Expected output: `agents` lists four `.md` files; `growth-masters` lists four
discipline directories (`funnel-psychology`, `copywriting`, `email-marketing`,
`crm-automation`).

### 5. Drop the agent definitions into your own project

```bash
mkdir -p /path/to/your-project/.claude/agents
cp agents/*.md /path/to/your-project/.claude/agents/
cp -R growth-masters /path/to/your-project/
```

What it does: Claude Code auto-discovers subagents from `.claude/agents/`; the agent
files reference `growth-masters/<discipline>/` as a relative path from your working
directory, so both need to live in the same project.

Check it worked: from inside `your-project`, run `ls .claude/agents growth-masters` —
same four-and-four listing as step 4.

### 6. Prove each gate holds

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

What it does: runs each discipline's linter against its `samples/good/*` (must pass)
and `samples/bad/*` (must fail) — this is the "anti-theater" proof that the linter
really enforces the rubric instead of always printing green.

Check it worked: each command ends with a line starting `PASS:` and exits 0. If a
script is not executable, run `chmod +x growth-masters/*/init.sh` first (the files in
this repo already ship with the executable bit set, so this is only needed if your
copy method — e.g. downloading a zip — stripped it).

## Configure

Nothing to configure. There is no `.env` file, no config file, and no environment
variable read anywhere in this repo's code. (The `.gitignore` lists `.env`/`.env.*`
as a precaution for anyone who later adds real credentials to a downstream project
built on top of this one — it is not something this repo itself needs.)

If you do wire a `crm-automator` deliverable into a real CRM/enrichment provider
later, the playbooks show the convention to follow — reference the secret, never
paste it:
```
CLAY_API_KEY=your-clay-api-key-here   # keyzhub-allow
```

## Run it

The first thing to run is the gate for whichever discipline you're starting with, to
confirm the harness holds on your machine before you trust it:

```bash
cd growth-masters/funnel-psychology
./init.sh
```

Success looks like this — the script prints per-sample check results, then:
```
PASS: linter correctly passes the good sample and fails the bad sample.
```
and exits with status 0 (check with `echo $?` immediately after — it should print `0`).

After that, from inside Claude Code (in the project where you copied `agents/` and
`growth-masters/`), invoke an agent directly:
```
Use the funnel-psychologist agent to design a funnel blueprint for [your offer].
```

## Troubleshooting

1. **`FAIL: python3 not found on PATH`** — `init.sh` checks for `python3` explicitly
   (not `python`). Fix: complete step 2 above, or if Python is installed as `python`
   only, add a symlink (`sudo ln -s "$(command -v python)" /usr/local/bin/python3`) or
   reinstall via Homebrew/python.org, which both provide `python3`.

2. **`permission denied` running `./init.sh`** — the executable bit was stripped
   (common after downloading a zip instead of `git clone`). Fix: `chmod +x
   growth-masters/*/init.sh`.

3. **Agent isn't found / doesn't trigger inside Claude Code** — the `agents/*.md`
   files must be inside `.claude/agents/` in the project you're running Claude Code
   from, and `growth-masters/` must sit at that same project's root (the agents
   reference it as a relative path, e.g. `growth-masters/funnel-psychology/init.sh`).
   Fix: re-check step 5 — both directories need to be siblings of `.claude/` in your
   working directory, not off in some other folder.