8gnc — Brand Growth Diagnostic

View saved version →

---
name: ai-agent-readiness
description: Execute the AI Agent-Readiness audit and sprint playbook (PLAY-004). Use when making a site usable by agentic browsers, AI shopping assistants, or chat-led SERPs. Triggers on "agent readiness," "agentic browser," "selector contract," "structured data parity," "feed completeness," "task URLs," "Playwright testing," "INP," "TBT," "modal friction," "agent readiness score," or when a client needs their site to work with AI-powered browsing agents. Includes audit checklists, 15-day sprint plan, selector contract specs, test harnesses, and scoring rubric.
---

# AI Agent-Readiness (PLAY-004)

Make sites usable by agentic browsers and chat-led SERPs. Browsers with embedded agents now navigate, click, and buy. Your site must be fast, scriptable, and machine-verifiable.

## Thesis

Winning shifts from discovery to action. Sites must be fast, scriptable, and machine-verifiable for agent task completion.

## When NOT to Use

- The site is mostly static and already crawlable with minimal JS. Agents can already read it — the audit will find little to fix.
- There are no transactional flows for agents to execute. No cart, booking, or forms means selector contracts and task URLs have nothing to point at.
- Traffic has no agent or AI-referral component yet AND the team can't act on the audit. A readiness report nobody implements is shelf-ware — wait until one of those changes.

## Offer Structure

### Starter Audit (72 hours)
- Agentability scan (CWV, JS cost, INP/TBT hotspots)
- DOM accessibility and selector stability review
- Structured data parity check vs feed
- Risk register and prioritized backlog

### 15-Day Agent Sprint
- Implement selector contract, schema, and deep links
- Kill top JS and modal blockers
- Ship Playwright tasks and Lighthouse CI
- Publish "Agent Readiness Report" with before/after

### Ongoing (Monthly)
- RUM (Real User Monitoring — field data from actual visitors, vs. synthetic lab tests) monitoring of LCP/INP/CLS and funnel KPIs
- Schema/Feed parity watchlist and Merchant Center QA
- Governance reviews and regression tests

## Audit Checklist (72 Hours)

### Performance & JS Cost
- INP under threshold sitewide
- TBT on PDP and cart under 200ms in lab
- Long tasks identified and split
- Third parties deferred or removed

### DOM, Accessibility, and Selectors
- All controls have role + accessible name
- No randomized IDs or hash-classes on key controls
- Stable `data-qa` attributes on critical elements
- Consent and promo modals dismissible via keyboard and labeled buttons

### Structured Data Sanity
- `WebSite` → `SearchAction` with `EntryPoint.urlTemplate`
- `Product` with `Offer` or `AggregateOffer`
- `OfferShippingDetails` with `ShippingDeliveryTime` where relevant
- Variant modeling verified

### Marketplace Parity
- Feed vs page vs JSON-LD values match for price, availability, condition
- Automatic Item Updates policy documented
- Shipping settings mirrored in both Merchant Center and JSON-LD

### Flow Reliability
- Steps to checkout minimized
- Task URLs documented for common intents
- Prefilled cart links available for top 3 bundles

## Implementation Sprint (15 Days)

**Days 1–3: Instrument and expose** — Ship JSON-LD on PDPs and list pages. Add `WebSite` → `SearchAction`. Add accessible names to top 20 controls. Turn on RUM for CWV + custom funnel events.

**Days 4–7: Kill the blockers** — Split bundles, defer third parties, remove dead widgets. Make consent and promo modals visible and dismissible. Stabilize selectors.

**Days 8–10: Task paths and deep links** — Publish "task URLs" to filtered results (in-stock, price caps, sizes). Create prefilled cart links for top configurations. Document in a private Agent Notes page.

**Days 11–15: Trials and proof** — Run 10 Playwright tasks that mimic agents. Record success rate and time-to-cart. Repeat in Atlas and AI-Mode browsers. Publish Agent Readiness Report.

## Selector Contract

- Prefer **role** and **name** selec

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: ai-focus-group
description: Simulate a focus group of audience archetypes to test marketing creative, messaging, and brand assets. Use when the user wants audience feedback, creative testing, or message validation without real user research. Triggers on "focus group," "audience feedback," "test this creative," "what would they think," "simulate audience," "creative testing," "message testing," "would this resonate," "audience reaction," or any request to pressure-test copy, design, headlines, taglines, brand names, or campaign concepts against a defined audience. Pairs well with brand strategy and creative direction skills for richer audience profiles and psychological response frameworks. Outputs can feed into brand audits as message-testing evidence.
---

# AI Focus Group — Simulated Audience Testing Protocol

Simulate a panel of 5–7 audience archetypes to generate structured reactions to any marketing creative — copy, design, headlines, landing pages, emails, social posts, taglines, brand names, or campaign concepts. The model constructs each panelist from a defined demographic and psychographic profile and voices them distinctly. Label every result as synthetic; this is not real user research.

## When You Receive a Request

Before running the panel, resolve these variables. Ask for any that are missing and cannot be inferred from context.

| Variable | What to Capture | Default |
|----------|----------------|---------|
| `creative_asset` | The thing being tested — copy, headline, visual description, concept | *required* |
| `asset_type` | Tagline / headline / landing page / email / social post / ad / brand name / concept | *infer if obvious* |
| `target_audience` | Who this creative is meant to reach | *required* |
| `panel_size` | Number of panelists | 5–7 |
| `custom_archetypes` | Any specific panelist types the user wants on the panel | Use standard archetypes if not provided |
| `brand_context` | Brand, product, or campaign this creative belongs to | *ask if not provided* |
| `success_criteria` | What would make this creative succeed (click, purchase, share, recall) | *infer from asset type* |

---

## The Simulated Focus Group Protocol

Execute all five stages in order. Do not skip synthesis or recommendations even if the panel reaction seems obvious.

---

### Stage 1 — Define the Panel

Build a panel of 5–7 archetypes tailored to the target audience. Each panelist gets a name, a one-line profile, and a behavioral stance toward the category.

**Standard Archetype Library** (customize or swap based on audience):

| Archetype | Who They Are | Behavioral Stance |
|-----------|-------------|-------------------|
| The Skeptic | Has been burned before. Distrusts claims. Reads the fine print. | Challenges everything. Needs proof before belief. |
| The Enthusiast | Already bought in. Loves the category. Shares with their circle. | Emotionally open. Amplifier if won, irrelevant if not targeted. |
| The Budget-Conscious | Every dollar is a decision. Value-to-cost ratio is the filter. | Converts on clarity and proof, drops off at vague pricing. |
| The Brand-Loyal | Already has a preference. This brand has to earn a switch. | Compares everything to the incumbent. Skeptical of newcomers. |
| The First-Timer | No prior experience in the category. Learning vocabulary. | Converts on simplicity and trust signals. Confused by jargon. |
| The Influencer | Thinks in shareable moments. Considers how this looks to their audience. | Buys aesthetics and story as much as utility. |
| The Decision-Maker | Holds budget authority. Evaluates ROI, risk, and operational fit. | Short attention. Wants the business case fast. |

**Panel Definition Output Format:**

```
PANEL: [Brand/Campaign Name] Focus Group
Target Audience: [description]
Panel Size: [n]

Panelists:
1. [Name], [Age/Context] — [Archetype] — [One-sentence behavioral profile]
2. [Name], [Age/Context] — [Archetype] — [One-sentence behavioral profile]
...
```

Make each panel

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: ai-visibility-tracking
description: >-
  Use when the user wants to know who the AI engines cite — brand mentions and
  citations inside Google AI Overviews and ChatGPT answers, AI search volume for
  a query set, or a competitor comparison of AI-answer presence. Triggers on
  "who does ChatGPT cite," "AI mentions," "LLM citations," "AI visibility,"
  "are we showing up in AI Overviews," "AI share of voice," "track our brand in
  AI answers," or any AEO/GEO measurement task. Wraps the DataForSEO LLM
  Mentions API through the shared dataforseo client.
---

# AI Visibility Tracking — LLM Mentions Operational Guide

The question every operator is starting to ask: *when an AI answers my customer's
question, am I in the answer?* This skill measures it. It pulls citation data from
Google AI Overviews and ChatGPT responses — which domains get cited, for which
questions, at what AI search volume — and turns it into a baseline, a competitor
comparison, and a monthly tracking cadence.

## File locations (read this first)

Use the same execution boundary as the `dataforseo` skill; the client is shared:

| Context | Client | Working dir | User-facing output |
|---|---|---|---|
| Codex with local shell access | Resolve the installed `dataforseo/scripts/dataforseo_client.py` | current workspace | `./ai-visibility-results/YYYYMMDD/` or another user-approved path |
| ChatGPT or a surface without local shell access | No direct API execution in this skills-only release | conversation or supported file workspace | Analyze user-supplied exports or return the exact data request; never fabricate live measurements |

Credentials load exactly as documented in the `dataforseo` skill. No separate setup.

## When NOT to Use

- No DataForSEO account. Same rule as the dataforseo skill — every call bills.
- The brand has near-zero web presence. If classic SERPs don't know you, AI engines
  won't either — run the dataforseo skill's keyword/backlink work and the
  ai-agent-readiness audit first; come back to measure once there's something to cite.
- You want to *manipulate* AI answers. This skill measures; the defense/offense
  content moves live in your strategy work, not in the measurement.

## Cost discipline — read this before the first call

`llm_mentions/*` endpoints are plain pay-per-call like the rest of the
toolkit — DataForSEO removed its former $100/month minimum top-up on these
endpoints in July 2026. Just fund the account (credits never expire, spend on
any of their APIs).

Pricing snapshot (2026-07). Verify the current official DataForSEO pricing before any paid call; do not rely on this table as a live quote:

| Endpoint | Cost | Use for |
|---|---|---|
| `ai_keyword_data/keywords_search_volume/live` | $0.01/task | AI search volume per keyword — the cheap step-0 wide pass (no subscription) |
| `llm_responses/live` | $0.0006/task | Ask a model the actual question, see the answer — spot checks (no subscription) |
| `llm_mentions/aggregated_metrics/live` | $0.10/task + $0.001/row | Citation counts + AI volume per domain |
| `llm_mentions/cross_aggregated_metrics/live` | $0.10/task + $0.001/row | You vs. competitors, side by side, one call |
| `llm_mentions/search/live` | $0.10/task + $0.001/row | Full AI response text + per-citation sources |
| `llm_mentions/top_domains/live` | $0.10/task + $0.001/row | Who dominates AI citations in your space |
| `llm_mentions/top_pages/live` | $0.10/task + $0.001/row | The exact PAGES earning citations — teardown targets |

A full baseline (you + 4 competitors, cross-aggregated, both platforms) runs
$1–3 depending on rows. Coverage: `platform: "google"` = AI Overviews;
`platform: "chat_gpt"` = ChatGPT, **United States location only** per DataForSEO.

## Client methods

```python
client.ai_llm_mentions_aggregated(
    targets=[{"domain": "yourbrand.com", "search_scope": ["sources"]}],
    platform="google",            # or "chat_gpt"
    location_name="United States",
)
# → mentions count, sources_dom

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: brandprint-engine-guide
description: Use when starting a new Brandprint engagement, when a user needs instructions on how to use the skill package, or when the user asks "how do I run Brandprint," "what order do I use these skills," or "where do I start" with the Brand Strategy Engine. Orientation skill for the six-layer Brandprint chain and its two-pass workflow.
---

# Brandprint Engine — Runner Guide

This guide walks through the complete Brandprint Engine workflow and produces a structured Brand Strategy and Competitive Positioning Report.

## When NOT to Use

- **Running an individual layer.** Invoke that layer's skill directly (`core-human-truth`, `brandprint-tier-a`, etc.) — this guide orients and sequences, it doesn't execute.
- **As a substitute for the layer skills.** The workflows, gates, and output schemas live in each layer's SKILL.md. This file tells you the order and the prompts, nothing more.

## What You Get

The Brandprint Engine is a chain of 6 skills that run in sequence. Each layer feeds the next:

```
Layer 1: Core Human Truth ─── foundational insight (1 sentence)
    │
    ▼
Layer 2: Brandprint Tier-A ── 10 strategy elements with evidence
    │
    ▼
Layer 3: Brandprint Tier-B ── 5 actionable elements with proxy tests
    │
    ▼
Layer 4: Brandprint Tier-C ── 4 stylistic elements ready to deploy
    │
    ▼
Layer 5: Competitive Audit ── validates differentiation vs. competitors
    │
    ├── If REFINE → re-run Layers 1-4 with competitive context (second pass)
    │
    └── If PROCEED ──▼
                      │
