Marketing capstone: the full engine

What you're shipping today

Over six weeks you built a marketing engine in pieces. The capstone runs it as one machine, on your real brand, in one sitting: a brief goes in, and out come a published page, a scheduled week of social, a staged newsletter section, and a report that knows what happened. Then you document it so it survives you.

• The repo: voice.md from your real corpus (plus voice-x.md if you cross-post), banned-words, positioning, calls and stories, the cadence, the folder gates.
• Skills: voice-extract, content-capture, seo-brief, write-post, write-linkedin, humanize, repurpose, the visual renderer, the lead-magnet page, publish-cms, the newsletter assembly, competitor-watch, the daily news digest, weekly-report - some installed from the catalogs and adapted, some built by hand. One skill per repeatable job - the law made visible.
• Subagents: researcher, writer, editor, fact-checker - each in its own context, each with a pinned model, and no writer grading its own draft.
• Guardrails: the lint script, the string-match quote check, the approved/ deny rule plus its PreToolUse hook, draft-only channel staging.
• Handoffs: the CMS publish package, the newsletter issue file, the social queue folder; analytics and search-console exports on the read side.

Anything on that list you skipped, today is when the gap shows. Patch as you go - the capstone is diagnostic by design. And gaps don't have to be built from scratch: open marketing skill packs exist (coreyhaines31/marketingskills on GitHub is a known one, and skillsmp.com indexes far more), so the fastest patch is install-then-adapt - read the full SKILL.md and scripts, copy it in, point it at your voice file and gates.

The run

One real piece from your actual calendar, end to end. Time each stage - the numbers become your before/after story.

1. Brief: run seo-brief on a real target query - your latest keyword export, the first-200-words requirement baked in.
2. Pipeline: run write-post. Approve the outline at the pause. Researcher, writer, editor, fact-checker each do their pass; the draft lands in drafts/ with a clean fact-check report.
3. Visual: render the post visual from HTML with the poster rules loaded - logos, names, counts, no sentences.
4. Gate: your human read. Edits become voice.md rewrite pairs. Move the file to approved/ yourself.
5. Publish: publish-cms builds the package with full furniture - metadata, FAQ JSON-LD validated, 3 internal links, alts. Carry it into your CMS, review, press publish by hand, archive to published/ with the URL.
6. Repurpose: run repurpose on the published piece. Pick moments, batch-review the derivatives, approve the survivors. The X version gets its own rewrite against voice-x.md.
7. Distribute: queue the social week as dated files in approved/social/; stage the newsletter section into this week's issue file.
8. Report: confirm the Monday report will capture the piece - page traffic, search queries, newsletter and social stats, all attributed.

The guardrail audit

Before you call it shipped, audit the engine against the five fears - the failure modes behind the AI-incident statistic from the first lesson - plus the one that hides inside every AI pipeline: a model approving its own work. Each maps to a specific mechanism; verify each mechanism actually fires.

• 'It won't sound like us' -> voice as a file built from real top-performing writing, rewrite pairs, banned words, the humanize pass. Test: blind-test still passes on this week's output.
• Hallucinated facts -> fact-checker subagent tracing every claim to a source, plus the deterministic string-match for quotes and numbers. Test: plant one fake number in a test draft; the pipeline must catch it.
• Off-brand at scale -> mechanical rules in code: the lint script, char validators, schema validation. Test: a draft with an em dash and a banned word fails loudly.
• Publishing accidents -> the folder boundary enforced by the deny rule plus the PreToolUse hook, with draft-only staging everywhere; no skill can send or publish. Test: ask Claude to mv a draft into approved/ - the hook must block the Bash call, because the deny rule alone would not catch it.
• Quality drift -> the capture loop (posted posts and corrections back into the corpus), performance notes in published/, the citation log, and the quarterly voice re-extraction. Test: this week's posted posts are already in corpus/posted/, and the calendar entry for the next re-extraction exists.
• The writer grading itself -> the editor and fact-checker run as separate subagents with their own context. Test: open each agent file and confirm the one that drafts is not the one that reviews.

Document it: CLAUDE.md as the operating manual

An engine only one person can run is a bus-factor problem wearing an automation costume. The fix is the repo's CLAUDE.md: the operating manual that makes every future session - and every future teammate - start smart. The best agency operators run their entire shop from this one file.

# Marketing repo - operating manual

## Who we are
One paragraph: company, audience, what we sell. Voice TL;DR
(full version: brand/voice.md - load it for ALL writing).

## Hard rules
- No em dashes. No words from brand/banned-words.md.
- NOTHING publishes or sends without a human. Skills stage
  drafts only. approved/ is human-written-only territory.
- Every claim traces to a source in the brief. No source, no claim.
- Same kind of asset twice? Make a skill. Don't re-prompt.
- Ground drafts only in corpus/ (calls, stories, posted). No
  facts from the model's general knowledge.

## Models
Writer, editor, fact-checker, researcher: opus. Variant batches:
sonnet. Tagging and metadata: haiku. Pinned in each agent file.

## Capture loop
Every posted post -> corpus/posted/. Every edit or rejection ->
corpus/corrections.md. Re-extract voice at 10+ new corrections.

## The pipeline
brief (seo-brief) -> write-post (4 subagents) -> human gate ->
publish-cms (publish package) -> human publish -> repurpose ->
queue (dated files in approved/social/) -> weekly-report

## Folder gates
drafts/ = machine territory. approved/ = humans move files here.
published/ = archive with URLs + performance notes.

## Who approves what
Posts: <name>, <name>. Founder-voice: founder only.
Newsletter send: <name>. CMS publish: <name>, <name>.

## Handoffs (produced here, finished; carried there by hand)
CMS: the publish-cms package. Newsletter: the issue file.
Social: post from the queue folder. Measurement: weekly
exports from analytics + search console into data/analytics/.
Nothing in this repo sends, posts, or publishes on its own.

1. Write it from today's run while the friction is fresh - the manual describes the engine as it actually works, not as designed.
2. Apply the test: could a new hire, or you in six months, run next week's content from this file alone? Have someone else try one skill using only the doc.
3. Commit everything: CLAUDE.md, skills, agents, settings, lint scripts. The repo is the playbook - there is no second document to drift out of date.
4. Package the team's skills as a plugin: the same marketplace mechanics you installed from work in reverse. A marketplace is just a git repo your teammates add once with /plugin marketplace add <org>/<repo>; after that a new teammate's setup is one /plugin install your-pack@your-marketplace command instead of a folder-copying afternoon, and a skill improved once reaches everyone on their next update.

Demo, cadence, and what's next

Finish by demoing a week of real output: the published page, the scheduled queue, the staged issue, the Monday report - and your stage timings against the old way. Benchmarks to beat: a two-person agency on this pattern took blog production from a full day to 2-3 hours at 3x output; Anthropic's team cut case studies from 2.5 hours to 30 minutes. Your numbers will differ; having numbers at all puts you ahead of almost everyone.

From here the engine compounds: every published piece feeds the archive, the archive feeds the voice and the newsletter and the report, and the report tells you where to point the engine next. You're no longer producing content with AI. You're operating a system that produces content - in your voice, with receipts, behind gates you control. That was the whole point.

Do this now

Sources and further reading

• RSL/A: a marketing agency run on Claude Code
• How Anthropic's marketing team uses Claude
• Marketing skills for Claude Code (open-source pack)