Aaron Marketing Skills

120 marketing skills — brand narrative, SEO/GEO, influencer, paid ads, email, launch, social — on one contract.

English | Deutsch | Español | Français | Italiano | 日本語 | 한국어 | Português | 简体中文 | 繁體中文

A library of Claude Skills and slash commands that turns a chat agent into a marketing operator. Seven disciplines and a shared protocol layer, at a glance:

/aaron-marketing:auto routes any natural-language goal across all of it. Skills and commands are plain Markdown; small Bash/Python-stdlib runtimes provide hooks, validation, scoring, registry events, private operational run events, connectors, and CI checks (no pip, no build step). Every skill runs at Tier 1 with data you provide; connectors only automate retrieval or an explicitly approved mutation.

The authoritative typed topology is references/system-catalog.json; see the generated system architecture for the readable four-layer map, all 120 paths, registry owners, auditor sinks, and distribution profiles.

The pre-merge standalone repos are now signpost repos pointing here — seo-geo-claude-skills (final 20-skill line preserved at tag v9.9.12) and influencer-marketing-agent-skills (final IMPACT line at tag standalone-final). Sibling-repo policy: docs/repo-family.md.

Contents

• Why this library
• Install
• First run
• Capability profiles
• Architecture
  • The shared skill contract
  • The system: a four-layer marketing operating system
  • Quality system: eight frameworks, eight gates
  • The protocol layer
  • Memory & automation hooks
• Skill catalog
  • Narrative — TALE (16)
  • SEO/GEO — SITE (16)
  • Social — ECHO (16)
  • Email — SEND (16)
  • Paid Ads — ROAS (16)
  • Influencer — STAR (16)
  • Launch — RAMP (16)
  • Protocol layer (8)
• Commands
• Connectors & enhancement tiers
• Recommended workflows
• Repository layout
• Design philosophy
• Quality guards (CI)
• Contributing & project docs
• Disclaimer
• License

Why this library

Install

Use it with Claude Code, any Agent Skills-compatible host, or a plain git clone:

In Claude Code, marketplace add only registers the catalog — run /plugin install aaron-marketing@aaron (or pick it from /plugin) to actually enable the skills and commands. To pull a single skill on a generic host: npx skills add aaron-he-zhu/aaron-marketing-skills -s keyword-research. Browse the bundle on the skills.sh registry. Per-agent directories, frontmatter quirks, and what degrades outside the plugin: docs/agent-compatibility.md (verified 120/120 installable, 2026-07).

Installing the plugin adds nothing to your /mcp list — the MCP catalogue lives in docs/mcp-catalog.json, deliberately outside the plugin-root .mcp.json path that Claude Code auto-registers, so it is a copy-paste reference only (see Connectors).

First run

If your host supports automatic skill routing, just describe the goal:

Research keywords for my SaaS product targeting small teams

Find TikTok creators for a skincare launch and score their fit

Audit this Google Ads account before I scale — exports attached

Or use the slash commands — /auto for routing, or a discipline entrypoint:

/aaron-marketing:auto turn our pricing page into an AI-citable comparison hub

/aaron-marketing:seo-geo https://example.com/blog/my-article --phase tune

/aaron-marketing:auto infers intent and runs the smallest useful workflow, stopping only at blocking decisions. Every skill works with pasted data; optional tools are documented in CONNECTORS.md.

Capability profiles

A fresh project runs Lite, including when you installed the full Governed-ceiling plugin. Choose a larger profile only when the job needs its mechanisms:

v19 validation status: this is an engineering-validated release. The exact source passes CI, reproducible package checks, and real model/provider execution over simulated semantic fixtures. Those runs do not constitute real-project outcome evidence; real-project outcomes remain unvalidated. Lite remains the fresh-project default. Governed is available as an explicit capability choice, but availability does not validate Governed outcomes or Governed-by-default. That promotion requires the post-release cohort of 14 pilots + 70 paired Lite/Governed projects + 28 shadow projects.