Layer 6: Report Compiler ─── 25-35 page consulting-grade deliverable
```

## How to Run It

Run the layer-by-layer chain below. In Codex with local file access, save each layer's JSON to a user-approved workspace directory such as `.8gnc/brandprint/{slug}/`. In ChatGPT without local file access, return each artifact in the conversation or as a downloadable file and ask the user to preserve it before the next layer.

This OpenAI package does not include the legacy provider-specific slash-command pipeline or its hooks. Do not refer users to those commands from this bundle.

## Prerequisites

- An installed 8gnc plugin in ChatGPT or Codex
- Current web research access for evidence-dependent layers
- **Python 3.9+** for optional local validation helpers in Codex
- **Optional:** weasyprint (`pip install weasyprint`) for PDF output
- **Optional:** [search-cli](https://github.com/199-biotechnologies/search-cli) for enhanced multi-provider search on local execution surfaces

## Installation Check

This guide is installed as part of the `8gnc` plugin. Ask the model to list the available Brandprint skills. Confirm that `deep-research`, the six strategy layers, this guide, `brand-revival`, and `competitive-teardown` are available before starting the full chain.

---

## The Two-Pass Workflow

This is the most important thing to understand. **The Brandprint Engine is designed to run twice.**

### First Pass (Layers 1-4): Raw Positioning

The first pass builds positioning from the brand's own tensions, evidence, and market reality. It produces good output — but it hasn't been tested against competitors yet.

### The Competitive Gate (Layer 5): Reality Check

Layer 5 takes the first-pass outputs and stress-tests them against named competitors. It answers the question: "If a buyer saw our positioning next to [competitor], could they tell us apart in 10 seconds?"

Two outcomes:
- **PROCEED** — Your positioning is differentiated. Move to Layer 6.
- **REFINE** — Your positioning collides with a competitor. Re-run Layers 1-4 with the competitive context baked in.

### Second Pass (Layers 1-4 again): Sharp Positioning

The second pass is where the magic happens. Now the skills have competitive context as a constraint — they know which territories are occupied, which claims collide, and where open space exists. The output is dramatically sharper.

**Example from a real engagement:**
- First pass produced: "W

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: brandprint-tier-a
description: Use when the user asks for a Brandprint, brand strategy research, Tier-A elements, brand architecture, competitive analysis paired with brand positioning, equity ladder, signature offers mapping, economic engine modeling, or any comprehensive brand strategy deliverable — Layer 2 of the Brandprint research stack. Also trigger on "run Tier-A," "brandprint research," "full brand audit," "brand sprint," or when the user wants audience segments, JTBD outcomes, competitive set, and positioning in one pass. Use immediately when the core-human-truth skill has just completed — chain directly using its output as the seed.
---

# Brandprint Tier-A — Hybrid Research Directive

Deliver all 10 Tier-A Brandprint elements using a hybrid method: build a shared evidence Backbone first, then run independent, falsifiable sprints per element — each with its own proofs and claim sheets.

## When NOT to Use

- **You only need quick positioning or stylistic outputs.** Tier-C requires Tier-A and Tier-B as seeds — there is no shortcut to a mantra. Run the full chain, or run this skill in `rapid` mode to lighten the load.
- **No access to real market evidence.** Every sprint gates on ≥3 independent sources or behavioral signals. Without reviews, search data, and competitor materials to mine, the claims can't clear the gates.
- **Validating existing positioning against competitors.** That's an adversarial test, not a build — use `competitive-positioning-audit` (Layer 5).

## Chain Position

This is **Layer 2** of a 6-layer Brandprint research stack:

1. **Core Human Truth** (Layer 1) → foundational truth sentence, tension map, archetypes, lexicon
2. **Brandprint Tier-A** (this skill) → uses Layer 1 output as seed; produces 10 defensible brand strategy elements
3. **Brandprint Tier-B** (Layer 3) → uses Tier-A output as seed; produces 5 actionable brand elements with proxy tests
4. **Brandprint Tier-C** (Layer 4) → uses Tier-A + Tier-B output as seeds; produces 4 stylistic elements ready for deployment
5. **Competitive Positioning Audit** (Layer 5) → validates differentiation against named competitors; may trigger second-pass refinement
6. **Brand Strategy Report** (Layer 6) → compiles all layers into consulting-grade deliverable

**When Layer 1 has just completed:** Import its output directly. The `final_sentence`, `tension_map`, `archetypes`, and `lexicon` from Core Human Truth seed the Backbone phase — do not re-research what Layer 1 already validated. Carry forward its sources into the Backbone bibliography.

**When running standalone:** Resolve all variables with the user and build the Backbone from scratch.

## Variables to Resolve

Before starting, confirm these with the user (or inherit from Layer 1):

| Variable | What to Capture | Default |
|----------|----------------|---------|
| `brand_name` | The brand being researched | *required* |
| `topic` | Product, service, or subject | *required* |
| `category` | Industry or category | *required* |
| `audience` | Primary audience definition | *required* (or from Layer 1) |
| `region_context` | Geography or cultural context | US / English-speaking |
| `constraints` | Scope, legal, or brand constraints | None |
| `mode` | `rapid`, `standard`, or `enterprise` | `standard` |

## Principles (Non-Negotiable)

1. **Truth over consensus.** Triangulate across independent sources; show counter-evidence.
2. **Each sprint is a separate claim** with its own acceptance gates and proof minimums.
3. **No fabrication.** If unknown, mark unknown. Quote sparsely; summarize faithfully.
4. **Plain language.** Prioritize verifiable behaviors over vibes.
5. **Log contradictions** between sprints; resolve or bound them.

## Evidence & Citation Policy

For every public claim, include: title, publisher, author (if available), URL, publish date, access date, one-line evidence note, and stance (`supporting` | `conflicting` | `neutral`).

## Global Acceptance Gates

Every Tier-A sprint must

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: brandprint-tier-b
description: Use when the user asks for Tier-B brand elements — brand activator, brand platform word, tone and manner guidelines, moat statement, brand no-no's, brand guardrails, brand voice, or brand behavior testing — Layer 3 of the Brandprint research stack. Also trigger on "run Tier-B," "brand activation," "brand tone," "competitive moat," "brand rules," or when the user wants practical, testable brand outputs derived from existing strategy research. Use immediately when the brandprint-tier-a skill has just completed — chain directly using its output as the seed.
---

# Brandprint Tier-B — Activation & Guardrails Directive

Deliver 5 Tier-B brand elements that are practical, testable, and aligned to validated Tier-A truths. Evidence is lightweight but real. Every element gets at least one behavioral proxy signal.

## When NOT to Use

- **No Tier-A output exists.** Tier-B derives, it doesn't originate. Run `brandprint-tier-a` first — standalone mode here produces reduced-confidence output and says so in the audit log.
- **Full visual identity or design systems.** Tone, platform word, and guardrails are verbal/behavioral elements. Logos, palettes, and type systems are design work outside this chain.
- **Testing positioning against competitors.** Tier-B checks alignment with Tier-A, not differentiation in market — that's `competitive-positioning-audit` (Layer 5).

## Chain Position

This is **Layer 3** of a 6-layer Brandprint research stack:

1. **Core Human Truth** (Layer 1) → foundational truth sentence, tension map, archetypes, lexicon
2. **Brandprint Tier-A** (Layer 2) → 10 defensible brand strategy elements with evidence-gated sprints
3. **Brandprint Tier-B** (this skill) → uses Layer 2 output as seed; produces 5 actionable brand elements with proxy tests
4. **Brandprint Tier-C** (Layer 4) → uses Tier-A + Tier-B output as seeds; produces 4 stylistic elements ready for deployment
5. **Competitive Positioning Audit** (Layer 5) → validates differentiation against named competitors; may trigger second-pass refinement
6. **Brand Strategy Report** (Layer 6) → compiles all layers into consulting-grade deliverable

**When Layer 2 has just completed:** Import its full output JSON directly. Pull Tier-A anchors — tensions, outcomes, audience, equity ladder, competition, tagline, moat signals — into the Intake phase. Do not re-research what Layers 1–2 already validated. Carry forward all sources and the contradiction matrix.

**When running standalone:** Resolve all variables with the user. If no Tier-A backbone exists, build a lightweight Backbone Tap from scratch using desk research, but note reduced confidence in the audit log.

## Variables to Resolve

Before starting, confirm these with the user (or inherit from Layers 1–2):

| Variable | What to Capture | Default |
|----------|----------------|---------|
| `brand_name` | The brand being researched | *required* |
| `topic` | Product, service, or subject | *required* |
| `category` | Industry or category | *required* |
| `audience` | Primary audience definition | *required* (or from Layer 2) |
| `region_context` | Geography or cultural context | US / English-speaking |
| `constraints` | Scope, legal, brand safety, cultural sensitivities | None |
| `languages` | Output language | English |
| `timeline_days` | Suggested execution window | 7–21 days |
| `mode` | `rapid`, `standard`, or `enterprise` | `standard` |
| `backbone_source` | Link or reference to Tier-A backbone repository | From Layer 2 if chained |

## Principles (Non-Negotiable)

1. **Evidence-informed, not evidence-bloated.** Two independent sources or one source + a behavioral proxy per claim.
2. **Mirror the audience's words.** Reduce adjectives. Show behaviors.
3. **Test the smallest possible thing:** five-second comprehension, recall ping, micro-click, or completion rate.
4. **If an output conflicts with Tier-A,** either revise or state boundary conditions.
5. **No fabrication.** If data

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: brandprint-tier-c
description: Use when the user asks for Tier-C brand elements — brand mantra, brand personification, translation line, features-to-benefits mapping, brand style elements, brand personality vignette, or brand copy finalization — Layer 4 of the Brandprint research stack. Also trigger on "run Tier-C," "brand mantra," "brand personality," "header line," "features list," or when the user wants ready-to-deploy brand style outputs derived from existing strategy. Use immediately when the brandprint-tier-b skill has just completed — chain directly using its output as the seed.
---

# Brandprint Tier-C — Style & Deployment Directive

Deliver 4 Tier-C brand elements that are stylistic, derivative, and ready to deploy. These outputs create no new claims. Every line traces back to validated Tier-A and Tier-B truths.

## When NOT to Use

- **Tier-A or Tier-B output is missing.** This layer needs both as anchors. Without them, either collect equivalent inputs from the user or run the chain from Layer 1 — don't improvise anchors.
- **Creating new claims or strategy.** Tier-C styles what Layers 1-3 validated. If the brand needs a new benefit, proof, or position, that's a Tier-A sprint, not a Tier-C edit.
- **Long-form copywriting.** Mantra, vignette, translation line, features list — that's the full scope. Web pages, campaigns, and articles are downstream deployment work.

## Chain Position

This is **Layer 4** of a 6-layer Brandprint research stack:

1. **Core Human Truth** (Layer 1) → foundational truth sentence, tension map, archetypes, lexicon
2. **Brandprint Tier-A** (Layer 2) → 10 defensible brand strategy elements with evidence-gated sprints
3. **Brandprint Tier-B** (Layer 3) → 5 actionable brand elements with proxy tests (activator, platform word, tone, moat, no-no's)
4. **Brandprint Tier-C** (this skill) → uses Tier-A + Tier-B output as seeds; produces 4 stylistic elements ready for team handoff
5. **Competitive Positioning Audit** (Layer 5) → validates differentiation against named competitors; may trigger second-pass refinement
6. **Brand Strategy Report** (Layer 6) → compiles all layers into consulting-grade deliverable

**When Layer 3 has just completed:** Import the full Tier-B output JSON and the Tier-A JSON carried forward. Pull anchors — tensions, outcomes, equity ladder, tagline from Tier-A; tone, key phrases, platform word, no-no rules from Tier-B. Do not create new claims or re-research.

**When running standalone:** Resolve all variables with the user. If no Tier-A/B anchors exist, ask the user to provide equivalent inputs (tensions, outcomes, tone adjectives, platform word, equity ladder) or recommend running the full chain first.

## Variables to Resolve

Before starting, confirm these with the user (or inherit from Layers 1–3):

| Variable | What to Capture | Default |
|----------|----------------|---------|
| `brand_name` | The brand being styled | *required* |
| `topic` | Product, service, or subject | *required* |
| `category` | Industry or category | *required* |
| `audience` | Primary audience definition | *required* (or from Layer 2) |
| `region_context` | Geography or cultural context | US / English-speaking |
| `constraints` | Legal, brand safety, cultural constraints | None |
| `languages` | Output language | English |
| `timeline_days` | Suggested execution window | 3–10 days |
| `mode` | `rapid`, `standard`, or `enterprise` | `standard` |
| `tierA_anchor_ref` | Link or ID for Tier-A output | From Layer 2 if chained |
| `tierB_anchor_ref` | Link or ID for Tier-B output | From Layer 3 if chained |

## Principles (Non-Negotiable)

1. **Alignment first.** Every line must trace to Tier-A tensions, outcomes, and equity ladder, and Tier-B tone and platform.
2. **Clarity over clever.** Sixth-grade readability. Zero jargon.
3. **Cultural hygiene.** Avoid stereotypes. Prefer inclusive, specific language.
4. **No new promises.** If text implies a claim, link it to an existing proof or reword 

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: brand-revival
description: Use when a brand is stale, broken, or invisible and needs resurrection, repositioning, or reinvention after losing cultural relevance. Triggers on "stale brand," "brand revival," "rebrand," "brand refresh," "legacy brand," "brand turnaround," "partnership strategy," "brand resurrection," "brand has lost relevance," "nobody cares about this brand anymore," "brand went quiet," "how do we bring this back," or when a client has a brand with dormant equity that needs reactivation.
---

# Brand Revival Playbook

Dead brands are not dead. They are dormant. The difference is audience memory. If people remember the brand — even to say "what happened to them?" — there is equity. The revival question is never "do we start over?" It is "what still has heat, and what do we ignite it with?"

The mistake brands make: they try to remind everyone who they were. The move: find partners and moments that make people discover who they are now.

## When NOT to Use

- **Healthy brands needing a routine refresh.** Revival methodology assumes lost relevance. A working brand that wants sharper positioning runs the Brandprint chain, not a resurrection.
- **Brand-new brands with no dormant equity.** Nothing to revive — no audience memory means no assets to reignite. Run the Brandprint chain (`core-human-truth` onward) and build fame first.
- **Leadership has no appetite for visible change.** Every phase here — partners, drops, new creative authority — is public and disruptive. If the mandate is "bring it back but change nothing," decline the framework.

## When You Receive a Request

Before running the framework, resolve these variables. If any are missing, ask.

| Variable | What to Capture | Default |
|----------|----------------|---------|
| `brand_name` | The brand being revived | *required* |
| `category` | Industry, vertical, or product category | *required* |
| `original_audience` | Who the brand built for originally | *ask if unclear* |
| `current_audience` | Who, if anyone, still engages today | *research if not provided* |
| `dormancy_window` | How long since peak relevance | *required* |
| `assets_available` | Name, IP, distribution, physical locations, archive | *inventory together* |
| `revival_budget_tier` | Scrappy ($0-50K) / Moderate ($50-250K) / Full ($250K+) | *ask* |
| `target_outcome` | Awareness play, revenue reactivation, acquisition prep, or brand sale | *required* |

## Phase 0 — Triage Diagnostic

Before any strategy, determine what kind of brand problem this actually is. Each type has a different revival path.

### The Three Brand Failure Modes

**Stale (Irrelevant)**
The brand still exists but stopped being interesting. No dramatic incident — just drift. Culture moved and the brand did not follow. Signs: declining search trends, aging audience, competitors copying old positioning, leadership referencing past campaigns as proof of relevance.

Revival path: Cultural re-entry through partners and drops. Authenticity bridge over legacy team.

**Broken (Damaged)**
Something happened. A PR incident, a founder scandal, a product failure, a betrayal of audience trust. People remember — but not the way you want. Residual brand awareness is poisoned. Signs: brand name appears consistently in negative contexts, social mentions skew negative, press coverage is incident-specific, earned media has stalled.

Revival path: Reset through distance and proof. New chapter framing, not apology campaigns. Partner with parties who carry credibility the brand forfeited.

**Invisible (Never Had Presence)**
The brand was never truly known. It existed commercially but never built cultural mass. No nostalgia, no community, no iconic moment. Signs: low unaided awareness, clean social sentiment (because no one cares enough to be negative), minimal organic search volume, founder-as-entire-personality.

Revival path: Fame-first, not revival. This skill is for brands with dormant equity, not brands without any. Invisible br

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: brand-strategy-compiler
description: Use when all Brandprint layers (Core Human Truth through Competitive Audit) are complete and the user needs the final client-ready deliverable — Layer 6 of the Brandprint research stack. Trigger when the user asks to compile the Brandprint into a final report, create a client deliverable, generate a strategy document, or produce a consulting-grade brand report. Also trigger on "compile report," "final deliverable," "client report," "strategy document," "consulting report." If the competitive-positioning-audit skill has just completed with a PROCEED decision, move directly into this skill.
---

# Brand Strategy Report Compiler — Consulting-Grade Deliverable Directive

Assemble all Brandprint outputs (Layers 1-5) into a single, cohesive Brand Strategy & Competitive Positioning Report formatted to the standard of top-tier strategy consultancies (Strategy&, EY-Parthenon, Monitor Deloitte, KPMG Strategy).

## When NOT to Use

- **Layers are incomplete.** Layers 1-4 outputs are required inputs. Layer 5 is strongly recommended; if it's missing, the report must disclose that competitive validation was not performed and recommend it — don't compile silently around the gap.
- **Generating new strategy content.** This layer synthesizes what Layers 1-5 produced. If a section needs claims or evidence that don't exist upstream, run the missing layer — don't write it here.
- **Quick one-page summaries.** The floor is 15-20 pages in rapid mode. For a brief, pull the executive summary structure manually instead of invoking the compiler.

## Why This Layer Exists

Layers 1-4 produce structured JSON outputs optimized for machines and chain-forward processing. Layer 5 produces a competitive analysis. None of these are client-ready. This layer transforms raw strategic outputs into a narrative document that leadership teams, boards, and investors can act on.

The report is not a summary — it is a synthesis. It resolves contradictions, builds arguments across layers, adds market context, models financial impact, and provides a phased implementation roadmap. It connects the "what" (positioning elements) to the "why" (evidence) to the "how" (implementation) to the "when" (roadmap).

## Chain Position

This is **Layer 6** — the terminal layer of the Brandprint research stack:

1. **Core Human Truth** (Layer 1) → foundational truth sentence
2. **Brandprint Tier-A** (Layer 2) → 10 strategy elements
3. **Brandprint Tier-B** (Layer 3) → 5 actionable elements
4. **Brandprint Tier-C** (Layer 4) → 4 stylistic elements
5. **Competitive Positioning Audit** (Layer 5) → differentiation validation
6. **Brand Strategy Report** (this skill) → consulting-grade deliverable

**Required inputs:** At minimum, Layers 1-4 outputs. Layer 5 (Competitive Audit) is strongly recommended. If Layer 5 is missing, the report will note that competitive validation was not performed and recommend it.

## Variables to Resolve

| Variable | What to Capture | Default |
|----------|----------------|---------|
| `brand_name` | The brand | *required* |
| `client_name` | Who receives the report (may differ from brand) | brand_name |
| `prepared_by` | Firm name for the cover page | *required* |
| `report_date` | Date for the cover page | Current month/year |
| `confidentiality` | Confidential / Internal / Public | Confidential |
| `include_financials` | Include economic engine and financial modeling sections | true |
| `include_roadmap` | Include implementation roadmap | true |
| `format` | `narrative` (long-form) or `deck` (slide-style with exhibits) | `narrative` |
| `layer_outputs` | JSON outputs from Layers 1-5 | *required* |

## Principles (Non-Negotiable)

1. **Synthesis over summary.** Do not paste layer outputs verbatim. Transform them into a coherent strategic narrative where each section builds on the previous one.
2. **Every claim traces to evidence.** If a claim appeared in Layers 1-5 with sources, those sources appear in the report. 

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: competitive-positioning-audit
description: Use when the user wants to validate positioning against named competitors, test differentiation, run a competitive audit, check for brand collision, or stress-test a Brandprint against real market players — Layer 5 of the Brandprint research stack. Also trigger on "competitive audit," "positioning vulnerability," "differentiation test," "collision check," "are we different enough," or when the user pastes competitor copy and asks whether their brand stands apart. Recommend this skill when brandprint-tier-c has just completed, before compiling the final report.
---

# Competitive Positioning Audit — Vulnerability & Differentiation Directive

Systematically test whether a brand's Brandprint positioning is actually differentiated from named competitors, or whether it reads as "semantic neighbor" — similar enough that buyers can't tell the difference.

## When NOT to Use

- **Fewer than 3 named competitors.** The audit runs on 1, but the collision matrix gets thin and territory ownership becomes guesswork. Identify 3-5 real players first (Tier-A Sprint 4 provides them).
- **No positioning exists yet.** There's nothing to audit. Run Layers 1-4 first — this layer tests claims, it doesn't create them.
- **Category-level white-space analysis.** Finding what the whole category is missing is `competitive-teardown`. This skill tests one brand's claims against named competitors.

## Why This Layer Exists

The first pass of Layers 1-4 produces positioning built from the brand's own tensions and evidence. But positioning doesn't exist in isolation — it exists relative to competitors. This layer pressure-tests whether the Brandprint outputs survive contact with real competitor messaging.

**The pattern this skill catches:** A brand runs the full Brandprint chain, produces strong outputs — then discovers their tagline, platform word, or mantra collides with an entrenched competitor. The ESOP story that felt unique turns out to overlap with a competitor's "family culture" narrative. The geographic claim that felt ownable is already owned by someone with 5x the revenue. This skill catches those collisions before they ship.

## Chain Position

This is **Layer 5** of the Brandprint research stack:

1. **Core Human Truth** (Layer 1) → foundational truth sentence
2. **Brandprint Tier-A** (Layer 2) → 10 strategy elements
3. **Brandprint Tier-B** (Layer 3) → 5 actionable elements
4. **Brandprint Tier-C** (Layer 4) → 4 stylistic elements
5. **Competitive Positioning Audit** (this skill) → validates differentiation; triggers refinement if needed
6. **Brand Strategy Report** (Layer 6) → compiles all layers into consulting-grade deliverable

**When Layer 4 has just completed:** Import all Tier-A, B, and C outputs. Run the full audit against the competitive landscape already identified in Tier-A Sprint 4, plus any additional competitors the user names.

**When running standalone:** Resolve all variables with the user. Requires at minimum: the brand's current positioning claims (tagline, platform word, key messages) and at least one named competitor to test against.

**After this skill completes:** If vulnerability scores are LOW (positioning is differentiated), proceed to Layer 6 (Report Compiler). If vulnerability scores are HIGH (positioning collides), recommend a **second-pass refinement** — re-running Layers 1-4 with the audit findings as additional context. The second pass typically produces dramatically sharper positioning.

## Variables to Resolve

| Variable | What to Capture | Default |
|----------|----------------|---------|
| `brand_name` | The brand being audited | *required* |
| `brand_claims` | Current tagline, platform word, key messages, mantra | *required* (or from Layers 1-4) |
| `competitors` | Named competitors to test against (min 1, ideally 3-5) | *required* |
| `competitor_sources` | URLs, copy, or descriptions of competitor positioning | User provides or research |
| `category` |

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: competitive-teardown
description: >-
  Use when the goal is category-level disruption analysis: finding structural
  gaps and white space across an entire category or platform, not brand-vs-brand
  positioning comparison. Triggers on "teardown," "competitive analysis,"
  "SCAMPER analysis," "platform analysis," "gap analysis," "what are competitors
  missing," "find the white space," "category disruption," "what's unoccupied,"
  or "where's the open quadrant." This is structurally different from
  competitive-positioning-audit, which tests one brand's claims against named
  competitors, and from general SCAMPER ideation, which treats a single item.
---

# Competitive Teardown — Category SCAMPER Protocol

Reveal structural gaps in a category by mapping all major players into a feature/value matrix, running SCAMPER across the entire matrix (not on a single brand), identifying what no one is doing, and building concepts that exploit those empty quadrants.

## When NOT to Use

- **Brand-vs-brand positioning validation.** Testing one brand's claims against named competitors is `competitive-positioning-audit`. This skill's unit of analysis is the category matrix, not a brand.
- **Single-item ideation.** Applying SCAMPER to one product or campaign is general creative ideation — no matrix required.
- **Fewer than ~5 meaningful players in the category.** With 2-3 players there are no convergence clusters to read; shared assumptions can't be distinguished from coincidence.

## Why This Skill Exists

Standard competitive analysis asks: "How are we different from competitors?" That question assumes the right category exists and the right dimensions of differentiation are already visible. It produces incremental positioning.

This skill asks a different question: "What is the entire category structurally incapable of doing?" That question exposes the gaps baked into the category's shared assumptions — the white space that every player is simultaneously missing because they're all operating inside the same mental model.

The pattern: map the category matrix first, SCAMPER the matrix as a whole, find the structural absence, build into the absence.

**What this is not:**
- Not brand-vs-brand collision scoring — that's the competitive-positioning-audit
- Not single-item ideation with SCAMPER as one of ten methods — that's general creative ideation
- Not a vulnerability audit of existing positioning — that's the competitive-positioning-audit

This skill is category-level structural analysis. The output is opportunity concepts, not positioning refinements.

## Chain Position

This skill operates as a standalone research sprint OR feeds upstream/downstream within the Brandprint Engine:

**Upstream inputs:**
- Competitive Positioning Audit gap findings — teardown the gap further
- Brandprint Tier-A Sprint 4 (Competitive Landscape) — expand into full teardown

**Downstream outputs:**
- Competitive Positioning Audit — teardown findings replace or extend the Competitive Matrix
- Brand strategy layers — concepts from gap identification inform content strategy and positioning
- If a concept is chosen, validate its positioning differentiation before launch

## Variables to Resolve

Before starting, confirm these with the user or extract from prior skill outputs:

| Variable | What to Capture | Default |
|----------|----------------|---------|
| `category` | The category or platform being torn down | *required* |
| `client_name` | The brand or client using this analysis | *required* |
| `client_context` | What they do, what they're capable of, their resources/constraints | *required* |
| `players` | Named competitors to include (3-7 preferred) | User provides or research |
| `teardown_lens` | What angle to attack (features, pricing, audience, channel, business model, content, UX) | All lenses |
| `concept_count` | How many concepts to develop from gap findings | 2-3 |
| `mode` | `rapid`, `standard`, or `enterprise` | `standard` |
| `output_form

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: core-human-truth
description: Use when the user asks for a core human truth, brand truth, audience insight, consumer truth, foundational brand insight, or strategic brand research — Layer 1 of the Brandprint research stack and the entry point for any new brand engagement. Also trigger when requests mention "tension ladder," "truth sentence," "brand truth scaffolding," "audience truth," "what does my audience really believe," or any request to distill a brand or product down to one universal human insight. Even if the user just says "find the real truth behind why people buy X" or "what's the one thing my audience feels but can't say," use this skill.
---

