agent-pipeline-render

Files (3)

• SKILL.md
• gtm-strategy-builder-walkthrough.md · references/
• strategy-payload-template.json · templates/

SKILL.md (first lines)

# Agent Pipeline Render — local artifact generation without running the swarm

## The class of repo

An "agent-swarm pipeline" repo in 2026 (Claude Code Workflow tool, AO, or similar) typically has:

- `*.workflow.js` (Claude Code) or `agent.py` (AO) — **the LLM orchestration layer** (NOT portable; requires Claude Code's proprietary Workflow tool API)
- `make_*.py` / `render_*.py` / `serve.py` — **the deterministic Python rendering layer** (portable; runs without any LLM)
- `examples/<client>/` or `runs/<client>/` — pre-baked examples showing the input schema
- `brand*.json` — visual identity config (firm_name, mode=light/dark, accent, fonts)
- `tests/` — pytest tests for the rendering layer
- `README.md` and `SPEC.md` — docs for the framework the swarm encodes

The README usually says "Built and run inside Claude Code" — that's about the LLM layer. **The Python layer is fully usable without Claude Code.** Don't waste cycles trying to run `*.workflow.js` outside Claude Code; the Workflow tool API is closed.

## When to use this skill

- You are handed a pipeline repo whose primary execution path is the Claude Code Workflow tool (or AO) and you don't have it
- The user wants the **artifacts** (decks, dashboards, docx, boards), not the LLM reasoning itself
- OR the user wants to **evaluate their product against a standardized framework** that the pipeline encodes (e.g. feed in their own brief and get a strategy back)
- Your runtime is Hermes / Codex / headless CI / any non-Claude-Code agent

## When NOT to use

- You actually have Claude Code available — just use the swarm
- The pipeline has no Python rendering layer (only Workflow JS / pure LLM prompts)
- The user wants the LLM's reasoning as the output, not rendered artifacts

## The 5-step workflow

### Step 1 — Identify the rendering layer

Look for `make_*.py`, `render_*.py`, `serve.py`, top-level `*.py`. These run without LLM:

```bash
ls *.py | head -20
grep -l "argparse\|def main" *.py
```

Common entry points:

| Command | Output |
|---|---|
| `python3 make_deck.py <brand> <client> --set` | `.pptx` set in `runs/<client>/decks/` |
| `python3 make_status.py [client]` | `STATUS.md` + `status.html` |
| `python3 serve.py <port>` | local HTTP dashboard |
| `python3 render_*.py <client>` | `.md` → `.docx` / `.pdf` |
| `python3 make_board.py <client>` | `runs/<client>/board.html` (may need `tools/*.json`) |

Install deps (almost always `python-pptx`, `python-docx`, `pillow`, optionally `numpy`, `openpyxl`):

```bash
pip3 install -q python-pptx python-docx pillow   # NOT --user in a venv (fails)
python3 -c "import pptx, docx, PIL; print('OK', pptx.__version__, docx.__version__)"
```

### Step 2 — Discover the input schema

Walk the bundled examples:

```bash
ls examples/*/         # or runs/*/
cat examples/<best-example>/full-strategy.json | python3 -m json.tool | head -80
```

Pick the most-complete example. Note:

- **Required fields** (every example has them)
- **Optional fields** (some examples omit)
- **Enums** (e.g. `phase` is usually a fixed list like Diagnose/Foundation/Demand Engine/Sales/Content/Measure)

For gtm-strategy-builder the canonical schema is in `examples/the-ledger/full-strategy.json` — see `templates/strategy-payload-template.json` for a minimal skeleton derived from it.

### Step 3 — Hand-author the input JSON

Create `runs/<your-client>/full-strategy.json`:

- Copy the schema shape from the most-complete example
- Fill every field with content **grounded in real evidence** — file:line citations, real numbers, real repo paths. Not aspirational copy.
- Keep text fields at typical example length (truncate rather than bloat)
- For frameworks that demand evidence/citations, include real references (file:line, wiki path, doc URL)

Validate by running the deck/status generator — most will error loudly on missing required fields.

### Step 4 — Set up branding BEFORE rendering

If the repo has `brand-<client>.json`, create one. Common keys:

```json
{
  "firm_name": "Your Firm Name",
  "tagline": "Your tagline",
  "mode": "dark",
  "bg": "0F1216",
  "surface": "171B21",
  "text": "E7E9EC",
  "muted": "8B939C",
  "ink": "E7E9EC",
  "primary": "1F1B14",
  "accent": "C2542D",
  "footer": "Internal — prepared for {client}",
  "head_font": "Baskerville",
  "body_font": "Helvetica Neue"
}
```

**Regenerate after any brand change** — most rendering layers bake the brand into the `.pptx`/`.pdf` at render time, not at view time.

### Step 5 — Render, verify, serve, screenshot

```bash
# Generate
python3 make_deck.py <client> <client> --set
python3 make_status.py
python3 -m pytest tests/ -v          # confirm bundled tests still pass

# Serve (background it — foreground will time out)
python3 serve.py 8099 &
sleep 2 && curl -fsS -o /dev/null -w "%{http_code}\n" http://localhost:8099/

From jleechanorg/jleechanbrain, MIT.

More from jleechanorg/jleechanbrain