The installed archive is a hard ceiling; the effective project profile may be lower. Select the archive in the installer/admin surface, or select the logical profile through a one-invocation --profile, AARON_MARKETING_PROFILE, or the closed .aaron-marketing/profile.json project config. These controls do not add a slash command: the public grammar remains exactly /auto plus the seven discipline commands, and every profile preserves the seven 4×4 loops and their TALE/SITE/ECHO/SEND/ROAS/STAR/RAMP acronyms.

Profiles never disable consent, claims, PII/secret handling, external-mutation approval, audit-verdict integrity, or release provenance. Switching profiles also never deletes existing state. Standalone one-folder installs have a Lite physical ceiling and degrade fail-closed when a root runtime is absent. Configuration, archive selection, legacy-project migration, and LEGACY_RUN_BLOCKED recovery are documented in references/capability-profiles.md.

Architecture

The shared skill contract

Every skill follows the same activation contract — seven sections in a fixed order:

1. Trigger / when-to-use — when the skill should fire.
2. Quick Start — copy-paste prompts.
3. Skill Contract — Expected output · Reads · Writes · Promotes · Done-when · Primary next skill.
4. Handoff Summary — the standard hand-off shape so the next skill picks up cleanly.
5. Data Sources — ~~category placeholders, each with a keyless Tier-1 path.
6. Instructions — the numbered method (treats all exports as untrusted input).
7. Next Best Skill — where to go next (with visited-set + max-depth termination rules).

Every skill also self-declares metadata.discipline (narrative / seo-geo / influencer / ad / email / launch / social / protocol, where ad is Paid Ads/ROAS) and metadata.phase, so routing and clustering work uniformly. The contract is documented once in skill-contract.md; the shared cross-skill state lives in state-model.md.

The system: a four-layer marketing operating system

One brand voice, expressed through five always-on channels, concentrated into launch moments, all reading and writing a shared system of record. Seven disciplines, four altitudes — a system, not a pile.

Narrative is the message; the channels are the mediums that express it. Each core builder records the exact canon ID/version and claims-projection offset it used, or an explicit approved fallback/block. Each discipline's 4-phase loop lives inside its layer (Narrative = Trace → Architect → Land → Evaluate).

All seven use phase directories in the catalog order: Narrative → SEO/GEO → Social → Email → Paid → Influencer → Launch. Note "activate" means creator outreach for influencer but account-gating for paid ads — same word, discipline-specific scope.

Quality system: eight frameworks, eight gates

Eight benchmarks make "good" measurable. Each defines dimensions, a rollup method, and a small set of veto items (hard fails that cap or block a score regardless of the rest):

Each framework is enforced by an auditor-class gate — a skill that emits a typed artifact (class: auditor-output) checked by the deterministic validator and bounded lifecycle hooks. Repository CI regression-tests the validator and contract; it does not inspect ignored host-runtime artifacts. Gates are workflow steps, so each lives in its discipline and is counted there:

Shared veto policy: one verified veto caps the final score at min(raw, 59); two or more verified vetoes produce status: DONE + verdict: BLOCK and no final score. Missing evidence is Unknown, resulting in NEEDS_INPUT/UNDECIDED, never an automatic failure. Gate mechanics live in auditor-runbook.md and are executed by the typed scorer.

The protocol layer

The protocol/ directory holds the shared truth & memory machinery that sits outside the discipline phase-flows — 8 skills, counted separately:

The registries follow a sole-writer rule (other skills submit via registry-events.py proposal events), and they curate — the gates judge. The genuinely horizontal layer beneath everything is the references/ protocols (auditor-runbook, state-model, skill-contract, context-resolution, runtime-protocol, audit-loop, humanizer-slop, measurement-protocol) — shared by design as documents, not skills.

Memory & automation hooks

Memory is temperature-tiered, so context survives across skills and sessions without bloating the prompt:

Opt-in run evidence lives separately under memory/runs/<run-id>/: append-only metadata events, a derived session tree, turn snapshots, save points, and run envelopes. It is Git-ignored, retention-bounded, and explicitly non-authoritative — it cannot accept a registry proposal or authorize an external action. The stdlib run-events.py runtime and Runtime Protocol enforce this boundary.