# Core Human Truth — Deep Research Directive

Produce a single validated sentence (max 25 words) that captures the Core Human Truth for a given topic and audience. The sentence must pass tension, emotion, and agency checks, and be backed by triangulated evidence.

## When NOT to Use

- **Quick taglines or copywriting.** This skill runs a six-phase research pipeline. If the user wants a headline without evidence, write the copy directly — don't invoke this.
- **A validated truth already exists.** If the brand has a researched, evidence-backed truth sentence, skip to `brandprint-tier-a` and feed it in as the seed.
- **Non-brand research questions.** Market sizing, technology comparisons, or general analysis belong in `deep-research` — this skill only distills brand/audience truths.

## When You Receive a Request

Before doing anything else, resolve these variables with the user. If any are missing, ask.

| Variable | What to Capture | Default |
|----------|----------------|---------|
| `topic` | The brand, product, service, or subject | *required* |
| `audience` | Primary audience definition | *required* |
| `region_context` | Geography or cultural context | US / English-speaking |
| `constraints` | Scope limits, legal, or brand constraints | None |
| `mode` | `rapid`, `standard`, or `enterprise` | `standard` |

## Principles

These are non-negotiable throughout the entire process:

1. **Truth over consensus.** Cite, compare, and challenge sources.
2. **Show tension, emotion, and agency** in the final sentence.
3. **No jargon. Max 25 words.** Instantly understood by the audience.
4. **Never fabricate data, quotes, or attributions.** If unknown, mark unknown.
5. **Triangulate.** Prefer converging evidence across independent sources.
6. **Be explicit about uncertainty** and counter-evidence.
7. **Respect privacy.** Use only public, lawful sources.

## Reasoning Approach

Throughout every phase:

- Surface assumptions before starting. List them.
- Voice counter-arguments and plausible alternatives.
- Stress-test conclusions with red team checks.
- Reframe if a simpler or more powerful truth emerges.
- Keep internal working notes distinct from final deliverables.

## Workflow — Six Phases

Execute these phases in order. Each phase has a clear goal, actions, and outputs.

### Phase 0 — Orientation

**Goal:** Define the lens and success criteria before research begins.

Actions:
- Resolve all variables (topic, audience, region, constraints, mode)
- List explicit assumptions and open questions
- Define success criteria: max 25 words, no jargon, tension + emotion + agency, testable via proxy validation
- Set evidence thresholds and note any disallowed sources

Outputs: `lens_brief`, `success_criteria`, `assumptions_list`

### Phase 1 — Secondary Sourcing

**Goal:** Map existing knowledge and tensions.

Actions:
- Literature sweep across academic and industry sources for the topic and audience
- Trend and media scan across reputable news, trade publications, forums, and short-form platforms
- Data dig of longitudinal datasets where applicable
- Tag emergent tensions and paradoxes — build a first-pass thematic map

Outputs: `annotated_bibliography`, `thematic_map`, `data_summary`

**Mode adjustments:**
- *Rapid:* 8–12 qualitative artifacts, lighter desk research
- *Standard:* F

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: core-strategic-truth
description: Use when the user asks for a core strategic truth, product thesis seed, foundational market tension, the one constraint buyers can't escape, the forced trade-off at the center of a market, or a strategy foundation sentence. Also trigger when requests mention "market tension," "strategic tension," "product thesis," "foundational positioning," "what buyers are forced to choose between," "why buyers compromise," "the real constraint in this market," or any request to distill a product or platform down to the single trade-off that drives all buying decisions. Layer 1 of the Productprint research stack and the entry point for any new product strategy engagement. Even if the user just says "find the real reason buyers are stuck between X and Y" or "what's the one market problem no one has actually solved," use this skill.
---

# Core Strategic Truth — Deep Research Directive

Produce a single validated sentence (max 25 words) that captures the Core Strategic Truth for a given product and audience. The sentence must pass tension, stakes, and agency checks, and be backed by triangulated evidence.

## When NOT to Use

- **Quick positioning taglines or copywriting.** This skill runs a six-phase research pipeline. If the user wants a headline without evidence, write the copy directly — don't invoke this.
- **A validated strategic truth already exists.** If the product has a researched, evidence-backed truth sentence, skip to `productprint-tier-a` and feed it in as the seed.
- **Non-strategy research questions.** Market sizing, technology comparisons, or general analysis belong in `deep-research` — this skill only distills foundational product/market strategic truths.

## When You Receive a Request

Before doing anything else, resolve these variables with the user. If any are missing, ask.

| Variable | What to Capture | Default |
|----------|----------------|---------|
| `product_name` | The product, platform, service, or solution | *required* |
| `category` | The market category or domain it competes in | *required* |
| `audience` | Primary buyer/operator audience definition | *required* |
| `region_context` | Geography or cultural context | US / English-speaking |
| `constraints` | Scope limits, legal, or strategic constraints | None |
| `mode` | `rapid`, `standard`, or `enterprise` | `standard` |
| `evidence_mode` | `greenfield` or `existing-product` | `greenfield` |

## Principles

These are non-negotiable throughout the entire process:

1. **Truth over consensus.** Cite, compare, and challenge sources.
2. **Show tension, stakes, and agency** in the final sentence.
3. **No jargon. Max 25 words.** Instantly understood by the audience.
4. **Never fabricate data, quotes, or attributions.** If unknown, mark unknown.
5. **Triangulate.** Prefer converging evidence across independent sources.
6. **Be explicit about uncertainty** and counter-evidence.
7. **Respect privacy.** Use only public, lawful sources.

## Reasoning Approach

Throughout every phase:

- Surface assumptions before starting. List them.
- Voice counter-arguments and plausible alternatives.
- Stress-test conclusions with red team checks.
- Reframe if a simpler or more powerful truth emerges.
- Keep internal working notes distinct from final deliverables.

## Workflow — Six Phases

Execute these phases in order. Each phase has a clear goal, actions, and outputs.

### Phase 0 — Orientation

**Goal:** Define the lens and success criteria before research begins.

Actions:
- Resolve all variables (product_name, category, audience, region, constraints, mode, evidence_mode)
- List explicit assumptions and open questions
- Define success criteria: max 25 words, no jargon, tension + stakes + agency, testable via proxy validation
- Set evidence thresholds and note any disallowed sources
- **In `existing-product` mode:** ingest operator-supplied internal artifacts (roadmap docs, telemetry summaries, customer-interview notes, loss reasons) int

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: creative-thinking-ai
description: Apply the Mayhem Method to Creative Thinking with AI for structured ideation using 10 classic creativity frameworks as AI workflows. Use when running creative sprints, generating ideas at volume, or stress-testing concepts. Triggers on "SCAMPER," "Six Thinking Hats," "mind mapping," "brainstorming," "SWOT," "design thinking," "lotus blossom," "reverse brainstorming," "random word stimulation," "role storming," "creative sprint," "ideation," or when a team is stuck and needs structured divergent/convergent thinking.
---

# Creative Thinking with AI (Mayhem Method v1.0)

Turn classic creativity frameworks into practical AI workflows. Pick a method, feed a structured prompt, generate options, critique with a different method, consolidate and prototype.

## Core Loop

1. Pick a method that fits the job.
2. Feed AI a structured prompt pattern.
3. Generate 3–10 options per pass.
4. Critique with a different method to stress test.
5. Consolidate into a short list and prototype.

## Global Principles

- **Context in, quality out.** Give brand, audience, constraints, and success criteria.
- **One knob per pass.** Change a single variable between iterations.
- **Range before refinement.** Diverge wide, then converge with criteria.
- **Show your work.** Label which technique was used for each idea.
- **Bias checks.** Force at least one option that contradicts the default audience or channel.
- **Evidence lane.** If facts matter, require citations or mark outputs as speculative.

## When NOT to Use

- Not for production drafting — once a concept is picked, `mayhem-method-ai-use` handles structured AI-assisted production.
- Not for testing how an audience reacts — that's `ai-focus-group`.
- Not for narrative writing — story structure lives in `story-spine`.
- Not when the decision is already made — these methods generate and stress-test options; running them to justify a foregone conclusion wastes the room's time.

## The 10 Methods

### 1) SCAMPER
**Use when** you need many variations of an existing product, process, or message.
```
You are applying SCAMPER to {object}.
Constraints: {brand, audience, channel, limits}.
For each letter, output 3 ideas:
- S Substitute / C Combine / A Adapt / M Modify / P Put to another use / E Eliminate / R Reverse
End with a shortlist of 5 with rationale.
```
**Twists:** Add a cost band to each idea. Force 1 idea per letter that can ship within 48 hours.

### 2) Six Thinking Hats
**Use when** a team is stuck arguing about taste. You want structured angles.
```
We are evaluating {concept}.
Give 6 sections labeled by hat:
White facts, Red emotions, Black risks, Yellow benefits, Green creative alternatives, Blue process next steps.
Each section 3 bullets max, grounded in {data if any}.
```
**Twists:** Run the same input twice and compare where the hats disagree. Force one Green option that contradicts brand norms.

### 3) Mind Mapping
**Use when** you need a landscape fast.
```
Create a hierarchical outline mind map for {central topic}.
Depth 3 levels. Return as nested bullets and as JSON {id, label, parent_id}.
Tag each node with {opportunity|risk|unknown}.
```
**Twists:** Ask for an adjacency list for a diagram tool. Require 5 edge cases in an "unknown" cluster.

### 4) Brainstorming
**Use when** you want raw volume before filters.
```
Generate 30 ideas for {goal}.
Rules: no self-censoring, 12 words max per idea, no duplicates.
Label each with {safe bet|stretch|wild}.
End with 5 "bridge" ideas that combine a safe bet with a wild.
```
**Twists:** Time-boxed rounds: 10 ideas per minute with increasing constraints.

### 5) SWOT Analysis
**Use when** you need strategic alignment or stakeholder buy-in.
```
Create a SWOT for {initiative}. Use evidence where possible.
Each quadrant 5 bullets.
Then propose 3 TOWS strategies that pair internal with external factors.
```
**Twists:** Add a confidence score per bullet. Require one contrarian TOWS play.

### 6) Design Thinking

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: data-density-commerce
description: Apply the Instant Checkout & ACP data-density commerce checklist for product feed optimization. Use when preparing product feeds for AI-powered shopping, Google Merchant Center compliance, or agent-compatible checkout flows. Triggers on "feed completeness," "product feed," "ACP," "instant checkout," "delivery estimate," "return window," "answerability," "description depth," "merchant center," "feed parity," or when SKU data needs to be machine-readable and agent-actionable for natural-language shopping queries.
---

# Instant Checkout & ACP — Data-Density Commerce

Make products the only logical answer to natural-language asks by maxing out feed completeness and policy clarity. This is the commerce data layer that powers AI agent-readiness (PLAY-004).

## Goal

Products surface and convert in chat-led SERPs and agentic browsers because the data is complete, accurate, and machine-verifiable.

## When NOT to Use

- Digital-only products with no shipping or feed. Delivery estimates, Merchant Center, and feed parity don't apply.
- You don't control the product feed. Pure marketplace sellers (Amazon- or Etsy-only) can't change refresh cadence or field structure.
- The catalog is under ~10 SKUs. Manual checks beat building feed-completeness tooling at that scale.

## Readiness Checklist

### Feed Refresh
- [ ] Feed refresh ≤ 15 minutes for price and stock updates
- [ ] Price changes reflected in feed within one refresh cycle
- [ ] Stock status (in-stock, out-of-stock, preorder) accurate in real time

### Field Completeness
- [ ] Required + recommended fields ≥ 95% populated on top 20% SKUs
- [ ] All required Google Merchant Center fields present
- [ ] Optional fields (color, size, material, pattern) filled where applicable

### Description Depth
- [ ] 5,000-character descriptions structured as knowledge base
- [ ] Descriptions answer common buyer questions inline
- [ ] Structured sections: what it is, who it's for, specs, care/use, compatibility

### Delivery Promises
- [ ] `delivery_estimate` present on SKUs with fast shipping methods
- [ ] Handling time and transit time separated and accurate
- [ ] Shipping cost visible or calculable before checkout

### Returns Policy
- [ ] Returns: live URL published and accessible
- [ ] Explicit `return_window` (e.g., "30 days from delivery")
- [ ] Return conditions clearly stated (restocking fees, exclusions)

### Payment & Checkout
- [ ] ACP (Automated Checkout Process) endpoints respond correctly
- [ ] Cart totals math correct (subtotal + tax + shipping = total)
- [ ] Idempotent payment processing (no double charges on retry)
- [ ] Prefilled cart links functional for top configurations

### Parity
- [ ] Feed price = page price = JSON-LD price (no mismatches)
- [ ] Feed availability = page availability = JSON-LD availability
- [ ] Feed condition = page condition = JSON-LD condition
- [ ] Shipping settings match between Merchant Center and JSON-LD

## Weekly KPIs

| Metric | Target | How to Measure |
|--------|--------|---------------|
| Feed completeness % | ≥ 95% on top SKUs | Required + recommended fields filled / total fields |
| Answerability % | ≥ 80% | % of top buyer queries answerable from feed data alone |
| Description depth | ≥ 3,000 avg chars | Average character count across active SKUs |
| Parity score | 100% | Feed vs page vs JSON-LD match rate on price, availability, condition |
| Feed freshness | ≤ 15 min lag | Time between source change and feed update |

## Description Structure Template

For each SKU, structure the 5,000-char description as:

```
## What It Is
[1-2 sentences: category, primary function, key differentiator]

## Who It's For
[1-2 sentences: ideal buyer, use case, skill level]

## Key Specs
[Structured list: dimensions, weight, materials, capacity, compatibility]

## How to Use / Care
[Maintenance, setup, or usage instructions relevant to the product]

## What's Included
[Box contents, accessories, warranties]

## Co

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: dataforseo
description: >-
  Use when the user asks to perform SEO research, keyword analysis, SERP audits,
  backlink checks, competitor analysis, or any task involving the DataForSEO API.
  Provides the complete Python client, authentication, response parsing patterns,
  and all available endpoints. Also use when writing scripts that call DataForSEO
  or when the user mentions keyword research, search volume, SERP rankings, or
  SEO data collection.
---

# DataForSEO API — Operational Guide

## File locations (read this first)

Choose behavior based on the current execution surface:

| Context | Client access | Working dir | User-facing output |
|---|---|---|---|
| Codex with local shell access | Resolve this installed skill directory and use `scripts/dataforseo_client.py` | current workspace | `./dataforseo-results/YYYYMMDD/` or another user-approved path |
| ChatGPT or a surface without local shell access | No direct API execution in this skills-only release | conversation or supported file workspace | Return an input contract or analyze user-supplied exports; never fabricate live API results |

This release has no authenticated DataForSEO MCP connection.

## When NOT to Use

- No DataForSEO account or API budget. Every call bills the account — there's no free tier worth building on.
- You only need your own site's organic data. Google Search Console gives you queries, clicks, impressions, and positions for free.
- One-off single-keyword lookups. Scripting a client and paying API spend for one number isn't worth it — use a free volume tool instead.

## Credentials

Use one of these local credential sources, in priority order:

1. **Environment variables:** `DATAFORSEO_LOGIN` and `DATAFORSEO_PASSWORD`.
2. **Local config file:** `~/.config/8gnc/dataforseo.json` with `{"login": "...", "password": "..."}`. Create or read it only with the user's permission and never print its contents.

Do not paste credentials into chat, source files, reports, or committed project configuration.

## Bundled client

A working `DataForSEOClient` ships inside the skill at `scripts/dataforseo_client.py` (~200 LoC, requests-based, covers every convenience method in the table below + generic `post`/`get`/`task_post`/`task_get`/`tasks_ready` escape hatches).

**To use it:** on a local execution surface, resolve the installed `dataforseo` skill directory from this loaded `SKILL.md` and add its `scripts/` directory to the Python import path. Do not copy the client into the user's project unless the user explicitly asks for a vendored copy.

The client only depends on `requests`. Standard library otherwise. Python 3.9+.

## Quick Start (Copy-Paste Pattern)

Every local DataForSEO script should start with this pattern after resolving the bundled client path:

```python
import json, sys, os, time
from pathlib import Path

from dataforseo_client import DataForSEOClient

API_LOGIN = os.environ.get("DATAFORSEO_LOGIN")
API_PASSWORD = os.environ.get("DATAFORSEO_PASSWORD")

client = DataForSEOClient(API_LOGIN, API_PASSWORD)
OUTPUT_DIR = Path.cwd() / "dataforseo-results" / time.strftime("%Y%m%d")
OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
```

- Add `time.sleep(2)` between API calls to respect rate limits.
- Save raw responses as JSON for re-analysis without re-billing the API.
- On a non-local surface, stop before the API call and request an export or an authenticated MCP capability.

## Available Client Methods

### Convenience Methods (Use These First)

| Method | What It Does | Endpoint |
|--------|-------------|----------|
| `client.serp_google_organic_live(keyword, location_name, language_name, device, depth)` | Live Google organic SERP results | `/serp/google/organic/live/advanced` |
| `client.serp_google_maps_live(keyword, location_name, language_name, depth)` | Live Google Maps SERP results | `/serp/google/maps/live/advanced` |
| `client.keywords_search_volume(keywords_list, location_name, language_name)` | Search volume for a list of keywo

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: deep-research
description: Use when a task needs enterprise-grade research across many sources with citation tracking and verification. Triggers on "deep research", "comprehensive analysis", "research report", "compare X vs Y", "analyze trends", or "state of the art". Not for simple lookups, debugging, or questions answerable with 1-2 searches.
---

# Deep Research

## Core Purpose

Deliver citation-backed, verified research reports through a structured pipeline with source credibility scoring, evidence persistence, and progressive context management.

**Autonomy Principle:** Operate independently. Infer assumptions from context. Only stop for critical errors or incomprehensible queries.

---

## Decision Tree

```
Request Analysis
+-- Simple lookup? --> STOP: Use the available current web-search tool
+-- Debugging? --> STOP: Use standard tools
+-- Complex analysis needed? --> CONTINUE

Mode Selection
+-- Initial exploration --> quick (3 phases, 2-5 min)
+-- Standard research --> standard (6 phases, 5-10 min) [DEFAULT]
+-- Critical decision --> deep (8 phases, 10-20 min)
+-- Comprehensive review --> ultradeep (8+ phases, 20-45 min)
```

**Default assumptions:** Technical query = technical audience. Comparison = balanced perspective. Trend = recent 1-2 years.

---

## Workflow Overview

| Phase | Name | Quick | Standard | Deep | UltraDeep |
|-------|------|-------|----------|------|-----------|
| 1 | SCOPE | Y | Y | Y | Y |
| 2 | PLAN | - | Y | Y | Y |
| 3 | RETRIEVE | Y | Y | Y | Y |
| 4 | TRIANGULATE | - | Y | Y | Y |
| 4.5 | OUTLINE REFINEMENT | - | Y | Y | Y |
| 5 | SYNTHESIZE | - | Y | Y | Y |
| 6 | CRITIQUE | - | - | Y | Y |
| 7 | REFINE | - | - | Y | Y |
| 8 | PACKAGE | Y | Y | Y | Y |

---

## File locations (read this first)

Choose behavior based on the current execution surface:

| Context | Helper execution | Report destination |
|---|---|---|
| Codex with local file and shell access | Resolve the installed `deep-research` skill directory from this loaded `SKILL.md`; call helpers from its `scripts/` directory | A user-approved workspace path such as `./research-output/[topic]-YYYYMMDD/` |
| ChatGPT or another surface without local shell access | Do not claim that bundled scripts ran | Return the report in conversation or through the supported downloadable-file workflow |

Never write into a home directory or external system without the user's authorization.

## Execution

**On invocation, load relevant reference files** (relative paths from this SKILL.md, which work on both surfaces):

1. **Phase 1-7:** Load [methodology.md](./reference/methodology.md) for detailed phase instructions
2. **Phase 8 (Report):** Load [report-assembly.md](./reference/report-assembly.md) for progressive generation
3. **HTML/PDF output:** Load [html-generation.md](./reference/html-generation.md)
4. **Quality checks:** Load [quality-gates.md](./reference/quality-gates.md)
5. **Long reports (>18K words):** Load [continuation.md](./reference/continuation.md)

**Templates:**
- Report structure: [report_template.md](./templates/report_template.md)
- HTML styling: [mckinsey_report_template.html](./templates/mckinsey_report_template.html)

**Scripts:** on a local execution surface, resolve the installed skill directory first and use absolute package-relative paths:

- `python3 [skill-dir]/scripts/validate_report.py --report [path]`
- `python3 [skill-dir]/scripts/verify_citations.py --report [path]`
- `python3 [skill-dir]/scripts/md_to_html.py [markdown_path]`

If local execution is unavailable, apply the same checks manually and disclose that the bundled validators did not run.

---

## Output Contract

**Required sections:**
- Executive Summary (200-400 words)
- Introduction (scope, methodology, assumptions)
- Main Analysis (4-8 findings, 600-2,000 words each, cited)
- Synthesis & Insights (patterns, implications)
- Limitations & Caveats
- Recommendations
- Bibliography (COMPLETE - every citation, no placeholders)
- Methodology Appendi

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 19 — file references are metadata, not package contents.

View saved version →

---
name: diagnose-brand-growth
description: Diagnose ambiguous brand and growth problems and route them to the smallest useful 8gnc method sequence. Use when the user says the brand feels stuck, generic, invisible, inconsistent, hard to explain, weak at conversion, weak in outreach, unclear on product direction, or asks which 8gnc skill to use. Also trigger for broad requests such as "fix my brand," "what is actually wrong," "where should we start," "audit this business," or "give me the full 8gnc treatment." Do not trigger when the user explicitly names a specialist skill and already has the inputs it requires.
---

# Diagnose Brand and Growth

Start with diagnosis. Do not expose a 36-skill menu or run the entire stack by default.

Read [capability-map.md](references/capability-map.md) before routing. Load only the selected specialist skill instructions after the route is chosen.

## 1. Establish the evidence boundary

Collect or inspect the smallest useful evidence set:

- the decision the user needs to make;
- the audience, offer, market, and current surface;
- available first-party evidence such as interviews, analytics, loss reasons, briefs, drafts, or pages;
- constraints, timing, and what has already been tried.

Label every input as observed, user-reported, inferred, or unknown. Never invent client intelligence, market evidence, metrics, approvals, or access.

This release has no authenticated client-data connection. Use only evidence the user provides, files available in the current workspace, and lawful public research. Treat an approval as a decision about the named artifact, not authorization to publish, deploy, send, or execute.

## 2. Name the primary constraint

Choose one primary lane:

- brand meaning or positioning;
- product direction or sequencing;
- content or voice;
- search or AI visibility;
- conversion or pricing architecture;
- sales motion or practice.

Use a secondary lane only when evidence shows it is upstream or downstream of the primary constraint. Distinguish symptoms from causes. Low traffic is not automatically an SEO problem; weak conversion is not automatically a copy problem; generic content is not automatically a voice problem.

## 3. Route the work

Select the minimum sequence from the capability map. Prefer:

- one diagnostic or research method;
- one synthesis or stress-test method;
- one deliverable method only when the inputs are strong enough.

Do not run compilers before their required layer artifacts exist. Do not call simulated audience reactions real research. Do not call speculative recommendations validated strategy.

If the user explicitly requests a named specialist skill, invoke that skill directly unless a missing prerequisite would make the output misleading.

## 4. Return a decision-ready diagnosis

Return:

1. **Primary constraint** — one sentence.
2. **Evidence** — what supports it, with source labels.
3. **Confidence and gaps** — high, medium, or low, plus what would change the call.
4. **Route** — the selected skills in order and why each is necessary.
5. **First move** — the first concrete input or action, not a generic checklist.
6. **Decision gate** — what a human must decide before implementation.

End substantial outputs with these five lines:

- Evidence supports:
- Evidence does not establish:
- Human judgment required:
- Implementation prerequisites:
- The model cannot know:

Do not end with an agency pitch. The method must be useful on its own.

Referenced files: 2 — file references are metadata, not package contents.

View saved version →

---
name: fairness-anchor-ladder
description: Execute the Fairness Anchor & Upgrade Ladder pricing strategy (PLAY-001). Use when a client needs loss-leader pricing with a choreographed upgrade path, menu/offer architecture, or viral pricing plays. Triggers on "fairness anchor," "upgrade ladder," "loss leader," "anchor pricing," "menu choreography," "price perception," offer tier design for local services, wellness, QSR, SaaS, or any request to build a pricing strategy around a public anchor price with stacked upgrades.
---

# Fairness Anchor & Upgrade Ladder (PLAY-001)

Operationalize a loss-leader model: lock one "fairness anchor" price in public view, choreograph an upgrade ladder beside it. The anchor edits perception; the ladder prints margin. Virality offsets the unit loss. Supply-side control keeps the engine fed.

## When NOT to Use

- **COGS already at floor.** The model's only levers when margin compresses are value-engineering `C_a` or raising `M_i` — never raising `P_a`. If there is no room to engineer the anchor's cost down, the loss leader is just margin bleed with no recovery path.
- **No audience or brand trust to absorb the anchor loss.** Virality is COGS here: `S_u` has to offset `L_a`. With no shares, views, or UGC engine, the blended contribution formula goes negative and stays there. Build attention first.
- **Regulated-pricing categories.** Healthcare, alcohol, financial services, utilities — public frozen prices and below-cost selling can violate minimum-pricing and advertising rules. A frozen anchor is a promise you may not legally be allowed to keep.
- **No natural upgrade adjacency.** The ladder needs 3–7 upgrades selectable in the same frame as the anchor. If the offer has no honest add-ons, there is nothing to print margin and the anchor is a coupon you pay forever.
- **The problem is flow or identity, not pricing.** For how customers move through the menu once it exists, use `ux-ui-psych`. For the creative system around the brand, use `neuro-design`.

1. Publish a price that feels impossibly fair.
2. Place it first in every frame (menu, landing page, storefront, social bio).
3. Stack 3–7 profitable upgrades immediately adjacent.
4. Engineer UGC around the anchor so attention subsidizes the loss.
5. Measure share-per-unit and attachment rates; iterate weekly.

## Principles

1. **Fairness over price.** A single, public, frozen price builds trust faster than a thousand claims.
2. **Anchors write the map.** First price seen sets the reference for every other decision.
3. **Menu is choreography.** Placement is persuasion. Top slot = hook. Second slot = margin. Third = novelty.
4. **Virality is COGS.** Treat UGC volume as an offset to anchor losses.
5. **Own the spine.** Control supply (inputs, tooling, process) or your loss leader becomes a coupon you pay forever.

## Offer Architecture

### Frame
- **Top-of-menu hero:** Anchor title, price in large type, 1-line promise.
- **Right-beside ladder:** 3–7 upgrades with simple names and one benefit each.
- **One-tap/two-click rule:** Upgrades must be selectable in the same frame as the anchor.

### Naming
- Anchor name: short, literal, shareable. Ex: "Forty-Cent Cone," "$49 Color Consult," "Free Lite Audit."
- Upgrades: descriptive, not clever. Ex: "Sundae +Topping," "Pro Polish," "Priority Turnaround."

### Ladder Design
- Slot 1: **Sane add-on** (highest attachment potential)
- Slot 2: **Signature upgrade** (highest margin)
- Slot 3: **Novelty** (seasonal, social bait)
- Slots 4–7: **Bundles** (anchor + 2 add-ons at slight discount)

## Pricing Logic & Formulas

Variables:
- `P_a` = Anchor price
- `C_a` = Anchor COGS (ingredients + labor + packaging + payment fees)
- `L_a` = Anchor unit loss = `P_a − C_a` (negative if sold below cost)
- `S_u` = Social offset per unit (estimated media value per anchor sold)
- `AR_i` = Attachment rate to upgrade i
- `M_i` = Margin dollars for upgrade i (price minus COGS)
- `U` = Anchor units sold in period

**Target:** Break

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: humanize
description: Rewrite AI-drafted text into the user's authentic voice using a saved voice profile and a 23-pattern editing framework. Use when the user asks to humanize, de-AI, remove generic model phrasing, vary rhythm, or make a draft sound like them. A voice profile from the voice-profiler skill is strongly recommended. This is a voice-fidelity workflow, not a detector-evasion tool.
---

# Humanize — AI Pattern Interrupter

> **READ FIRST — voice profile strongly recommended.** Check for an attached or approved local voice profile before rewriting. If none exists, ask whether to continue with a generic edit or invoke `voice-profiler` first.

You are a writing pattern interrupter. Your job is to identify generic model habits, then rewrite the text in the user's authentic voice using evidence from their voice profile.

This workflow improves voice fidelity and removes common generic-model patterns. Do not optimize for, predict, or guarantee the result of any AI classifier.

## Voice Profile Loading

Before rewriting, load the user's voice profile from the evidence the current surface can actually access:

1. Prefer an attached or explicitly provided `voice-profile.md`.
2. In Codex with local file access, check `./.8gnc/voice-profile.md`, then `./voice-profile.md`.
3. Check `~/.config/8gnc/voice-profile.md` only when the user has approved a persistent personal profile.
4. If none is found, offer `voice-profiler` or continue with a clearly labeled generic edit at the user's choice.

Parse the profile for: core identity, sentence rhythm, opening/closing patterns, vocabulary preferences, banned words, persuasion style, writing samples, and any platform-specific overrides.

The voice profile is the difference between generic "humanized" text and text that sounds like YOU wrote it. The voice profile must be built from the user's OWN writing samples — never reuse someone else's profile; output will sound like the wrong person.

## Input

Use the text supplied in the user's request. If the user says "last," operate on the last substantial text block produced in the conversation.

## Step 1: ANALYZE — Score Generic Model Patterns

Evaluate the input against every pattern below. Score each 0-3:
- **0** = Not present (already human-sounding)
- **1** = Mild (slight AI pattern)
- **2** = Moderate (clearly AI-patterned)
- **3** = Strong (textbook AI output)

### Tier 1 — Statistical Patterns
These are foundational writing signals that often make generated prose feel safe, uniform, and unlike the named author.

| # | Pattern | What to inspect | Score 0-3 |
|---|---------|-------------------|-----------|
| 1.1 | **Low perplexity** | AI picks the most statistically probable next word. Text reads as "safe" and predictable. No surprising vocabulary choices. | |
| 1.2 | **Low burstiness** | Uniform sentence lengths. AI writes 15-20 word sentences consistently. No short punches followed by long expansions. | |
| 1.3 | **Limited semantic diversity** | Same vocabulary recycled across paragraphs. Synonyms cluster around common words. | |
| 1.4 | **Smooth token probability** | No jarring word choices. Every word flows into the next with high probability. Human writing has "spikes" — unexpected words that fit contextually but aren't statistically obvious. | |

### Tier 2 — Composition Patterns
These patterns appear in phrasing, structure, and emphasis. Score how strongly each one makes the draft sound generic or unlike the user's samples.

| # | Pattern | What to inspect | Score 0-3 |
|---|---------|-------------------|-----------|
| 2.1 | **Structural uniformity** | Introduction → supporting points → conclusion. Parallel sentence structures. Predictable argument flow. | |
| 2.2 | **Hedging and qualification** | "It's important to note," "While there are many factors," "It's worth mentioning." AI never commits — it always leaves itself an out. | |
| 2.3 | **Generic abstraction** | Smoothing specific facts into general statements. "Ma

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: humanize-ig
description: Rewrite text as an Instagram-native caption using compact phrasing, intentional lowercase, varied rhythm, and the user's approved voice profile. Use when the user asks to humanize an Instagram caption, remove generic model phrasing, or make a caption sound like they typed it on their phone. This is a voice-fidelity workflow, not a detector-evasion tool.
---

# Humanize IG — Instagram Voice Interrupter

> **READ FIRST — voice profile recommended.** Check for an attached or approved local voice profile. If none exists, mention once that the edit will use a generic Instagram voice and offer `voice-profiler` for personalized output.

You are a writing pattern interrupter optimized for Instagram captions. Your job is to take AI-generated text and rewrite it so it reads like a real human typed it on their phone for an Instagram post.

This is the Instagram-specific sibling of `humanize`. It uses the same editing framework with a different output voice and makes no classifier prediction or guarantee.

## Voice Profile Loading

Before rewriting, check for an attached `voice-profile.md`. In Codex with local file access, check `./.8gnc/voice-profile.md`, then `./voice-profile.md`; check `~/.config/8gnc/voice-profile.md` only when the user approved a persistent personal profile.

If found, load any Instagram-specific overrides from the "Platform Overrides" section. The IG voice rules below are non-negotiable — they override general voice profile settings — but the profile's vocabulary, identity, and emotional range still apply.

If no profile exists, the skill still works — it just won't carry your personal fingerprint.

## Input

Use the text supplied in the user's request. If the user says "last," operate on the last substantial text block produced in the conversation.

## Step 1: ANALYZE — Score AI Patterns

This skill uses the same 23-pattern editing framework as `humanize` (Tier 1: statistical, Tier 2: composition, Tier 3: document-level). The rules under "Pattern-Breaking for IG Specifically" below are the IG-specific deltas. A skill invocation does not load sibling skill files automatically, so the pattern names live here too — score each 0-3 standalone:

- **Tier 1 — Statistical (max 12):** low perplexity, low burstiness, limited semantic diversity, smooth token probability
- **Tier 2 — Composition (max 42):** structural uniformity, hedging, generic abstraction, mechanical transitions, emotional flattening, over-completeness, list-heavy structure, preamble/summary, significance inflation, superficial -ing clauses, copulative avoidance, rule of three, elegant variation, negative parallelisms
- **Tier 3 — Document-Level (max 15):** consistent register, balanced paragraph length, perfect grammar, absence of voice, symmetrical structure

## Step 2: REPORT — Show the Score

```
PATTERN ANALYSIS (IG MODE)
────────────────
Tier 1 (Statistical):  [score]/12
Tier 2 (Composition):   [score]/42
Tier 3 (Document):     [score]/15
────────────────
Total: [score]/69 ([percentage]%)
Mode:  [SURGICAL | MODERATE | FULL REWRITE]
```

Use the same mode thresholds as `humanize`:
- 0-15% → SURGICAL
- 16-50% → MODERATE
- 51%+ → FULL REWRITE

## Step 3: REWRITE — Apply Instagram Voice

### The IG Voice Rules

These are non-negotiable. Every single one gets applied.

**1. Lowercase everything except the first word of the entire caption.**
- First word capitalized. Everything else lowercase. Including after periods.
- Proper nouns stay lowercase unless it looks weird (brand names can keep caps if needed).
- Example: `Brand strategy isn't the logo. its the thing underneath that nobody sees.`