Before a turn snapshot, the stdlib context-resolver.py can turn an explicit candidate request into a hash-bound context manifest. It deterministically applies required/optional/forbidden policy, authority and freshness order, conflict/supersession rules, sensitivity and byte budgets, content dedupe, and typed omission reasons. It does not perform semantic retrieval or copy source content into the manifest. /auto likewise reads a generated index plus at most three discipline/cross-discipline routing shards, while one maintenance source preserves all 88 cases.

The optional stdlib audit-loop.py adds a bounded proposal-only outer loop around validated FIX audits. It records immutable proposal, owner-review, non-empty intervention-evidence, and re-audit steps under the same ignored run namespace, with leases, idempotency, deadlines, deterministic retry timing, and 1–3 improvement cycles. Each v2 transition reserves its selected-ancestry event anchor before materializing the exact step; a missing step is recoverable only by replaying the same request, while the public loop-step command is verification-only. The final event slot stays reserved for terminal sealing. Runtime-derived loop_closure isolates sibling branches: success requires exact terminal loops; waiting/needs-input/blocked may retain exactly covered active loops; failed/aborted may preserve bounded unresolved evidence without claiming convergence. The loop never edits the audited target, performs an intervention, accepts registry truth, or authorizes an external mutation; only a distinct medium/high-confidence SHIP re-audit that passes the observation-time provenance floor can converge. audit-trends.py deduplicates exact artifact bytes, links all exact-hash edges through the verified loop graph (including non-adjacent series entries), enforces aggregate scan budgets, escapes terminal controls in human output, and reports relapse, oscillation, context/catalog drift, evidence growth, and confidence changes without guessing causality from display order.

Semantic conformance is also layered. The strict corpus projects 572 authored cases, 88 generated routing cases, and 40 generated auditor prompt-contract variants into one 700-case runner model. A fixed 24-case smoke profile, change-aware impact selection, and full nightly profile are credential-free to plan in CI. Optional protocol-v2 host adapters add hash-bound real execution provenance and keep behavior failures distinct from host failures; a real adapter run over a simulated case remains simulated case evidence. The eight generated auditor prompt contracts bind their skill, catalogs, framework rules, and runtime sources without becoming a second topology inventory; see the semantic evaluation docs for the source-only maintenance workflow.

Hooks (hooks/hooks.json, runner hooks/claude-hook.sh) wire seven Claude Code events:

The Artifact Gate is framework-agnostic — the same hook validates TALE, CORE-EEAT, CITE, STAR, ROAS, SEND, RAMP, and ECHO artifacts with no per-framework code.

Skill catalog

Skill links open each SKILL.md. Expand the Details under each discipline for a one-line purpose per skill. Catalog order follows the four-layer strata — Narrative (L1 · Strategy) first, the five always-on channels next, Launch (L3 · Orchestration), then the Protocol layer.

Narrative — TALE (16) · 📖 Discipline guide

Four phase directories under narrative/ (4 skills each) follow the TALE loop (Trace → Architect → Land → Evaluate); the gate (⛩ narrative-quality-auditor) sits in Evaluate. It runs truth, system, and effectiveness profiles separately; a full review links three results and never averages them. Narrative is the L1 · Strategy layer: one brand voice the five always-on channels inherit. It absorbs positioning — positioning-mapper stays physically in launch/ but reads logically as the front of TALE Trace.

Reused cross-discipline (counted in their home phases, not duplicated): positioning-mapper (logically the front of Trace, physically in launch/), message-house-builder, audience-mapper, share-of-voice-tracker (resonance denominator). No new connector — narrative resonance reuses bluesky.py / gdelt.py / tavily.py / wayback.py — see tale-benchmark.md.

SEO/GEO — SITE (16) · 📖 Discipline guide

Four phase directories (4 skills each) plus the discipline's two quality gates (marked ⛩).