**2. No em dashes. Ever.**
- Replace every em dash (—) with a period, comma, or just smash the thoughts together.
- "That's what brand strategy is — the structure underneath" becomes "thats what brand strategy is. the structure underneath"

**3. One paragraph. No line breaks in the body.**
- The entire caption body is ONE block of te

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: linkedin-authority
description: Use when creating LinkedIn posts, personal brand content, thought leadership pieces, or social media copy that needs to feel human, conversational, and memorable. Also use when analyzing or improving existing LinkedIn content. Triggers on requests for LinkedIn posts, personal branding content, thought leadership writing, or when user wants content that "sounds human" or avoids AI-sounding copy. Writes high-performing LinkedIn content using patterns extracted from viral post analysis.
---

# LinkedIn Authority — High-Performance Content Framework

Write LinkedIn posts that perform using patterns extracted from analysis of 42 high-performing posts (peak 376 likes, 104 comments). These patterns are platform-native — built from what actually works on LinkedIn, not what marketing textbooks say should work.

## Core Philosophy

Content ABOUT the work outperforms content OF the work. Meta-commentary on the platform, the struggle, the game beats polished expertise. The tension between critique and participation is the brand.

## The Five Themes (Pick One Per Post)

Every post should be a variation of one core theme:

1. **Taste > Creativity** — The editing muscle matters more than the generating muscle. Killing ideas is harder than making them.
2. **Performance > Authenticity** — "Just be yourself" is bad advice. Put on a show. Become a character. The show IS the brand.
3. **Interesting > Impressive** — Do things worth talking about. Impressive doesn't stop the scroll; interesting does.
4. **Platform as Venue** — You are the show, the algorithm is eavesdropping. Talk to humans, machines follow.
5. **Repetition IS Strategy** — Say the same 5 things 50 different ways. Consistency compounds.

## Voice & Tone

- Self-deprecating but not groveling
- Philosophical without being pretentious
- Frustrated but not bitter
- Teaching but not lecturing
- Talk TO the audience, not AT them

## Structural Patterns

### Sentence Rhythm

Short paragraphs. Single sentences as their own line. Build with fragments:

```
Not because you're not impressive.
But because impressive is not the same thing as interesting.
```

### Hook Types (Pick One)

| Type | Example | Why It Works |
|------|---------|--------------|
| Confession | "I haven't missed a single day of posting in 5 years" | Stakes + credibility |
| Counterintuitive | "The best hook I ever wrote made me feel stupid" | Curiosity through contradiction |
| Story Open | "A client once asked me to write 50 headlines" | Narrative pull |
| Direct Challenge | "Can we all stop talking about how Gen Z..." | Stakes a position |

**Avoid**: Newsletter promos as hooks, vague philosophical statements without punch.

### The 6-8 Line Rule

The real hook is usually buried 6-8 lines into your first draft. Find it. Move it up.

### Ending Patterns

- Circle back to opening with a twist
- One-line kicker that lands the point
- Self-aware CTA that doesn't feel salesy
- Question that makes reader apply it to themselves

## Content Tiers

### Tier 1: Framework Posts (Highest Engagement)

Give people a taxonomy they can apply to themselves. The "three types of creatives" pattern:

1. Name 3 types/categories in your domain
2. Describe each with clear traits
3. Add a simple self-assessment test
4. People share because they want to see which one they are

### Tier 2: Platform Vulnerability

Say what everyone's thinking about the algorithm, the game, the performance. Be honest about frustration while still playing.

### Tier 3: Contrarian Takes

"Just be yourself is the worst advice" — stake a position, but deliver it conversationally. Generate debate, not agreement.

### Tier 4: Historical/Craft Content

Builds authority, doesn't win on likes. The Club Med origin story, the first ad ever written. These compound over time.

### Tier 5: Filler (Maintain Presence)

Short algorithm quips, quick observations. Don't pretend they're more than they are.

## What NOT To Do

- Newsletter prom

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: local-services-seo
description: Execute the Local Services city-by-service matrix playbook (PLAY-003). Use when building city/service landing pages, local SEO architecture, provider directories, or lead routing systems. Triggers on "city pages," "local SEO," "service area pages," "provider directory," "describe your job form," "lead routing," "round robin," "JSON-LD LocalBusiness," "city-by-service matrix," or when scaling one service across multiple metros.
---

# Local Services — City-by-Service Matrix (PLAY-003)

Pick one service, multiply it across ten cities with lean, useful pages that convert. Each page earns trust with a unique local intro, a mini directory, and a fast "Describe your job" form. Structured data makes the pages machine-readable.

## When NOT to Use

- The service is B2B or geographically agnostic. City pages add nothing when buyers don't search by city.
- Single-location business with no expansion plan. Standard local SEO — Google Business Profile, one location page, reviews — covers it without a matrix.
- You can't vet providers or route leads. Without a real directory or a working form, the pages are thin doorway pages and will read like it.

## Core Loop

1. Pick one service × ten cities with clean, consistent URLs.
2. Clone a simple page template that is actually useful at the city level.
3. Add JSON-LD so search and LLMs understand the content.
4. Ship a phone-friendly form with clear consent and round-robin routing.
5. Track submissions, provider response, and close rates. Iterate weekly.

## Principles

1. **One service, many cities.** Narrow the offer, scale the footprint.
2. **Every page useful on its own.** Unique intro plus real providers beats thin doorway pages.
3. **Human + machine readable.** Plain language on the page, JSON-LD under the hood.
4. **Consent is explicit.** Lead sharing and outreach require clear permission.
5. **Routes not silos.** Round-robin or rules-based routing keeps providers engaged and response times low.

## Information Architecture

- **Slug pattern:** `/{state}/{city-slug}/{service-slug}/`
  - Examples: `/tx/dallas/pool-cleaning/`, `/tx/plano/pool-cleaning/`
- **Canonical:** each page canonicalizes to itself.
- **Hubs:** optional `/{state}/{service-slug}/` hub that links to all cities.
- **Sitemap:** include every city page; avoid orphans.

## Page Template

**Title/H1:** "{Service} in {City}, {ST}"

**Intro (100–150 words):** seasonal context, common issues, notable neighborhoods. Write uniquely for each city.

**Mini directory:** 5–20 providers with name, phone, hours, areas served.

**CTA:** "Describe your job" form, above the fold on mobile.

**Optional adds:** embedded map, 3-bullet "How {service} works in {City}," 1–2 local FAQs, "List your business" link.

## Structured Data (JSON-LD)

### If listing providers on the page — ItemList of LocalBusiness:

```json
{
  "@context":"https://schema.org",
  "@type":"ItemList",
  "name":"Pool Cleaning in Dallas, TX",
  "itemListElement":[
    {
      "@type":"ListItem","position":1,
      "item":{
        "@type":"LocalBusiness",
        "name":"Bluefin Pool Service",
        "url":"https://example.com/bluefin",
        "telephone":"+1-214-555-0101",
        "address":{"@type":"PostalAddress","addressLocality":"Dallas","addressRegion":"TX"},
        "areaServed":"Dallas, TX",
        "openingHours":"Mo-Fr 08:00-18:00"
      }
    }
  ]
}
```

### If no providers yet — Service block:

```json
{
  "@context":"https://schema.org",
  "@type":"Service",
  "serviceType":"Pool Cleaning",
  "areaServed":{"@type":"City","name":"Dallas"},
  "providerMobility":"dynamic",
  "hasOfferCatalog":{
    "@type":"OfferCatalog",
    "name":"Pool Cleaning Services",
    "itemListElement":[
      {"@type":"Offer","name":"Weekly Cleaning"},
      {"@type":"Offer","name":"Green-to-Clean"},
      {"@type":"Offer","name":"Repair"}
    ]
  }
}
```

**Optional enhancements:** BreadcrumbList for nav context, FAQPage if real FAQs are on 

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: mayhem-method-ai-use
description: Apply the Mayhem Method to AI Use for standardized AI-assisted creative production. Use when producing social posts, campaign briefs, copy blocks, or any creative output using AI workflows. Triggers on "AI workflow," "prompt chaining," "few-shot steering," "zero-shot baseline," "structured deliverable," "acceptance rubric," "campaign brief schema," "mayhem method AI," or when systematizing AI-assisted content creation for client work.
---

# Mayhem Method to AI Use (v1.0)

Standardize how Branded Mayhem uses AI to produce high-quality creative outputs fast. Start with a clear baseline, iterate with tight feedback, ground everything in brand and source context, package outputs in usable formats.

## Core Loop

1. Define the task and constraints with a zero-shot baseline.
2. Chain prompts with specific feedback to refine.
3. Provide examples to lock tone and cadence.
4. Request structured deliverables and variants.
5. Evaluate against brand criteria, then package and ship.

## Principles

1. **Clarity first.** State goal, audience, channel, format, length, constraints.
2. **Context in, quality out.** Supply source articles, brand pillars, voice rules.
3. **Iterate with purpose.** Each message adds or removes exactly one uncertainty.
4. **Examples steer style.** One good example is worth ten adjectives.
5. **Structure beats vibes.** Bullet requirements so nothing slips.
6. **Options unlock choice.** Ask for multiple hooks or formats when exploring.
7. **Ethics matter.** Avoid dark patterns, protect IP, cite when summarizing.
8. **Respect limits.** Request export-friendly output (Markdown, HTML, CSV).

## Workflow

### 3.1 Define the Task (Zero-Shot)

```
Goal: 4 social posts for {brand} during {theme}
Audience: {role}, {industry}
Tone: {voice rules}
Inputs: {link or pasted source}
Deliverable: {count}, {format}, {length}, {hashtags yes/no}, {artwork hooks}
Constraints: {regulated terms, claims, style rules}
```

### 3.2 Iterate (Prompt Chaining)

```
Keep: Post 1 structure
Change: Hook needs a stat; add 1 data point
Cut: Hashtags over 5
Add: CTA specific to {practice area}
```

### 3.3 Steer with Examples (Few-Shot)

```
Match this intro cadence:
"It's Cybersecurity Awareness Month... {short pivot}. {brand} helps {who} with {what}."
Apply that to 4 pillars: Insight, Security, Awareness, Governance.
```

### 3.4 Request Structure and Variants

```
For each post include:
- Headline (<=8 words)
- Caption (2–3 sentences)
- 3–5 hashtags
- Artwork hook (2 variants)
- 1 brand tie-in sentence using {practice area list}
```

### 3.5 Packaging

```
Output as Markdown sections per post with H2 headings. No code fences.
```

## Prompt Patterns Library

**Baseline generation:**
```
Create {n} {asset_type} for {brand}. Audience {aud}. Tone {voice}.
Each must include {elements}. Source: {link or text}.
Avoid {prohibited}. Length {limit}. Output as {format}.
```

**Refinement:**
```
Revise Post {#}: keep core idea, strengthen hook with stat,
wrap with {brand practice area}, remove jargon, keep under {char}.
```

**Few-shot steer:**
```
Mimic this style:
Example: "{sample 1}"
Example: "{sample 2}"
Now produce {n} new {assets} on {topics}.
```

**Options request:**
```
Give 3 alternate hooks for Post {#}, each in a different framing:
{authority}, {fear-to-safety}, {process reveal}.
```

**Format packaging:**
```
Return a one-page brief with:
- Objective
- Audience
- Message pillars
- 4 posts (H2)
- Asset checklist
```

## Thematic Cohesion

- Define a campaign spine with 3–4 pillars.
- Provide one sample intro to set cadence.
- Require each asset to map to a pillar and call out the mapping.

## Structured Deliverable Schemas

**Social post:**
```json
{
  "post_id": "CYA-01",
  "pillar": "Insight",
  "headline": "",
  "caption": "",
  "hashtags": [],
  "art_hooks": ["", ""],
  "brand_tie_in": ""
}
```

**Campaign brief:**
```json
{
  "objective": "",
  "audience": "",
  "pillars": ["","","",""],
  "source

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: neuro-design
description: Apply the Neuro-Design Playbook (v1.0) for psychology-driven creative direction and visual identity systems. Use when designing brand identity, campaign creative, or assets that need to encode memory and drive response. Triggers on "neuro design," "geometric reduction," "sensory branding," "red dot principle," "salient accent," "nostalgia fusion," "emotional direction," "emotional polarity," "memory encoding," "visual identity psychology," or when creative direction needs a specific psychological play for recall and response.
---

# Neuro-Design Playbook (v1.0)

Turn psychology into repeatable creative moves that drive recall and response.

## Philosophy

Reduce to signal. Repeat to encode. Polarize to be remembered. Evoke to belong.

Design is a memory game. Shape cues the brain can store in one glance or one beat, then repeat them until they feel inevitable.

## When NOT to Use

- **Audiences too diverse to share a cultural memory.** P4 Nostalgia Fusion's QA is "audience names the era in under one second" — if your markets or generations don't share the cue, you get costume-party vibes instead of belonging. Stay with P1 or P5, or skip the playbook.
- **Zero budget for creative testing.** Every play here lives or dies on its QA test and KPIs — recall tests, one-second silent tests, sentiment surveys. If you cannot run any of them, you are shipping unverified psychology and calling it strategy.
- **Rapid prototyping where shipping beats identity.** Shape libraries, audio stings, alignment grids, and stance rules are compounding assets. If the asset is disposable or the product may pivot next month, the research-backed system work slows you down for nothing.
- **The problem is pricing or flow, not memory.** This playbook encodes recall and response into creative. For offer architecture use `fairness-anchor-ladder`; for conversion flow and nudges use `ux-ui-psych`.

1. Need universal recognition fast? → **P1 Geometric Reduction**
2. Need ritual and anticipation? → **P2 Sensory Branding**
3. Need one click now? → **P3 Salient Accent (Red Dot)**
4. Need belonging through memory? → **P4 Nostalgia Fusion**
5. Need a feeling in one second? → **P5 Emotional Direction**
6. Need talk value and tribe? → **P6 Emotional Polarity**

---

## P1) Geometric Reduction

Strip visuals to simple high-contrast geometry. Use as a code system across touchpoints.

**Use when:** You need universality, control, or fast recognition across formats. Tech, platforms, uniforms, signage, safety.

**Build steps:**
1. Define 1–3 core shapes and a primary field color.
2. Set contrast rules: background fields, stroke widths, spacing grid.
3. Write the "code key" for meaning per shape.
4. Produce a micro library: SVGs, masks, motion loops, sticker sheet.
5. Publish do/don't rules for clutter, gradients, and photo use.

**Artifacts:** Shape set, usage grid, icon masks, 3 motion stingers, sticker sheet, one-page rules.

**QA:** Drawable from memory in 5 seconds. Recognizable at favicon size.

**KPIs:** Unaided logo recall, scroll-stop rate, favicon recognition test, speed of task in UI.

---

## P2) Sensory Branding

Pair a restrained visual with one or two consistent sensory cues: sound, motion, light direction, or rhythm.

**Use when:** You want ritual, anticipation, and "it feels like us" before the message lands.

**Build steps:**
1. Pick two cues max. Example: low piano chord + slow tilt-up light.
2. Lock duration, attack/decay, and start time in the edit.
3. Create a 2–4 second sting and a 10–15 second long open.
4. Document where the cue appears: openers, chapter cards, app events.
5. Add a silent variant that keeps the same rhythm and light.

**Artifacts:** Audio stings, motion overlays, light rig guide, LUT, edit macro/template.

**QA:** Cue recognized without logo. People predict what's coming.

**KPIs:** Watch-through lift when cue present, unaided cue recognition, brand-correct association in surveys.

---

## P3) Sali

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: outreach-diagnosis
description: Diagnose cold outreach performance using kill metrics, root cause analysis, and prioritized fix plans. Use when outreach campaigns have low open rates, zero replies, poor deliverability, or any cold email/LinkedIn sequence is underperforming. Triggers on "outreach diagnosis," "email not working," "zero replies," "low open rate," "cold email audit," "outreach audit," "deliverability," "why no replies," "email warmup," "outreach kill metrics," "sequence diagnosis," or when reviewing any cold outreach campaign performance. Produces a structured diagnosis with root causes and a prioritized fix sequence.
---

# Outreach Diagnosis Framework

Structured post-mortem methodology for cold outreach campaigns. Identifies root causes, applies kill metrics, and produces a prioritized fix plan.

## When NOT to Use

- **Fewer than ~50 sends.** The kill metrics are rates, and at small sample sizes one reply or one bounce swings a rate past a threshold. This framework's own follow-up cadence re-evaluates at 40 sends — below that volume you are diagnosing noise, not a campaign.
- **Brand-new domain with zero warmup.** You already know what Check 1 will find. Warm the domain first — ramped daily volume, auth records, engagement on warmup sends — then run the diagnosis on real campaign data.
- **Outreach under active legal or compliance review.** The fix plans here optimize performance, not legal exposure. If counsel is reviewing your sends for CAN-SPAM, GDPR, or industry rules, pause and resolve that first — a better subject line does not fix a compliance problem.
- **The problem is past the inbox.** Replies that stall on calls, prospects who ghost after a proposal, deals that die in negotiation — that is conversation territory. Use `pitching-pivot` for the methodology and `sales-simulator` to practice it.

Resolve these variables:

| Variable | What to Capture | Default |
|----------|----------------|---------|
| `campaign_name` | Campaign or sequence identifier | *required* |
| `channel` | Email / LinkedIn / Multi-channel | Email |
| `sends` | Total emails or messages sent | *required* |
| `opens` | Open count and rate | *required for email* |
| `replies` | Reply count and rate | *required* |
| `bookings` | Meetings booked | 0 |
| `time_period` | Date range of sends | *required* |
| `sender_domain` | Sending domain | *required for email* |
| `domain_age` | How long the domain has been sending | *ask* |
| `tools_used` | Outreach platform, CRM, warmup tools | *ask* |
| `sample_subjects` | 5-10 subject lines used | *ask* |
| `sample_body` | 1-2 email body examples | *helpful* |
| `target_segment` | Who was targeted (ICP, title, industry) | *ask* |

## Kill Metrics

These are non-negotiable thresholds. If any is violated, the campaign is broken and must be fixed before continuing sends.

| Metric | Target | Kill Floor | Action if Below Kill Floor |
|--------|--------|------------|---------------------------|
| Open Rate | 50%+ | 30% | **Stop sending.** Deliverability or subject line problem. |
| Reply Rate | 5%+ | 2% | **Pause and diagnose.** Message or targeting problem. |
| Bounce Rate | <2% | 5% | **Stop sending.** List quality problem. |
| Unsubscribe Rate | <1% | 2% | **Pause.** Targeting or frequency problem. |
| Spam Complaint | <0.1% | 0.3% | **Stop immediately.** Domain reputation at risk. |

## Diagnosis Protocol

Run these checks in order. Each produces findings that feed the fix plan.

### Check 1: Deliverability

**Is the email reaching the inbox?**

- Domain warmup status: Has the sending domain been warmed? How many emails/day before campaign?
- SPF/DKIM/DMARC: Are authentication records configured?
- Sending volume: How many emails per day? Ramp pattern?
- Sending pattern: Spacing between sends? All same time or distributed?
- Blacklist check: Is the domain or IP on any blocklists?
- Reply rate on warmup emails: Were warmup emails getting engagement?

**Red flags:**
- New domain with no warm

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: pitching-pivot
description: Apply the Pitching Pivot technique for value-based sales conversations. Use when preparing for sales calls, handling pricing objections, reframing commodity requests into strategic engagements, or coaching on consultative selling. Triggers on "pivot technique," "value-based pricing," "objection handling," "too expensive," "price objection," "how to close," "sales prep," "upsell without upselling," "reframe the conversation," "they only want a website," "client wants a logo," or when a prospect is asking for a commodity service and you need to shift the conversation to strategic value.
---

# Pitching Pivot Technique

Stop selling, start serving. Whoever asks more questions controls the conversation. When the client says the value out loud, they close themselves.

## Core Principle

When a client asks for a specific service (e.g., "I need a website"), do not quote the service. Pivot by asking about their bigger goals. The price gap between the commodity ask and the strategic offer is small, but the value leap is massive.

## When NOT to Use

- **Locked-budget RFPs where price is already decided.** A committee scoring line items against a fixed budget cannot be reframed by discovery questions — the frame was set before you arrived. Decide whether to bid the spec or walk; do not burn the pivot on a buyer who cannot reopen the conversation.
- **Pure commodity sales with no value-reframing room.** The pivot works because the output serves a bigger outcome. If the outcome genuinely is the output — a buyer who needs exactly the thing, at spec, with zero strategic upside — Step 2's question dead-ends and you sound evasive instead of consultative.
- **Emergency procurement with no discovery window.** The framework requires at least 3 questions before any solution and a discovery call before any proposal. A buyer in a same-day emergency has no window for either. Quote it, deliver it, and run the pivot on the next engagement.
- **Practice, not principles.** To drill this technique against realistic buyers with scoring, use `sales-simulator` — it trains exactly this framework. And if the problem is upstream — cold emails getting no replies, so there is no conversation to pivot — that is `outreach-diagnosis`.

Determine the mode:

| Mode | When | Output |
|------|------|--------|
| `prep` | Before a sales call or meeting | Pivot script with anticipated objections and reframes |
| `roleplay` | Practice run — you play the prospect | Interactive sales simulation with feedback |
| `debrief` | After a call that did not close | Diagnosis of where the pivot failed + recovery plan |
| `coach` | General sales methodology guidance | Principles and techniques with examples |

Resolve these variables:

| Variable | What to Capture | Default |
|----------|----------------|---------|
| `prospect_name` | Company or individual | *required for prep/debrief* |
| `commodity_ask` | What they initially requested | *required* |
| `industry` | Their sector | *helpful* |
| `known_budget` | Any budget signals | None |
| `prior_context` | How they found you, what they have said so far | None |

## The Pivot Framework

### Step 1: Receive the Commodity Ask

The prospect says something like:
- "We need a new website"
- "How much for a logo?"
- "Can you redesign our social media?"
- "We need SEO help"

**Do not answer with a price.** Do not even answer with a range. The moment you quote a commodity, you are a commodity.

### Step 2: Acknowledge and Pivot

Use this pattern:

> "I can absolutely help with that. Before I give you a number, can I ask — what is the website (or logo, or SEO) supposed to do for your business?"

The pivot question format: **"What is [their ask] supposed to do for [their business]?"**

This forces the prospect to articulate the outcome, not the output.

### Step 3: Go Deeper with Follow-Up Questions

Each answer reveals a deeper need. Keep asking:

- "What happens if that works? What does that look like fo

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: productprint-engine-guide
description: Use when starting a new Productprint engagement, when a buyer needs instructions on how to use the skill package, or when the user asks "how do I run the Productprint," "what order do I use these skills," or "where do I start" with the Product/Platform Strategy Engine. Orientation skill for the 6-layer Productprint chain (core-strategic-truth → productprint-tier-a → productprint-tier-b → productprint-tier-c → thesis-stress-test → strategy-thesis-compiler).
---

# Productprint Engine — Runner Guide

This guide walks through the complete Productprint Engine workflow and produces a structured Integrated Product Strategy Thesis.

## When NOT to Use

- **Running an individual layer.** Invoke that layer's skill directly (`core-strategic-truth`, `productprint-tier-a`, etc.) — this guide orients and sequences, it doesn't execute.
- **As a substitute for the layer skills.** The workflows, gates, and output schemas live in each layer's SKILL.md. This file tells you the order and the prompts, nothing more.

## What You Get

The Productprint Engine is a chain of 6 skills that run in sequence. Each layer feeds the next:

```
Layer 1: Core Strategic Truth ─── foundational tension sentence (1 sentence, max 25 words)
    │
    ▼
Layer 2: Productprint Tier-A ──── 10 Playing-to-Win cascade elements with evidence gates
    │
    ▼
Layer 3: Productprint Tier-B ──── 5 actionable elements: bets, roadmap, build/buy/partner,
    │                              prioritization model, risk register
    ▼
Layer 4: Productprint Tier-C ──── 4 deployable positioning artifacts: positioning statement,
    │                              product one-liner, bet narrative, strategy-on-a-page
    ▼
Layer 5: Thesis Stress-Test ───── extracts load-bearing assumptions; tries to FALSIFY them
    │
    ├── If REFINE → re-run Layers 1-4 with constraint package injected (second pass)
    │                (hard stop after 2 passes — surface to operator)
    └── If PROCEED ──▼
                      │
Layer 6: Strategy Thesis Compiler ── 20-40 page consulting-grade integrated strategy thesis
```

The domain-neutral skeleton these layers implement is specified in `CONTRACT.md`.

---

## Prerequisites

- An installed 8gnc plugin in ChatGPT or Codex
- Current web research access for evidence-dependent layers
- **Python 3.9+** for optional local research and validation helpers in Codex
- **Optional:** weasyprint (`pip install weasyprint`) for PDF output
- **Optional:** [search-cli](https://github.com/199-biotechnologies/search-cli) for enhanced multi-provider search on local execution surfaces

---

## Installation Check

This guide is installed as part of the `8gnc` plugin. Ask the model to list the available Productprint skills. Confirm that the six strategy layers, this guide, and the shared `deep-research` skill are available before starting the full chain.

---

## The Two-Pass Workflow

This is the most important thing to understand. **The Productprint Engine is designed to run twice.**

### First Pass (Layers 1-4): Raw Strategy

The first pass builds a strategy thesis from the product's own evidence: market tensions, JTBD outcomes, competitive capabilities, economic engine, and positioning artifacts. It produces good output — but the load-bearing assumptions have not been attacked yet.

### The Thesis Gate (Layer 5): Adversarial Pre-Mortem

Layer 5 is not a competitive vocabulary check. It is a **structured pre-mortem on the one assumption that, if false, collapses the entire strategy**. The gate asks: "What has to be true for this thesis to hold — and is it actually true?"

The gate extracts every assumption embedded in Layers 1-4, ranks them by fragility (how much of the strategy depends on each one × how hard it is to verify), and then tries to FALSIFY the highest-fragility assumption using disconfirmation queries. Counter-evidence is the success condition of this pass, not a failure.

Two outcomes:

- **PROCEED** — The 

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: productprint-tier-a
description: Use when the user asks for a Productprint, product strategy research, Playing-to-Win cascade, where-to-play analysis, how-to-win hypothesis, market sizing, competitive capability teardown, JTBD outcomes mapping, segment willingness-to-pay, economic engine modeling, differentiation wedge, or any comprehensive product or platform strategy deliverable — Layer 2 of the Productprint research stack. Also trigger on "run Tier-A," "productprint research," "full product strategy audit," "product strategy sprint," "Playing-to-Win cascade," "market sizing," "where to play," "how to win," or when the user wants JTBD outcomes, competitive capability teardown, segment WTP, and strategy positioning in one pass. Use immediately when the core-strategic-truth skill has just completed — chain directly using its output as the seed.
---

# Productprint Tier-A — Hybrid Research Directive

Deliver all 10 Tier-A Productprint elements using a hybrid method: build a shared evidence Backbone first, then run independent, falsifiable sprints per element — each with its own proofs and claim sheets. The 10 elements form an integrated Playing-to-Win cascade: winning aspiration → category sizing → JTBD outcomes → segments → where-to-play → competitive capability teardown → how-to-win → required capabilities → economic engine → differentiation wedge.

## When NOT to Use

- **You only need quick positioning or stylistic outputs.** Tier-C requires Tier-A and Tier-B as seeds — there is no shortcut to a strategy thesis. Run the full chain, or run this skill in `rapid` mode to lighten the load.
- **No access to real market evidence.** Every sprint gates on ≥3 independent sources or behavioral signals. Without reviews, search data, and competitor materials to mine, the claims can't clear the gates.
- **Validating existing positioning against competitors.** That's an adversarial test, not a build — use `thesis-stress-test` (Layer 5).

## Chain Position

This is **Layer 2** of a 6-layer Productprint research stack:

1. **Core Strategic Truth** (Layer 1) → foundational tension sentence, tension map, JTBD seed, archetypes, lexicon
2. **Productprint Tier-A** (this skill) → uses Layer 1 output as seed; produces 10 defensible Playing-to-Win cascade elements
3. **Productprint Tier-B** (Layer 3) → uses Tier-A output as seed; produces actionable plan: strategic bets, Now/Next/Later roadmap, build/buy/partner decisions, prioritization model, and risk register
4. **Productprint Tier-C** (Layer 4) → uses Tier-A + Tier-B output as seeds; produces deployment-ready positioning artifacts: positioning statement, one-liner, bet narrative, and strategy-on-a-page
5. **Thesis Stress-Test** (Layer 5) → adversarial pre-mortem gate; extracts load-bearing assumptions and tries to FALSIFY them; returns PROCEED if they survive or REFINE (with a constraint package) if one falls
6. **Strategy Thesis Compiler** (Layer 6) → compiles all layers into a consulting-grade integrated strategy thesis deliverable

**When Layer 1 has just completed:** Import its output directly. The `final_sentence`, `tension_map`, `jtbd_seed`, `archetypes`, `lexicon`, and `evidence_mode` from Core Strategic Truth seed the Backbone phase — do not re-research what Layer 1 already validated. Carry forward its sources into the Backbone bibliography.

**When running standalone:** Resolve all variables with the user and build the Backbone from scratch.

## Variables to Resolve

Before starting, confirm these with the user (or inherit from Layer 1):

| Variable | What to Capture | Default |
|----------|----------------|---------|
| `product_name` | The product, platform, or solution being researched | *required* |
| `category` | Market category or domain | *required* |
| `audience` | Primary buyer/operator audience definition | *required* (or from Layer 1) |
| `region_context` | Geography or cultural context | US / English-speaking |
| `constraints` | Scope, legal, or strategic constrai

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: productprint-tier-b
description: Use when the user asks for Tier-B product strategy elements — strategic bets, Now/Next/Later roadmap, build-vs-buy-vs-partner decisions, prioritization model, risk register, or roadmap sequencing — Layer 3 of the Productprint research stack. Also trigger on "run Tier-B," "Productprint Tier-B," "strategic bets," "roadmap horizons," "Now/Next/Later," "build vs buy," "prioritization model," "risk register," or when the user wants a sequenced, evidence-backed product plan derived from existing Tier-A strategy research. Use immediately when the productprint-tier-a skill has just completed — chain directly using its output as the seed.
---

# Productprint Tier-B — Strategic Bets, Roadmap & Risk Directive

Deliver 5 Tier-B product strategy elements that are sequenced, falsifiable, and aligned to validated Tier-A truths. The Now/Next/Later roadmap is the marquee output: its ordering MUST be justified by inter-bet dependencies and kill-criterion thresholds, not intuition. Evidence is lightweight but real. Every element with a testable behavioral signal gets a proxy test.

## When NOT to Use

- **No Tier-A output exists.** Tier-B derives, it doesn't originate. Run `productprint-tier-a` first — standalone mode here produces reduced-confidence output and says so in the audit log.
- **Full product specifications or technical architecture.** Bets, roadmap horizons, and the risk register are strategy-layer artifacts. Technical specs, API designs, and sprint plans are implementation work outside this chain.
- **Adversarial differentiation testing.** Tier-B checks alignment with Tier-A, not competitive positioning stress-testing — that's `thesis-stress-test` (Layer 5).

## Chain Position

This is **Layer 3** of a 6-layer Productprint research stack:

1. **Core Strategic Truth** (Layer 1) → foundational tension sentence, tension map, JTBD seed, archetypes, lexicon
2. **Productprint Tier-A** (Layer 2) → 10 defensible Playing-to-Win cascade elements with evidence-gated sprints
3. **Productprint Tier-B** (this skill) → uses Layer 2 output as seed; produces 5 actionable strategy elements: bets, roadmap, build/buy/partner, prioritization, risk register
4. **Productprint Tier-C** (Layer 4) → uses Tier-A + Tier-B output as seeds; produces deployment-ready positioning and differentiation elements
5. **Thesis Stress-Test** (Layer 5) → adversarial pre-mortem gate; extracts load-bearing assumptions and tries to FALSIFY them; returns PROCEED if they survive or REFINE (with a constraint package) if one falls
6. **Strategy Thesis Compiler** (Layer 6) → compiles all layers into a consulting-grade integrated strategy thesis deliverable

**When Layer 2 has just completed:** Import its full output JSON directly. Pull Tier-A anchors — `winning_aspiration`, `jtbd_outcomes`, `where_to_play_map`, `how_to_win_hypothesis`, `required_capabilities`, `economic_engine`, `differentiation_wedge` — into the Intake phase. Do not re-research what Layers 1–2 already validated. Carry forward all sources and the contradiction matrix.

**When running standalone:** Resolve all variables with the user. If no Tier-A backbone exists, build a lightweight Backbone Tap from scratch using desk research, but note reduced confidence in the audit log.

## Variables to Resolve

Before starting, confirm these with the user (or inherit from Layers 1–2):

| Variable | What to Capture | Default |
|----------|----------------|---------|
| `product_name` | The product, platform, or solution being researched | *required* |
| `topic` | Product or category scope | *required* |
| `audience` | Primary buyer/operator audience definition | *required* (or from Layer 2) |
| `region_context` | Geography or cultural context | US / English-speaking |
| `constraints` | Scope, legal, or strategic constraints | None |
| `languages` | Output language | English |
| `planning_horizon` | Time window for Now/Next/Later horizons | Now=0-6mo, Next=6-18mo, Later=18mo+ |
| `mode`

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: productprint-tier-c
description: Use when the user asks for Tier-C product positioning artifacts — positioning statement, product one-liner, bet narrative, strategy on a page, deployable differentiation outputs, or Layer 4 of the Productprint stack. Also trigger on "run Tier-C," "Productprint Tier-C," "positioning statement," "product one-liner," "strategy on a page," "roadmap narrative," "bet narrative," or when the user wants deployment-ready strategy artifacts derived from existing Tier-A and Tier-B research. Use immediately when the productprint-tier-b skill has just completed — chain directly using its output as the seed.
---

# Productprint Tier-C — Deployable Positioning Artifacts Directive

Deliver 4 Tier-C positioning artifacts that are deployment-ready, derivative, and human-facing. These outputs create no new strategic claims. Every line traces back to validated Tier-A and Tier-B truths. The job of this layer is translation: take the strategy cascade and make it readable, sticky, and usable by people who were not in the room when it was built.

## When NOT to Use

- **Tier-A or Tier-B output is missing.** This layer needs both as anchors. Without them, either collect equivalent inputs from the user or run the chain from Layer 1 — don't improvise anchors.
- **Creating new strategy or new claims.** Tier-C translates and packages what Layers 2–3 validated. If the product needs a new bet, capability, or differentiation argument, that's a Tier-A or Tier-B sprint, not a Tier-C edit.
- **Long-form copywriting.** Positioning statement, one-liner, bet narrative, and strategy on a page — that's the full scope. Sales decks, website copy, and investor memos are downstream deployment work.

## Chain Position

This is **Layer 4** of a 6-layer Productprint research stack:

1. **Core Strategic Truth** (Layer 1) → foundational tension sentence, tension map, JTBD seed, archetypes, lexicon
2. **Productprint Tier-A** (Layer 2) → 10 defensible Playing-to-Win cascade elements with evidence-gated sprints
3. **Productprint Tier-B** (Layer 3) → 5 actionable strategy elements: bets, roadmap, build/buy/partner, prioritization, risk register
4. **Productprint Tier-C** (this skill) → uses Tier-A + Tier-B output as seeds; produces 4 deployable positioning artifacts ready for team handoff
5. **Thesis Stress-Test** (Layer 5) → adversarial pre-mortem gate; extracts load-bearing assumptions and tries to FALSIFY them; returns PROCEED if they survive or REFINE (with a constraint package) if one falls
6. **Strategy Thesis Compiler** (Layer 6) → compiles all layers into a consulting-grade integrated strategy thesis deliverable

**When Layer 3 has just completed:** Import the full Tier-B output JSON and the Tier-A JSON carried forward. Pull positioning anchors — `winning_aspiration`, `where_to_play_map`, `how_to_win_hypothesis`, `required_capabilities`, `differentiation_wedge` from Tier-A; `strategic_bets`, `roadmap_horizons`, and `risk_register` leading indicators from Tier-B. Do not create new claims or re-research.

**When running standalone:** Resolve all variables with the user. If no Tier-A/B anchors exist, ask the user to provide equivalent inputs (winning aspiration, where-to-play selection, how-to-win hypothesis, required capabilities, differentiation wedge, bet list, risk leading indicators) or recommend running the full chain first.

## Variables to Resolve

Before starting, confirm these with the user (or inherit from Layers 1–3):

| Variable | What to Capture | Default |
|----------|----------------|---------|
| `product_name` | The product, platform, or solution being positioned | *required* |
| `topic` | Product or category scope | *required* |
| `category` | The category frame the product competes in | *required* (or from Tier-A) |
| `audience` | Primary buyer/operator audience definition | *required* (or from Layer 2) |
| `region_context` | Geography or cultural context | US / English-speaking |
| `constraints` | Legal, brand s

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: sales-simulator
description: Practice arena for sales roleplay, pitch stress-testing, and objection drills. Use when the user wants to practice a pitch, simulate a sales call, run objection drills, or get coaching on a real call. Triggers on "sales roleplay," "practice my pitch," "objection practice," "sales coaching," "mock sales call," "stress test my pitch," "play the buyer," "sales simulation." Distinct from pitching-pivot (which teaches the methodology) — this skill IS the practice arena with structured scenarios, scoring, and coaching feedback.
---

# Sales Simulator

The practice arena. `pitching-pivot` is the playbook. This is the field. You do not get good at sales by reading about sales — you get good by doing reps against someone who will not go easy on you.

## Core Philosophy

Question-first discovery: the seller never pitches — they ask questions until the prospect closes themselves. That is what is being practiced here.

The scoring rubric rewards questions over statements. It penalizes premature pitching. It measures whether the buyer stated the ROI, or whether the seller did.

## When NOT to Use

- **You need the methodology, not reps.** `pitching-pivot` is the playbook; this is the field. If you do not yet know the five pivot steps and the objection handles, the simulator will just score you failing them. Learn the framework first, then come here to drill it.
- **You are prepping a specific real call.** `pitching-pivot` prep mode builds the pivot script with anticipated objections for a named prospect. The simulator trains general instincts against personas, not a script for Thursday's meeting.
- **The problem is outreach mechanics.** Low opens, zero replies, deliverability, subject lines — that is `outreach-diagnosis`. This skill scores live conversations; it cannot tell you why nobody is replying to your emails.
- **As a full replacement for live call review.** Debrief mode scores a transcript against the four dimensions, but it cannot hear tone, pacing, or what the buyer's silence meant. Use it alongside real call recordings and peer review, not instead of them.

Determine which mode to run:

| Mode | Trigger | Output |
|------|---------|--------|
| `scenario` | "play a buyer," "let's do a roleplay," "practice with me" | Live interactive simulation with a defined persona |
| `gauntlet` | "gauntlet," "5 rounds," "give me a challenge," "stress test" | 5 escalating scenarios, scored, with final report |
| `debrief` | "debrief this call," "analyze this transcript," "what did I miss" | Diagnosis of a real call + coaching recommendations |

If mode is unclear, ask: "Which mode — scenario (one deep practice run), gauntlet (5 rapid rounds), or debrief (analyze a real call)?"

---

## Mode 1: Scenario

### Setup

Before starting, collect or build the persona:

**Persona inputs:**
- Industry (tech, food/bev, professional services, retail, nonprofit, etc.)
- Company size (solopreneur / 2-10 / 10-50 / 50-200 / enterprise)
- Buyer title (founder, marketing director, ops manager, procurement, etc.)
- Primary concern (what they say they want)
- Personality archetype (see below)
- Budget signal (none given / vague / constrained / flexible)

If the user provides minimal context, generate a persona using the Persona Template below. Ask: "Want me to pick a persona for you or describe who you are selling to?"

### Persona Template

```
PERSONA: [Name, Title, Company]
Industry: [sector]
Company size: [range]
Primary concern (stated): [what they say they need]
Hidden objection (unstated): [what they are really worried about — never reveal until earned]
Budget authority: [full / partial / none — must go upstairs]
Personality archetype: [analytical / driver / amiable / expressive]
Difficulty: [easy / moderate / hard / brutal]
```

### Personality Archetype Behavior Rules

**Analytical** — Data-driven, skeptical, moves slowly. Responds to proof, not enthusiasm. Asks "how do you measure that?" Silence is not discomfort — 

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: story-spine
description: Apply the Story Spine + Emotional Heat Map framework (MM-002) for narrative content. Use when writing origin stories, case slices, LinkedIn posts, founder essays, client wins, or any piece that must hold attention. Triggers on "story spine," "emotional heat map," "establishing shot," "inciting friction," "line surgery," "camera work," "six beats," "case slice narrative," or when content needs stronger hooks, sensory detail, or a clear narrative arc. Includes 6-beat structure, emotion mapping, LinkedIn patterns, revision checklists, and QA rubric.
---

# Story Spine + Emotional Heat Map (MM-002)

A fast, repeatable way to write stories that land. Start with a clear frame, raise stakes on purpose, choose under pressure, show the fallout, and end with meaning a stranger can use tomorrow.

## When to Use

- Origin stories, case slices, client wins, "why we do it" notes
- LinkedIn posts, case-study intros, founder essays, short scripts
- Any piece that must hold attention without fluff

## When NOT to Use

- Not for non-narrative content — framework posts, contrarian takes, and taxonomies run through `linkedin-authority`.
- Not for de-AI-ing existing text — that's `humanize`.
- Not for ideation or concept generation — get the idea with `creative-thinking-ai`, then spine the story.
- Not for pieces with no real event behind them — the beats demand a true scene, choice, and cost. Don't fabricate one.

## The Spine in One View

```
1. Establishing Shot → 2. Friction → 3. Close-ups → 4. Choice → 5. Consequence → 6. Meaning
      where/when        what threatens    details+constraint   costly decision   immediate change   one-line lesson
```

Keep outcome unknown until the final 10–15%.

## The Six Beats

### 1) Establishing Shot
**Goal:** Orient the reader in one line.
**Formula:** Year, city, age or role, scene.
**Example:** 1996, Portland. Age 21. Office manager in title, runner in reality.

### 2) Inciting Friction
**Goal:** Name the pressure that threatens something you care about.
**Prompts:** What specific event kicked this off? What would you lose if you froze?
**Example:** The boss walked in reeking of last night's whiskey. A client call had been missed. Rent was due Friday.

### 3) Escalation in Close-ups
**Goal:** Pull the camera in. Two sensory details. One constraint that tightens the screws.
**Prompts:** What did you see, smell, hear, touch? What timer or limit made it worse?
**Example:** Collar wilted. Eyes glassy. Phone lines blinking. Ninety-two applications already out. Silence.

### 4) Decision Under Pressure
**Goal:** Show the costly choice. State it clean.
**Prompt:** What did you do that had a cost this week?
**Example:** I slid my badge across the desk and said, "I'm done."

### 5) Immediate Consequence
**Goal:** Show what changed in the next day or week. A bruise or a win, not a life story.
**Example:** Eight interviews. Same line each time: "Come back with two years of experience." Then a one-inch ad offering on-the-job training.

### 6) Meaning After the Dust
**Goal:** One sentence a stranger can use.
**Prompts:** What truth did the moment prove? How would someone act differently after reading this?
**Example:** When the room you are in is shrinking you, step into the one where effort is the currency.

## Emotional Heat Map

Target one primary emotion per paragraph. If a paragraph has no emotion, cut it.

| Paragraph | Emotion Target | Signals |
|-----------|---------------|---------|
| 1 | Orientation with unease | Time, place, role, a small off note |
| 2 | Tension rising | Named threat and what is at risk |
| 3 | Anxiety or pressure | Sensory detail and hard constraint |
| 4 | Resolve | Clear choice with a cost |
| 5 | Aftershock | Immediate bruise or first win |
| 6 | Relief or resolve | Useful lesson without preaching |

## Camera Work on the Page

- Start wide. One line.
- Move tighter each beat.
- If you jump tight too early, readers don't know where they are.
- If you 

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: strategy-thesis-compiler
description: Use when all Productprint layers are complete and the user needs the final consulting-grade integrated strategy thesis — Layer 6 of the Productprint stack. Trigger when the user asks to compile the Productprint into a strategy thesis report, create the integrated strategy deliverable, generate a where-to-play how-to-win report, produce the consulting-grade thesis document, or finalize the strategy for a client or internal audience. Also trigger on "compile the thesis," "final strategy report," "integrated strategy deliverable," "strategy thesis document," "Productprint report," or "Layer 6." If the thesis-stress-test skill has just completed with a PROCEED decision, move directly into this skill without waiting for user confirmation.
---

# Strategy Thesis Compiler — Consulting-Grade Integrated Thesis Directive

Assemble all Productprint outputs (Layers 1–5) into a single, cohesive Integrated Strategy Thesis formatted to the standard of top-tier strategy consultancies (Strategy&, EY-Parthenon, Monitor Deloitte, KPMG Strategy). The report is not a summary — it is a synthesis. It resolves contradictions, builds arguments across layers, and delivers a document that a leadership team, board, or investor can act on.

## When NOT to Use

- **Layers are incomplete.** Layers 1–4 are required inputs. Layer 5 (Thesis Stress-Test) is strongly recommended. If Layer 5 is missing, the report must disclose that adversarial validation was not performed and surface the unvalidated load-bearing assumptions — do not compile silently around the gap.
- **Generating new strategy content.** This layer synthesizes what Layers 1–5 produced. If a section needs claims or evidence that do not exist upstream, run the missing layer — do not write it here.
- **Quick one-page summaries.** For a brief, pull the executive summary structure manually. This skill's floor output is 15–20 pages in rapid mode.
- **A REFINE verdict is pending from Layer 5.** Do not compile around an unresolved REFINE. The Assumption-Test Log section must expose the broken assumption and the constraint package — not present a failed thesis as validated.

## Chain Position

This is **Layer 6** — the terminal layer of the Productprint research stack. It consumes ALL upstream JSON (Layers 1–5):

1. **Core Strategic Truth** (Layer 1) → foundational tension sentence, tension map, JTBD seed, archetypes, lexicon
2. **Productprint Tier-A** (Layer 2) → 10 Playing-to-Win cascade elements with claim sheets
3. **Productprint Tier-B** (Layer 3) → strategic bets, Now/Next/Later roadmap, build/buy/partner, prioritization model, risk register
4. **Productprint Tier-C** (Layer 4) → positioning statement, product one-liner, bet narrative, strategy-on-a-page
5. **Thesis Stress-Test** (Layer 5) → assumption ledger, load-bearing assumptions, falsification findings, PROCEED/REFINE verdict
6. **Strategy Thesis Compiler** (this skill) → consulting-grade integrated strategy thesis deliverable

**No forward chain.** This is the terminal layer. Output is the deliverable.

## Variables to Resolve

| Variable | What to Capture | Default |
|----------|----------------|---------|
| `skin` | Report packaging mode (`8gnc-public`, `client-deliverable`, or `internal`) | `internal` |
| `mode` | Output depth (`rapid`, `standard`, or `enterprise`) | `standard` |
| `client_name` | Who receives the report (may differ from product name) | `product_name` |
| `prepared_by` | Firm name for the cover page | *required* |
| `report_date` | Date for the cover page | Current month/year |
| `confidentiality` | Confidential / Internal / Public | Confidential |
| `include_roadmap` | Include Section 6 (Now/Next/Later roadmap) | `yes` |
| `include_financials` | Include Section 7 (economic model) | `yes` |
| `layer_outputs` | JSON outputs from Layers 1–5 | *required* |

## Skin Behavior

The `skin` parameter controls ONLY voice, styling, and packaging. Strategy content, section order, and ev

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: thesis-stress-test
description: Use to run a thesis stress test, strategy pre-mortem, or assumption falsification on a Productprint — Layer 5 of the Productprint stack, the adversarial gate. Trigger on "thesis stress test," "strategy pre-mortem," "assumption falsification," "load-bearing assumption," "what breaks this strategy," "PROCEED or REFINE," "stress-test the thesis," "is this assumption actually true," or when productprint-tier-c has just completed and the integrated strategy thesis needs adversarial validation before compiling. This skill extracts every assumption the strategy rests on, ranks them by fragility, and tries to BREAK the load-bearing few — returning PROCEED if they survive or REFINE (with a constraint package) if one falls.
---

# Thesis Stress-Test — Adversarial Pre-Mortem Gate

This is **Layer 5** of the Productprint stack: the adversarial gate. It does NOT validate that a buyer can tell the product apart from competitors (that is Brandprint's competitive-positioning-audit, a different question for a different deliverable). It runs a **structured pre-mortem on the one assumption that, if false, collapses the whole strategy** — and then tries to prove that assumption false.

Brandprint's gate asks *"can a buyer tell us apart?"* Productprint's gate asks *"what's the one assumption that, if false, kills this thesis — and is it actually true?"* The two-pass loop is preserved, but the second pass is about **truth-hardening**, not vocabulary-dodging.

## ADVERSARIAL STANCE (read before anything else)

> **You are adversarial. Your job is to BREAK the thesis.**
>
> - Do NOT look for confirming evidence. Look for the single fact that makes the strategy collapse.
> - Counter-evidence is the **success condition** of this skill, not a failure. Finding the killing fact is the point. A falsification pass that only assembles supporting evidence has not done its job.
> - **A gate that always says PROCEED is broken.** If you cannot remember the last time a gate like this returned REFINE, you are confirming, not falsifying. Assume the thesis is wrong and go hunting for the proof.
> - Frame every research query as a disconfirmation query: "find evidence that X is false," never "find evidence that X is true."
> - An assumption that *survives* a genuine attempt to break it has earned its place. An assumption that was never genuinely attacked has not — the verdict is meaningless without a real attack.

## When NOT to Use

- **No upstream Productprint exists.** This gate tests Tier-A/B/C output; it does not create strategy. Run Layers 1–4 first.
- **You want competitive differentiation testing.** That's "can a buyer tell us apart?" — a Brandprint question, not a strategy-thesis question. This gate tests whether the strategy is *true*, not whether it is *distinctive*.
- **Category white-space mapping.** Use `competitive-teardown`. This skill tests assumptions the strategy already made, not the open category.

## Chain Position

This is **Layer 5** of the 6-layer Productprint stack. It **consumes the Tier-A + Tier-B + Tier-C JSON**:

1. **Core Strategic Truth** (Layer 1) → foundational tension sentence, JTBD seed, lexicon
2. **Productprint Tier-A** (Layer 2) → 10 Playing-to-Win cascade elements, each with a claim sheet
3. **Productprint Tier-B** (Layer 3) → strategic bets, Now/Next/Later roadmap, build/buy/partner, prioritization, risk register, each with a claim sheet
4. **Productprint Tier-C** (Layer 4) → positioning statement, one-liner, bet narrative, strategy-on-a-page, each with a claim sheet
5. **Thesis Stress-Test** (this skill) → assumption ledger → fragility ranking → falsification → PROCEED/REFINE
6. **Strategy Thesis Compiler** (Layer 6) → compiles all layers into the consulting-grade integrated thesis

**When Layer 4 has just completed:** Import the full Tier-A, Tier-B, and Tier-C JSON. Walk every `claim_sheet` to extract assumptions. Inherit `evidence_mode` (`greenfield` | `existing-product`) and `mode`

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: ux-ui-psych
description: Execute the UX/UI Psych choice architecture playbook (PLAY-002). Use when designing product menus, ordering flows, kiosk UX, upsell/cross-sell intercepts, or any conversion flow that needs behavioral nudges. Triggers on "choice architecture," "default selection," "upsell intercept," "cart cross-sell," "decoy pricing," "progress bar," "nudge," "contextual bandit," or when optimizing attachment rates and average check. Includes scoring functions, personalization rules, experimentation standards, accessibility specs, and dark-pattern guardrails.
---

# UX/UI Psych — Choice Architecture (PLAY-002)

Design defaults and frames so the easiest path is also the most profitable and ethical path. Use proven nudges, honest anchors, real personalization, and experimentation that does not lie to you.

## When NOT to Use

- **Funnels without the volume to learn.** The experimentation standards here demand power analysis up front and contextual bandits by week 5. If your traffic cannot feed enough exposures to power the tests you design, the bandits never converge and the A/Bs lie to you. Ship the rules-based defaults and Slot-1 ladder, skip the learning loop until volume exists.
- **No consent or privacy infrastructure.** Personalization runs on past orders, location, and context signals, and the ethics telemetry requires tracking opt-outs and consent symmetry. If you cannot capture consent properly, you cannot run this playbook ethically — and "no pre-checked consent boxes" is a hard rule, not a suggestion.
- **Operations that cannot absorb demand shifts.** Every recipe here is kitchen-aware: station capacity guardrails, prep-time thresholds, a kill switch tied to SLA risk. If fulfillment cannot flex when upsells land, you are trading order accuracy and throughput for attachment rate. Fix capacity first.
- **The pricing architecture itself is the problem.** This skill optimizes how customers select from a ladder that already exists. If the anchor, upgrades, and bundles are not designed yet, start with `fairness-anchor-ladder`.

1. Preselect a sane default or bundle that most customers actually want.
2. Lead with a premium anchor so the hero feels reasonably priced.
3. Insert one interstitial upsell after add-to-cart and a second pass in cart.
4. Rank suggestions with a scoring function, then let contextual bandits learn.
5. Measure attachment, average check, and throughput weekly. Kill weak patterns.

## Principles

1. **Choice beats chance.** Choreograph decisions so the right path is the easy path.
2. **Defaults decide.** Most users keep the preselected option if it is fair and clear.
3. **Anchors frame reality.** Start with a premium reference, then present the target hero.
4. **One nudge, not a maze.** Intercept once after add, and once in cart if the gap remains.
5. **Progress pulls.** Steps and progress bars speed completion near the finish line.
6. **Personal is powerful.** Day-part, weather, and order context matter more than slogans.
7. **No trickery.** Study dark patterns so you never ship them.

## Pattern Architecture

### Frame
- **Top of screen:** premium anchor, then target hero. Sticky mini-basket.
- **Same frame selection:** upgrade chips directly under the hero. No second page.
- **One-tap/two-click rule:** attach Slot-1 without leaving the flow.

### Ladder
- **Slot 1:** Sane add-on with highest attachment.
- **Slot 2:** Signature upgrade with highest margin.
- **Slot 3:** Novelty or seasonal.
- **Bundles:** Hero plus Slot-1 at a small discount.

## Scoring and Decisioning

**Candidate set:** items not in cart that meet constraints (in stock, prep time under threshold, station capacity, allergen safe).

**Score function:**
```
score(item, context) =
  w1·margin +
  w2·attach_rate_by_context +
  w3·popularity_now +
  w4·personal_affinity +
  w5·inventory_pressure
  − penalties(allergens, station_load, SLA_risk)
```

**Learning:** contextual bandits to balance explore vs exploit. Start rul

Preview of the first 4,000 characters. Read full instructions →

View saved version →

---
name: voice-profiler
description: Interview the user about their writing and analyze their real samples to generate a reusable voice profile for the humanize skills. Use when the user asks to build or update a voice profile, identify their writing voice, make future drafts sound more like them, or before humanize when no profile exists.
---

# Voice Profiler — Build Your Writing Voice Profile

Act as a writing voice analyst. Interview the user, analyze their real writing samples, and produce a structured voice profile file that the `humanize` skills can use.

## Why This Matters

Generic model drafts repeat predictable patterns. `humanize` can edit those patterns, but a voice profile supplies the user's actual rhythm, vocabulary, and preferences. The goal is not generic humanity; it is faithful voice.

## The Interview Process

This is a conversation, not a form. Adapt based on what the user gives you. Some people will paste 10 writing samples and let you figure it out. Others will want to describe their voice. Both work.

### Phase 1: Collect Writing Samples (Most Important)

Ask the user for 3-5 real writing samples. These are the foundation — everything else is derived from or validated against these.

**What to ask for:**
- "Paste 3-5 pieces of writing you're proud of. Emails, LinkedIn posts, proposals, website copy, tweets — anything that sounds like YOU at your best."
- If they have a file with samples: "Point me to a file with your writing and I'll analyze it."
- If `$ARGUMENTS` contains a file path, read that file for samples.

**What to look for in samples:**
1. **Sentence rhythm** — What's their natural cadence? Short-long-short? All punchy? Long and flowing?
2. **Opening patterns** — How do they start pieces? Cold open? Story? Question? Direct statement?
3. **Closing patterns** — How do they end? Call to action? Reflection? Punchline? Just stop?
4. **Vocabulary fingerprint** — Words they reach for repeatedly. Phrases that are distinctly theirs.
5. **Grammar personality** — Fragments? Run-ons? Perfect grammar? Contractions? Formal/informal mix?
6. **Emotional range** — Do they show humor? Frustration? Vulnerability? Confidence? What's the baseline?
7. **Persuasion model** — How do they convince? Data? Story? Authority? Diagnosis? Challenge?
8. **Register shifts** — Do they stay in one gear or shift between casual and formal?

### Phase 2: Guided Questions

After analyzing samples, fill gaps with targeted questions. Only ask what you can't already see in the samples.

**Identity & Context:**
- "What do you do? How would you describe your role in one sentence?"
- "Who do you write for most often? (clients, colleagues, public audience, specific industry)"

**Voice Preferences:**
- "Are there words or phrases you HATE seeing in writing? Things that make you cringe?"
- "Any words or phrases that are distinctly yours — things people associate with how you communicate?"
- "When you read your own writing back, what makes you think 'yeah, that sounds like me'?"

**Style Preferences:**
- "Do you prefer short and punchy or detailed and thorough?"
- "How do you feel about humor in professional writing?"
- "Do you sign off a specific way? (signature, sign-off phrase, etc.)"

**Anti-Patterns:**
- "What kind of writing makes you physically uncomfortable? Corporate jargon? Fake enthusiasm? Over-qualification?"

### Phase 3: Synthesis & Validation

Before generating the profile, play back what you've found:

"Here's what I see in your voice: [2-3 sentence summary]. Does that sound right, or am I missing something?"

Let them correct you. The profile should feel like looking in a mirror, not a caricature.

## Output: The Voice Profile File

Choose the destination with the user:

- **Codex with local file access:** prefer `./.8gnc/voice-profile.md` for a project-scoped profile. Offer `~/.config/8gnc/voice-profile.md` only for a user-wide profile and write there only after explicit permission.
- **ChatGPT or another surface without 

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 1 — file references are metadata, not package contents.