@aicopycoders/exodus 2026.9.1100-beta.3 → 2026.9.1400-beta.1

package/assets/docs/CLAUDE.md

@@ -4,7 +4,7 @@
 
 This is a creative-strategy workspace operated by the **exodus** CLI. It is brand-agnostic infrastructure serving **all of the account's brands**: each brand has its own subfolder here (marked by a `.exodus-brand.json` file) holding that brand's `state/` and `output/`. Which brand you're working on resolves **folder first, pointer second**: commands run from inside a brand's subfolder target that brand automatically; otherwise the `npx @aicopycoders/exodus brand use <slug>` pointer applies. (Older single-brand installs keep `state/` and `output/` at this root — same rules, one brand.)
 
-**How to engage the system:** every skill here is namespaced `exodus-*`, and a front-door `exodus` hub skill routes generic asks. Members say "exodus" to engage ("exodus, write me some ads") or invoke a specific skill with `/exodus-<name>` (e.g. `/exodus-write`). This namespacing is deliberate: it lets these skills coexist with other skill packs (like the workshop pack) installed in the same folder, and it keeps the bare word "Genesis" unambiguous — on its own, "Genesis" always means the member's own Genesis API key/recipes, never Exodus. CLI commands are unchanged (`npx @aicopycoders/exodus genesis`, `npx @aicopycoders/exodus brand use`, etc.).
+**How to engage the system:** two families of skills live here. The pipeline skills are namespaced `exodus-*`, and a front-door `exodus` hub skill routes generic asks. The method skills (Luke's thinking as skills: `odf`, `mechanism`, `copy-instincts`, and the rest, listed under **Method skills** below) carry plain names and fire on what the user is trying to do. Members say "exodus" to engage ("exodus, write me some ads") or invoke a specific skill with `/exodus-<name>` (e.g. `/exodus-write`). This namespacing is deliberate: it lets these skills coexist with other skill packs (like the workshop pack) installed in the same folder, and it keeps the bare word "Genesis" unambiguous — on its own, "Genesis" always means the member's own Genesis API key/recipes, never Exodus. CLI commands are unchanged (`npx @aicopycoders/exodus genesis`, `npx @aicopycoders/exodus brand use`, etc.).
 
 The strategist persona, the Luke Mills / Genesis frameworks, the operating rules and creative principles, and the operating discipline all live in **one skill** plus its references:
 
@@ -64,11 +64,33 @@ These are the **Exodus** pipelines — the automatic system that drives the Gene
 | **Video** | `exodus-video` | Make a video ad from a Show: start a run from a script, read and approve the storyboard, `npx @aicopycoders/exodus video pull` every piece (per-scene clips, voices, keyframes, word timings, music bed) plus a manifest, cut them with the bundled first-cut script, upload the cut and approve it. Admin-only. |
 | **Browse** | `exodus-browse` | View history and retrieve past outputs |
 | **Drive** | `exodus-drive` | Read/write Google Docs, Sheets, and Drive files via `npx @aicopycoders/exodus drive` (uses the dashboard's Google OAuth — no local CLI) |
+| **Swipe / Mining** | (no skill; CLI only) | The competitor watch list behind the Mining page: `npx @aicopycoders/exodus swipe brands list`, `swipe brands bulk-import <csv>` (checks each brand and starts collecting its ads), `swipe brands add "<Name>" --fb <pageId>` (adds without starting research, #1366), `swipe run` / `swipe mine`. There is no `competitors` verb. |
 | **Ads** | `exodus-ads` | Read your own live Meta ads once the account is connected on the dashboard — `npx @aicopycoders/exodus ads list` (sort by cost per result, spend or CTR), `ads show <adId>` (copy, both windows, media links, comment counts), `npx @aicopycoders/exodus comments list` (already commenter-redacted), and `npx @aicopycoders/exodus winners definition` (what this brand means by a winner). Read-only; no Meta login or MCP needed. |
 | **Winners** | `exodus-winners` | Mine your own Meta ad account for winning ads and import them into Exodus as generative fuel — interview, visual confirmation, `npx @aicopycoders/exodus winners import`. A brand whose Meta account is connected reads its ads and its winner definition straight from Exodus; only an unconnected brand needs the Meta Ads MCP. |
 
 For the operator-facing quick reference on how to invoke these in Claude Code, see `PIPELINES.md` in the workspace root.
 
+### Method skills (Luke's thinking, in Claude Code)
+
+These are not pipelines. They are Luke's methods written as skills, so the thinking that happens *before* a pipeline runs (who to sell to, what the mechanism is, which competitors matter, what patterns the account shows) happens with the same discipline every time. They run as a conversation with whatever data the user has; some push results into Exodus through the CLI. Anything they write lands inside the active brand's subfolder (`<brand>/state/` for decided artifacts, `<brand>/inputs/` for research), so run `brand current` first. Invoke one by name (`/odf`) or just describe the job.
+
+| Skill | When to Use |
+|-------|-------------|
+| `thinking-vs-build` | Load first whenever a session does method work (positioning, research, critique). The two modes (think: short lists, one axis per message, propose then the user cuts; build: the full thing, no check-ins) and how to tell which one a message is in. |
+| `positioning-spiral` | Positioning a product before any ads: cycles through features, targets, research, catalog, and thinking until segments, mechanisms, and story hang together. Calls the four station skills below. |
+| `odf` | Who to sell to. Outcome × Demographic × Facet, one axis at a time. MAP (build the grid), PERSONAS (named humans that live in Exodus), HORIZONTAL (aim a winner at a new segment). Pushes with `npx @aicopycoders/exodus segment`. |
+| `mechanism` | The product's unique mechanism of the problem and of the solution, per segment. Uses the Genesis mechanism bots for breadth (needs `GENESIS_API_KEY` plus a provider key), works as a conversation without them. |
+| `find-competitors` | Who is actually strong in a niche, on Meta first and Amazon second. Ranked competitor sheet and a watch list. Optional scripts for Atria and the Meta Ad Library via Apify (each needs its own key; they bill per result and say the plan back before spending). |
+| `patterns-and-gaps` | What repeats and matters across own ads, competitor ads, organic content, and research, read layer by layer, and the three kinds of gap. |
+| `anatomy-of-ads` | The parts list of an ad (Messaging × Creative). Write a brief, dissect any ad into the same parts, tag a batch so patterns can be counted. Also the vocabulary the other skills use. |
+| `copy-instincts` | See, Attract, Make. Run on a draft that already exists (hook, ad, mechanism paragraph) to take it from good to great. |
+| `bot-builder` | Build a custom bot the way Luke and Mario build the Genesis bots (SEAK), and put it where it runs: an Exodus workflow Prompt node, a Genesis bot, or a skill. |
+| `remember-that` | Bank one reaction mid-session ("remember that", "never do X") into `STANDARDS.md`, and push approved winning lines to the matching Exodus bank. |
+| `handoff` | End a session: scrape the chat into `workflow/sessions/`, propose standards, write a resume prompt, update the one-page workflow. "handoff review" reads the sessions back. |
+| `segment-grid` | The earlier segment-grid kit. Superseded by `odf`; kept for existing hand-off docs. |
+
+**Standards and handoff.** `STANDARDS.md` at the workspace root is the user's taste, written where the system always reads it. Every method skill reads it before producing anything and grades its draft against it. The install creates it once from a template and never overwrites it. Mid-session, "remember that" banks a reaction through `remember-that`. At the end of a session, "handoff" scrapes the chat and proposes standards; nothing is written without a yes. At the start of a session, check the newest file in `workflow/sessions/` (if the folder exists); when it has a **Resume** section, offer to continue from it.
+
 ### Genesis bots (manual)
 
 The same folder usually also carries **`genesis-bots`** — the *manual* way to drive the same Genesis bots. You pick a bot and prompt it yourself with the member's own `gen_` key, chaining bots by hand (buyer profile → creative brief → ad hooks → ads). It is **not** an `exodus-*` skill and is **never** invoked by saying "exodus".

package/assets/docs/PIPELINES.md

@@ -23,6 +23,26 @@ In Claude Code you don't click buttons. You say **"exodus"** plus what you want
 
 ---
 
+## Method skills (Luke's thinking)
+
+Not pipelines. These run as a conversation and shape the thinking before a pipeline fires. Call one by name or describe the job.
+
+| Skill | Say things like |
+|-------|-----------------|
+| thinking-vs-build | (loads at session start) "let's think", "basic list", "just the outcomes" vs "build it", "let it rip" |
+| positioning-spiral | "who do we sell this to and what's the story", "are we positioned right" |
+| odf | "map the segments", "build personas from the comments", "aim this winner at a new segment" |
+| mechanism | "what's the mechanism", "which ingredient leads", "name the problem" |
+| find-competitors | "who's scaling in this niche", "build me a watch list" |
+| patterns-and-gaps | "what patterns do you see", "what are they doing that we aren't" |
+| anatomy-of-ads | "break this ad down", "tag these ads", "write me a brief" |
+| copy-instincts | "make this hit harder", "what's wrong with this ad", "find the big idea" |
+| bot-builder | "build me a bot that…", "turn this into a prompt", "make a node for the workflow" |
+| remember-that | "remember that", "never do that again", "lock that in" |
+| handoff | "handoff", "wrap up", "what did we do today", "handoff review" |
+
+They read `STANDARDS.md` (your taste, at the workspace root) before producing anything. `remember-that` adds to it mid-session; `handoff` proposes additions at the end and writes session files to `workflow/sessions/`.
+
 ## exodus-write (start here)
 
 **What it does:** The guided front door for copywriting. You don't need to know which command to run — say "exodus" plus what you want and the exodus-write flow figures out where you are, helps shape the brief, sets up your foundation if needed, runs Genesis, and hands back the Google Doc.

package/assets/skills/anatomy-of-ads/SKILL.md

@@ -0,0 +1,138 @@
+---
+name: anatomy-of-ads
+description: Luke's anatomy of an ad, Messaging × Creative, used three ways: to write a brief before an ad exists, to dissect any ad (own, competitor, organic) into the same parts, and to feed patterns-and-gaps so patterns are found layer by layer. Messaging is WHO (segment / persona) × WHAT (concept / angle, mechanism UMP / UMS, copy blocks, copy beats) × HOW (hook, structure). Creative is static (native, template, branded) or video (conceit, actors, style, terrain, setup). Use it whenever someone says "break this ad down", "what's the DNA of this", "tag these ads", "what's the angle here", "write me a brief", "which layer changed", "what would I swap", or hands over a transcript, a swipe file, or a batch of their own ads and wants them read the same way. Also the vocabulary every other skill uses for ads: when a user says format, conceit, angle, concept, or beat, this is what they mean. Carries the beat map, the angle families, the insight-vector operations, the hook rules, and the swap-cost rule in references.
+---
+
+# Anatomy of an ad
+
+Every ad is the same set of parts. Once you can see the parts, you can write a brief by filling them in, dissect anyone's ad by reading them out, and find patterns by counting each part across a set instead of squinting at whole ads. This skill is the parts list and the tests for each part.
+
+Think mode for a read or a brief (lists, one layer at a time). Build mode for tagging a batch. Read `thinking-vs-build` if installed.
+
+## The grid
+
+```
+MESSAGING
+  WHO   = Segment / Persona
+  WHAT  = Concept / Angle (the core idea, the point of the ad)
+          Mechanism (UMP, UMS, or both)
+          Copy Blocks (what's present, what's added, what's missing)
+          Copy Beats (from the beat map; added or missing)
+  HOW   = Hook
+          Structure (format)
+
+CREATIVE
+  Static = Native · Template (many types) · Branded
+  Video  = Conceit (what media it pretends to be) · Actor(s) · Style · Terrain · Setup
+```
+
+The same parts as a stack, top to bottom, each layer constraining the next: **Market** (segment, persona, awareness) → **Substance** (concept, mechanism, proof) → **Frame** (the angle) → **Structure** (the skeleton, an ordered set of beats filling block roles) → **Rendering** (medium, then conceit, actor, style, terrain, setup) → **Surface** (the literal words and pixels; the hook is the top of it).
+
+## The rule that orders the stack
+
+The deeper a part sits, the less meaning it carries and the cheaper it is to swap. A style swap changes nothing the buyer has to believe. A format swap changes delivery, not the answers. An angle swap changes the doorway, not the claim. A concept swap is a new bet. A segment swap is the most expensive bet on the board.
+
+Same list read as what kills you if wrong: segment and mechanism are driver genes, get them wrong and you are at zero; style is cosmetic, get it wrong and you are at minus thirty percent.
+
+So: every launch should be one cheap swap away from something proven. Luke's order of what to play with most, for video especially: segment, format, style, conceit.
+
+## The layers, with their tests
+
+### WHO: segment / persona
+
+Three parts, ODF: Outcome (what they want), Demographic (what you could tick from across the room), Facet (why they are here: belief, state, value, occasion). One outcome × one demographic × a facet or two. Change any part and it is a different human and usually a different ad. The facet is the underrated axis: self-verifiable in one second and usually carrying its own mechanism ("do you sit six hours a day?" → blood flow). A persona is the segment with its evidence attached: the verbatim quotes, the awareness the facet sets, the failed solutions in their language. Awareness rides on top; it is not inside the segment. Depth: `odf`.
+
+Tag test: could you say who this ad is for in the ODF shape from the ad alone? If it only names a demographic ("women over 40"), the facet layer is empty; that is the usual gap.
+
+### WHAT: concept / angle
+
+Concept is the raw truth, the flat fact, the WHAT. Angle is the psychological frame wrapped around it, the WAY IN. Tell: if you can say it flat, with no villain, no feeling, no "you", it is a concept. One fact, "vitamin D deficiency is linked to depression", through five angles: conspiracy ("why your psychiatrist will never check your vitamin D"), geographic ("why almost nobody in sunny Dubai gets seasonal depression"), accidental discovery ("a lab tech's mistake revealed what vitamin D does to serotonin"), countdown ("the FDA is moving to restrict high-dose vitamin D in 30 days"), enemy admission ("even the people who make antidepressants quietly take this").
+
+The precise version: a concept is a causal diagram, not a sentence. Same graph, same concept, even if the words differ. An angle is which role in that graph you star: star the adversary and it is a conspiracy ad; the discoverer, a breakthrough ad; the experiencer, a story ad; the clock, a warning ad. The affordance rule: an angle is available only if a fact fills its role. No admitting insider, no enemy-admission ad.
+
+Two asymmetries. Concepts burn out ("cortisol belly" saturates); angle families do not (conspiracy as a frame never wears out). You have a handful of true concepts and almost unlimited angles, so most firepower goes into angles. And why split them: if timeline ads keep winning, the market is responding to the angle; if "silver" keeps recurring across stories and conspiracies alike, it is responding to the concept.
+
+Angle families: Discovery · Urgency · Authority · Conflict · Story · Reframe. Full list, the affordance roles, and the insight-vector operations that generate concepts: `references/concept-angle.md`.
+
+### WHAT: mechanism (UMP, UMS, or both)
+
+UMP is the hidden reason behind the problem ("why were you able to figure out this hidden cause when other experts haven't"). UMS is the unique solution and how it was found ("how did you uniquely discover this when everyone else missed it"). The concept is the destination (the one-sentence edit: "your bloating is parasites"); the mechanism is the route that gets the edit accepted. The modal shape in winning ads is the re-diagnosis: relabel ("it's not fat, it's sludge"), install the hidden cause, sweep the retrodictions (it must explain their symptoms, every prior failure, and why it is worse now), draw the edge to the solution, gate it with a verification ritual.
+
+The brand gate is the beat the beat map does not have and the winning corpus runs most consistently: only this version of the solution reaches the cause. Generic is dead → sourcing specifics → a way to verify. Tag it in or beside the mechanism field. Naming: body thing plus what it is doing wrong, and the name must imply the fix. Depth: `mechanism`.
+
+### WHAT: copy blocks
+
+Six: Pain, Promise, Proof, Curiosity, Constraints, Conditions. Rate each present block 1 to 10 and name what is missing. The rule that matters for added/missing: curiosity is the only block unique to the product, because it holds the mechanism; the other five belong to the market and every competitor can say them. No curiosity block, no engine. Test for a line: paste it into a competitor's ad; if it still works, it is grey. Depth: `copy-instincts`.
+
+### WHAT: copy beats
+
+The beat map is fourteen narrative beats reverse-engineered from VSLs, each defined by the subconscious question it answers. It is the story of the product, and it is where the point of an ad usually comes from: read down the beats and one of them is the ad. Short video forces ten more beats into existence that the map does not list: call-out, absolution ("it's not your fault, it's the mechanism", arguably the highest-leverage beat there is), demonstration, future pacing, comparison, offer reveal, CTA, re-hook, qualification, belonging.
+
+Added/missing is a verdict audit: tag every line with the belief it is there to close, then ask which beliefs are left unreached and whether the market's awareness already covers them. Overbuilt shows as bloat (the timing beat is the usual offender); unreached shows as the reason it did not convert (risk is the usual gap). Full map and the nine verdicts: `references/beat-map.md`.
+
+Copy melodies: "more specific psychological moments, lines, or clusters we might add." Only one line of definition exists. The nearest concrete material is the Make moves in `copy-instincts`. Open.
+
+### HOW: hook
+
+The hook is concept plus angle compressed to the fewest, sharpest words. Structurally it is a beat promoted to slot zero, usually the body's organising beat; when hook and body diverge too far you pay the clickbait tax (high CTR, dead conversion). Hooks rotate independently of the body: five hooks on one identical body is a clean experiment, and the way to test is five made maximally different, not five micro-variations.
+
+Craft rules: immediate relevance · charged words (object words and action verbs) · an open loop · stakes · specific and tangible · caveman-simple · consequence first, mechanism later · Germanic over Latinate · one sentence · a 1 to 3 intensity dial · always some wildcards. "Most language is filler, filler, filler, then a point. Be clear what the point is and let the rest be caveman."
+
+For unaware traffic, the straddle: curiosity plus relevance in the first line. Relevance has four levels of charge: existential → mechanism → condition → sensation. The onion ladder shows the dial from unaware to problem-aware: what onions do to you → your body → your health → your blood sugar → your neuropathy. Full rules and ladders: `references/hook-and-structure.md`.
+
+### HOW: structure (format)
+
+The word "format" hides four dials. Say which one you mean: **medium** (static, video, carousel), **skeleton** (beat order), **conceit** (what it pretends to be), **style** (visual gloss). On Luke's own list, podcast and 80s retro news are conceits, timeline and specimen VSL are skeletons, UGC is a style and actor choice, song ad is a conceit with a style.
+
+Structure proper is the skeleton: the beat order. A format is a beat promoted to spine, the way a hook is a beat promoted to slot zero, which is why "conspiracy timeline" reads as one thing: the adversary beat is both spine and hook. Skeletons are walks through the concept graph: a timeline narrates it forward, a mechanism explainer walks back from symptom to root, an exposé radiates out from the adversary. Luke's short-ad skeleton: HOOK → POINT → MECHANISM → OFFER. Awareness collapses skeletons: each notch up collapses the middle beats because their beliefs arrive pre-closed. Format beats copy (the Lampropoulos principle): the same copy in a new format has been the massive winner more than once.
+
+### CREATIVE
+
+**Static:** native (looks like a post, a screenshot, a text thread), template (the fifty-odd structured ad types: testimonial, before-and-after, comparison, sign-holder, infographic, and so on), branded (the product is the picture).
+
+**Video:** conceit (street interview, podcast, on stage, doctor visit, customer call, cue cards, news desk), actor (founder, nurse, customer, cartoon, nobody, method-acted prospect), style (UGC, Pixar, claymation, greenscreen, whiteboard, mummies), terrain (where it is shot: kitchen, car, clinic, stage), setup (the situation the conceit needs in place: a phone being shown, a whiteboard already drawn, two chairs). The conceit is the hinge between message and creative: the last decision about how you say it and the first about how you show it. A customer-call script has two voices; a cue-card script is one beat per card. Test for any creative element: does it carry the message, or just host it?
+
+## Three uses
+
+### 1. Tag an ad (the read)
+
+One ad in, one filled grid out. Quote the ad for every field; do not paraphrase.
+
+```
+AD: <id / brand / source / run days or result>
+WHO      segment (O × D × F) · persona if named · awareness caught at
+CONCEPT  the flat fact, one sentence (or "none: a pure angle on a market truth")
+ANGLE    family · role starred · the door line, quoted
+MECH     UMP (the named cause) · UMS (the named fix) · brand gate present? · name implies fix?
+BLOCKS   pain n/10 · promise n/10 · proof n/10 · curiosity n/10 · constraints n/10 · conditions n/10 · missing:
+BEATS    in order as they appear (from the map + the ten) · overbuilt: · unreached:
+HOOK     quoted · which beat promoted · intensity 1–3 · straddle / symptom / worldview / story
+STRUCT   medium · skeleton (beat order in five words) · conceit · style
+CREATIVE static: native / template:<type> / branded · video: conceit · actor · style · terrain · setup
+SWAP     the cheapest swap that would make this a different ad · the expensive one
+NOTE     one line: why it works or why it died
+```
+
+For a single winning ad that deserves a full dissection, the `message-isolator` Genesis bot returns an eight-layer message object with exact quotes; run it, then fill the grid from it.
+
+### 2. Write a brief (the build)
+
+Same grid, filled before the ad exists, top to bottom because each layer constrains the next: segment and awareness first, then concept and mechanism, then angle, then the beats the awareness level still needs, then hook candidates (five, maximally different), then skeleton, then the creative choices with the conceit chosen last on the messaging side and first on the creative side. A brief with an empty curiosity row or an unnamed mechanism is not ready to write.
+
+### 3. Feed patterns and gaps
+
+Tag a set of ads with the grid, then count per layer: which segments, which angle families, which mechanism words, which beats, which hooks, which conceits. A pattern in one layer with the others held constant is what tells you what the market is responding to. Hand the counts to `patterns-and-gaps`; it reads them by layer and finds the gaps by layer.
+
+When a definition here is unsettled for your brand (concept versus angle, where the brand gate sits), bank the call with `remember-that` and it becomes the rule here.
+
+## Worked read (fictional)
+
+A competitor ad in the fictional cortisol lane, 289 days running. WHO: cortisol belly × women 45 to 60 × "tried everything" (solution-aware). CONCEPT: night-time cortisol keeps fat locked on the midsection. ANGLE: Authority, discoverer starred: a nurse who "sees it a thousand times a week". MECH: UMP "cortisol lock" (name implies a key), UMS the two-ingredient evening blend; brand gate present ("most ashwagandha is root powder; ours is the standardised extract"). BLOCKS: pain 9, promise 7, proof 6, curiosity 8, constraints 5, conditions 7; missing: a risk line with teeth. BEATS: call-out → symptom stack (problem narrative) → failed solutions → UMP → absolution → UMS → demonstration → timeline → offer; overbuilt: momentum; unreached: risk. HOOK: "You're not fat. Your cortisol is." Beat promoted: absolution. Intensity 3. Symptom hook. STRUCT: video, skeleton = diagnosis-then-timeline, conceit = clinic visit, style = UGC with lower-thirds. CREATIVE: actor nurse in scrubs, terrain clinic hallway, setup a clipboard. SWAP: cheapest = style (shoot it as a phone call); expensive = segment (men 35+). NOTE: works because the absolution beat is the hook and the spine, and the brand gate lands before the offer.
+
+## What this skill is not
+
+It does not choose the segment (odf), find the mechanism (mechanism), or write the ad. It is the parts list every one of those skills refers to, and the read that turns any ad into comparable data.
+
+## Standards
+
+Before producing anything, read `STANDARDS.md` at the workspace root (and the section for this output type). Grade the draft against it before showing it; rewrite failures first. When the user reacts with a judgment, a banking phrase, or the same note twice, hand the reaction to `remember-that`. At the end of the session, `handoff` scrapes the chat and proposes entries.

package/assets/skills/anatomy-of-ads/references/beat-map.md

@@ -0,0 +1,69 @@
+# The beat map
+
+Fourteen narrative beats reverse-engineered from VSLs. Each answers a subconscious question the reader has before they can say it, and each is fodder for hooks, ads, emails, and curiosity content. Read down the beats to find the point of an ad. Tag an ad's lines to beats to find what is overbuilt and what is unreached.
+
+| # | Beat | The question it answers | Sub-beats | Example |
+|---|---|---|---|---|
+| 1 | Speaker background and credibility | Who are you, and why should I listen to you about this? | general background · credentials · personality and perspective | "As a former yo-yo dieter myself, I know firsthand how demoralising it is to try every diet trend and end up back where you started." |
+| 2 | Problem narrative | Do you actually understand what I'm going through, and how serious it is? | early warning signs · worsening · crisis point · emotional nadir | "I found myself walking on eggshells, afraid to say anything that might set her off." |
+| 3 | Failed solutions | Why hasn't anything I've tried worked, and why is yours different? | common advice is wrong · common remedy makes it worse · comparisons | "Cutting carbs seems like the holy grail, but when you slash them your body goes into full panic mode." |
+| 4 | Myths and mistakes | What beliefs am I relying on that are making it worse? | prevailing myths · costly mistakes | "One of the biggest myths about building wealth is that you need a high-paying job or an inheritance." |
+| 5 | Unique mechanism preview (UMP) | Why were YOU able to figure out this hidden reason when other experts haven't? | discovery narrative · UMP trigger | "A landmark study uncovered a psychological trigger that makes women feel an uncontrollable pull. Dr. Hoffman calls it 'the Lovemap Loophole'." |
+| 6 | UMP cause | What's REALLY causing it, and who or what is responsible? | surprising culprit · UMP adversaries | "The food industry adds AGEs to enhance flavour and shelf life, putting profits over people's health." |
+| 7 | Unique mechanism elaboration | If this explains my issue, why doesn't everyone have it, and why is it worse now? | individual differences · changing landscape · unspoken truth | "In the past there weren't many emulsifiers in food. Now the amount has skyrocketed by more than 340%." |
+| 8 | Self-reflection | How do I know this applies to ME? | UMP quiz | "Do you eat a lot of processed food? Cook at high temperatures? Struggle with belly fat despite eating well?" |
+| 9 | UMS preview | How did you uniquely discover this solution when everyone else missed it? | UMS trigger | "After a devastating breakup I stumbled on an ancient Tibetan manuscript that revealed 'Emotional Resonance'." |
+| 10 | UMS characterisation | How can you prove the solution is simple, intuitive, unique, and different? | blind / curiosity characterisation · single-step action · transformational roadmap · taboo reframe | "To trigger his response, all you need to do is whisper one specific phrase in his ear." |
+| 11 | UMS tips and secrets | Can you give me value right now, before I commit? | how-tos, tips, ingredients, secrets | "One simple trick to create instant connection is to mirror their body language." |
+| 12 | Creating the solution | How do I know this is credible, tested, and proven? | attempts and failures · first user success · unsolicited requests · zero-to-hero testimonials | "'I've struggled with my weight since high school… after 30 days I'm down 23 pounds' — Lisa H." |
+| 13 | Momentum | Why act now instead of thinking it over? | urgency · scarcity | "We can only accept a limited number of couples to ensure personal attention." |
+| 14 | Risk | What if it doesn't work, and what happens if I do nothing? | risk reversal · guarantees | "If you don't see a significant increase in 90 days, we refund everything and add a bonus session." |
+
+The UMP trigger list, reused for the UMS at beat 9: scientific evidence, news, historical example, story, analogy, thought experiment, personal challenge, counterintuitive wisdom, paradoxical question.
+
+## Ten beats short video forces into existence
+
+Not on the map, present in the winning corpus:
+
+- **Call-out**: who this is for.
+- **Absolution**: "it's not your fault, it's the mechanism." Arguably the highest-leverage beat in direct response; buried inside failed solutions on the map.
+- **Demonstration**: live proof in action.
+- **Future pacing**: the after, shown.
+- **Comparison**: versus named alternatives.
+- **Offer reveal / value stack**.
+- **CTA**: the map ends at risk; there is no beat for "here is literally what to do."
+- **Re-hook**: the mid-roll pattern interrupt every 20 to 30 seconds; a floating beat that inserts between others.
+- **Qualification / exclusivity**.
+- **Belonging**: "join 40,000 women who…"
+
+## The nine verdicts (what beats are for)
+
+A beat is testimony; a verdict is the belief it closes. The verdict list is closed; the beat list is open forever.
+
+1. My problem is really caused by Y. (beats 5, 6, 7)
+2. Everything I tried failed because it never touched Y. (beats 3, 4)
+3. Z fixes Y through this pathway. (beats 9, 10, 11)
+4. Only this version of Z reaches Y. **The brand gate. No beat on the map.** Generic is dead → sourcing specifics → verification ritual.
+5. Left alone, Y compounds. (beat 2, and the ratchet)
+6. This messenger can be trusted. (beats 1, 12)
+7. This applies to me. (beat 8)
+8. I cannot lose. (beat 14)
+9. Now, not later. (beat 13)
+
+**The verdict audit.** Tag every line of an ad with the verdict it serves. Which verdicts are unreached? Does the market's awareness already cover them? Overbuilt verdicts show up as bloat (timing is the usual one: "sells out constantly"). Unreached verdicts show up as the reason it did not convert (risk is the usual one). Awareness collapses the map: each notch up collapses beats 3 to 9, because their verdicts arrive pre-closed, and running them anyway re-litigates settled questions on borrowed attention.
+
+## The unaware-ad skeleton, with lengths
+
+```
+Hook          1–2 sentences
+Payoff        50–2000 words
+Story         1000–2000 words
+Other angles  100–150 words
+=== transition ===
+Mechanism     200–300 words   problem → intermediary → mechanism
+Solution      200–300 words   solution → unique solution
+Product       150–300 words   what's different about yours
+Offer         50–100 words    why buy now
+```
+
+Luke's short-ad skeleton: HOOK → POINT → MECHANISM → OFFER.

package/assets/skills/anatomy-of-ads/references/concept-angle.md

@@ -0,0 +1,50 @@
+# Concept, angle, and where concepts come from
+
+## Concept versus angle
+
+Concept: the raw truth, the flat fact, the WHAT. Angle: the frame wrapped around it, the WAY IN. If you can say it flat, no villain, no feeling, no "you", it is a concept.
+
+Precise version: a concept is a causal graph. "Chronically high glucose → endothelial damage → narrowed penile artery → reduced flow → weaker erections, with a feedback loop shame → avoidance → stress → worse glucose." Two ads on the same topic with different graphs are different concepts. Same graph, same concept.
+
+Angle: which role in the graph you star.
+
+| Role starred | Angle |
+|---|---|
+| Adversary | conspiracy / exposé |
+| Discoverer | breakthrough / accidental discovery |
+| Experiencer | story |
+| Clock | warning / countdown |
+| Admitter (insider) | enemy admission |
+| Place | geographic |
+| Prior belief violated | reframe / myth |
+
+The affordance rule: an angle is available only if a fact fills its role. Worked on a fertility product: discoverer = the researchers; adversary = an industry with a $25K product to protect; admitter = embryologists who take it themselves; experiencer = a 43-year-old after four failed transfers; clock = the monthly decline rate after 35; place = none found, so no geographic angle; prior belief violated = "old eggs are old, period."
+
+Asymmetries: concepts burn out, angle families do not. A handful of true concepts, unlimited angles; most firepower goes into angles. Diagnostic: if timeline ads keep winning, the market is responding to the angle; if one word keeps recurring across every frame, it is responding to the concept.
+
+Proposed definition, not locked: a concept is a belief they don't have yet; an angle is a belief they already have; the ad is the wire from the second to the first.
+
+## Angle families
+
+Discovery · Urgency · Authority · Conflict · Story · Reframe. The wider taxonomy ran to 55 entries; a stress test kept about 24 and evicted the rest as claims, spines, or proof modes wearing an angle's name (root cause → concept layer; hero's journey → skeleton; quiz → beat; permission granting → the absolution beat).
+
+## Where concepts come from: insight vectors
+
+An insight vector is an edit to the causal graph the prospect already holds. Information adds nodes and needs source trust. Insight rewrites edges between nodes they already have and needs no trust at all, because every node in the rewrite is already theirs. The "aha" is that edit executing in their head.
+
+Eight families, with one example each:
+
+- **Causation shifts**: reverse ("your dog isn't misbehaving because they're stubborn; they're stubborn because they're misbehaving"), hidden, multiple, circular, delayed ("the fat you fight today was programmed by metabolic damage two years ago"), threshold.
+- **Feedback loops**: vicious ("each sleepless night floods you with stress hormones, so your mind races faster the next night"), virtuous, balancing, reinforcing, delayed, cross-system ("slouched shoulders become salary problems").
+- **Structure revelations**: hidden constraints, system boundaries ("you obsess over kibble brands when the microbiome is the system that matters"), leverage points ("a 3-second adjustment at first crack beats $2000 of roasting equipment"), bottlenecks, dependencies, hierarchies.
+- **Context shifts**: environmental, rule, paradigm ("it's not about more DHT, it's about follicle sensitivity"), time horizon, scale, network.
+- **Pattern recognition**: hidden cycles, archetypes, fractal, leading indicators ("a 23% spike in one-way U-Haul rentals has preceded every real-estate boom by eight months"), pattern breaks, meta-patterns.
+- **Mental model updates**: false assumptions, missing variables, wrong metrics ("amateurs celebrate win rate; pros watch risk-adjusted expectancy"), model limits, model conflicts ("one foot on the gas, one on the brake"), model evolution.
+- **Optimisation shifts**: local vs global, visible vs hidden, direct vs indirect ("nagging creates instant resistance"), simple vs complex, static vs dynamic, short vs long term.
+- **Relationship revelations**: non-linear, emergent, counter-intuitive links ("your moisturiser is causing premature aging: the moisture dependency effect"), hidden dependencies, synergies, trade-offs ("the harder you cut calories the more your metabolism slows").
+
+They stack. The textbook example: "It doesn't matter if you feed the most expensive kibble or table scraps; all that matters is what their gut converts it into. Think of it as a currency exchange." Zero new facts, one new edge, and the prospect supplies the confirming evidence from memory.
+
+The nine operations every vector reduces to: install node · install edge · sever · redirect · flip · relabel · reweight · retime · swap.
+
+Validation filters: not obvious · reveals a mechanism · proof-free (self-evident) · retellable · suggests an action. Delivery shape of one insight: familiar situation → pattern break → mechanism reveal → "therefore" bridge → action path. Banned: gravity, momentum, snowball metaphors; "success breeds success"; vague energy or force analogies.

package/assets/skills/anatomy-of-ads/references/hook-and-structure.md

@@ -0,0 +1,69 @@
+# Hook and structure
+
+## Hook rules
+
+The hook is concept plus angle compressed to the fewest, sharpest words. Structurally, a beat promoted to slot zero, usually the body's organising beat. Hooks rotate independently of the body, so test five hooks made maximally different on one body, not micro-variations.
+
+Craft rules:
+
+- Immediate relevance.
+- Charged language: object words and action verbs with natural charge ("bullied", "whip", "dead muscle").
+- An open loop, natural intrigue.
+- Stakes; rubbernecking.
+- Specific and tangible, but specificity that points at the point, not away from it.
+- Caveman-simple. "Most language is filler, filler, filler, then a point. Be clear what the point is and let the rest be simple."
+- No fragments. One sentence, not three.
+- Consequence first, mechanism later.
+- Germanic over Latinate ("cloth" over "fabric").
+- A 1 to 3 intensity dial; always some wildcards.
+
+Worked edit. Before: "My daughter got me this omelet, I caught myself staring at the stove barefoot without the broken glass feeling." The read: the point is hard to see, the specificity goes the wrong way. After: "My granddaughter bullied me into eating this weird Indonesian fruit to stop my neuropathy. Now, for the first time in three years, I can walk barefoot." The charged word is "bullied"; the rest is pain point and promise in plain words.
+
+Second edit: "Laxatives whip your colon" has the association but you cannot see it. "Abuse it until it becomes a dead muscle that can't poop anymore" lands.
+
+Patterns: weird facts ("why you wake up at 3:17am") · magic words ("the four-word text that makes him chase you") · weird methods ("the Japanese loophole that melts fat overnight") · incomplete loops.
+
+Failure mode: hook and body diverging too far pays the clickbait tax, high click rate and dead conversion. The exception that proves the rule: a conspiracy-bodied ad opening with a discovery hook that pivots to suppression in line two.
+
+## Unaware hooks
+
+Four types for unaware traffic: **straddle** (curiosity plus relevance in the first line), **symptom** (a neutral reference plus a charge), **worldview** (a belief chain: tap the reservoir → explain why → show the cost → mechanism, product, offer), **story**.
+
+Relevance has four levels of charge, from broad to sharp: existential (death, aging) → mechanism (cortisol, blood sugar) → condition (neuropathy, ED) → sensation (tingling feet, waking at 3am, brain fog at 2pm).
+
+The onion ladder, unaware to problem-aware, one word at a time:
+
+```
+What onions do to you
+What onions do to your body
+What onions do to your health
+What onions do to your blood sugar
+What onions do to your neuropathy
+```
+
+Symptom hooks: "Is your dog eating grass?" → "That's a sign of digestive distress." "If you need coffee to wake up, your mitochondria are already 40% dead."
+
+Process: hooks first, always. A hook bot plus a hook primer of 50 to 100 winning hooks plus the brief, pushed two or three times, then edited by hand.
+
+## Structure: the four dials behind "format"
+
+| Dial | What it is | Examples |
+|---|---|---|
+| Medium | the container | static, video, carousel |
+| Skeleton | beat order | timeline, specimen VSL, diagnosis-then-timeline, mechanism explainer, exposé |
+| Conceit | what it pretends to be | podcast, street interview, 80s news desk, customer call, cue cards, song |
+| Style | visual gloss | UGC, Pixar, claymation, greenscreen, whiteboard, mummies |
+
+Every time someone says "new format", ask which dial. Luke's own list mixes all four: story-telling song ad (conceit + style), timeline (skeleton), UGC (style + actor), animated ingredients or villains (style), conspiracy timeline (skeleton with the adversary beat as spine), podcast (conceit), POV (conceit + style), specimen VSL (skeleton: the problem-cause beat promoted, trust carried by the instrument), 80s retro news (conceit).
+
+A format is a beat promoted to spine. A hook is a beat promoted to slot zero. When the same beat takes both, format, concept, and hook arrive fused; that is why "conspiracy timeline" reads as one thing.
+
+Skeletons are walks through the concept graph: timeline narrates forward node by node; mechanism explainer walks backward from symptom to root; exposé starts at the adversary and radiates out. Same graph, three orders, three different-feeling ads.
+
+Awareness collapses skeletons. Each notch up collapses the middle beats; running them anyway re-litigates settled questions on borrowed attention. Short-ad skeleton: HOOK → POINT → MECHANISM → OFFER.
+
+Format beats copy (the Lampropoulos principle): the same copy moved into a bookalog format has been the massive winner. When copy is stuck, change the format before the words.
+
+## Conceit: the hinge
+
+The conceit is the last decision about how you say something and the first about how you show it. It is the script's shape, not a separate step: a customer-call script has two voices, a cue-card script is one beat per card. Test for every creative element: does it carry the message, or just host it?

package/assets/skills/bot-builder/SKILL.md

@@ -0,0 +1,147 @@
+---
+name: bot-builder
+description: Build a custom bot (a prompt that does one job well) the way Luke and Mario build the Genesis bots, and put it where it runs: an Exodus workflow Prompt node (variables, model, temperature, loops), a Genesis bot via the bot-builder-bot, or a Claude Code skill. Use it whenever someone says "build me a bot", "I want a bot that…", "turn this into a prompt", "make a node for the workflow", "clone my voice", "the bot keeps doing X, fix the prompt", "write the system prompt", or whenever, mid-task, a repeated step would be better as its own bot (then say: we'll just build that for you). The method is SEAK: Structure, Examples, Ask AI, Knowledge. The two things that matter most are domain knowledge and seven to ten high-quality, diverse examples, and this workspace already knows where the examples live (the ad bank, the swipe files, the winners, the reviews). Also covers the advanced stack (mandate, elite intelligence unit, operational protocol, quality-control checklist, creative-freedom filter, automatic failure triggers, anti-AI module) and the iterate loop (test, note everything you hate, ask AI to fix it, preserve don't compress).
+---
+
+# Bot builder
+
+A bot is a prompt with a structure, examples, and knowledge that does one job. Luke's crash course, in full: pick the right structure, find seven to ten high-quality examples, put in the domain knowledge and modules, test it, note everything you hate, tell AI to fix it, repeat until done. Everything else in this skill is detail on those five moves.
+
+Two rules before anything:
+
+- **Domain knowledge plus examples is the alchemy.** A rigorous concept with ten clear examples lets a model do the job better than most humans. Take either away and the bot gets worse. If you can only have one, examples win.
+- **One task per bot.** Ideate, generate, and edit are different modes. Mixing them in one call makes every output muddier. A story-idea bot feeding a writing bot beats one bot that does both.
+
+Think mode for scoping (what is it, who uses it, what comes out). Build mode for writing the prompt and running the test loop. Read `thinking-vs-build` if installed.
+
+## Step 0. Say what it is
+
+Before writing a line, answer these in a few lines and say them back:
+
+- **Who uses it and in what mindset?** A coach sitting down to write an email. A strategist who just ripped twenty ads. A node in a workflow that nobody talks to. This decides the whole operational protocol.
+- **Inputs.** What they will actually have in hand: a buyer profile, a sales page URL, a dump of transcripts, a voice note. Give them two or three ways in; forcing one path is annoying.
+- **Output.** The exact shape. A menu of twenty ideas. A rewritten email. A table with fixed columns. A one-breath mechanism.
+- **Type.** Two dials, four types. Generative (a little in, a lot out) or analytical (a lot in, a little out). Interactive (back and forth, a process) or node (one in, one out, no conversation). A writing bot is generative and mostly node. A copy chief is analytical and interactive. An extract bot is analytical and node. Two modifiers: how polished (internal, or emoji-and-hierarchy pretty for perceived value) and how autonomous.
+- **Where it runs.** An Exodus workflow Prompt node, a Genesis bot, or a Claude Code skill. See "Where it lives" below. The structure is the same everywhere.
+
+Do not get stuck on the type. It is a tool to pick the structure, not a gate. If in doubt, build the node version first; it is the easiest and it slots into workflows.
+
+## Step 1. Structure (the S)
+
+The building blocks, in the order that works for most bots:
+
+| Block | What it is |
+|---|---|
+| Identity | The role, or better, the task and the team (see elite intelligence unit) |
+| Purpose | The outcome, stated as the one thing success is measured on |
+| Process | The steps, only for interactive bots; each step is its own subroutine with its own purpose, knowledge, and examples |
+| Domain knowledge | The concepts the job runs on (copy blocks, ODF, the mechanism rules, a theory of humour) |
+| Examples | Seven to ten, diverse, best first |
+| Modules | Plug-in blocks reused across bots: copy chief, copy blocks, rhetorical frames, anti-AI |
+| Formatting | The exact output shape |
+| Guidelines | Do's and don'ts, then a recap of the mandates |
+
+Order changes by type. **Voice and writing bots put examples before knowledge** (a voice is thousands of dimensions; examples carry them, descriptions do not). **Asset and analysis bots put knowledge before examples** (the concept is the job; examples show its shape). **Process bots put the process early** so the bot knows the flow, then each step carries its own purpose, knowledge, and examples.
+
+Full block templates, by type, with the advanced additions: `references/prompt-blocks.md`.
+
+## Step 2. Examples (the E)
+
+The most important input. Rules:
+
+- **Seven to ten.** More rarely helps. Fewer than five overfits.
+- **Diverse.** Short and long, with and without a call to action, selling and value, emotional and neutral. Diversity is what stops every output sounding like example one.
+- **Best first.** Earlier examples carry more weight. The first example is the one the bot will sound most like.
+- **Explain why.** An example plus one line on what makes it good beats the example alone. The bot learns the boundary, not just the shape.
+- **Micro-examples too.** For structured outputs, show one example per component (a hook type with its example, a reframe with its example), not only whole pieces.
+- **Show what to do, not what not to do.** Negative examples teach the negative.
+- **Drip a little of what you want more of.** If the outputs are not hitting hard enough, add one example from a writer whose edge you want. A dash of it changes the alchemy.
+
+Where the examples come from, in this workspace:
+
+- Own winning ads, transcripts and copy, in the ad bank and the tested-ads master file. Highest quality.
+- Competitor long-running ads from the swipe files (the rip). Proven in the wild.
+- Reviews and comments with counts, from the research folders, for anything that needs the market's own words.
+- The Scout library in Exodus for organic hooks.
+- Genesis bank keys (hooks, headlines, body by awareness, modules) when the bot runs as a workflow node.
+
+When no examples exist, **bootstrap them**. Start with one to three seed examples, even if you have to write them by hand. Build the v0 bot with the structure and the seeds. Generate one output. Edit it until it is as good as you can make it (or bring it to a feedback call). Put it back in as example four. Generate again. After five or six rounds the bot writes examples you no longer need to edit. Mario built almost every Genesis bot this way. A universal writing bot with a large example bank can also write your first seeds in any style ("write in this style, do not copy the content or structure, just the voice"), then you edit them. If a swipe feels too close to steal, have the model rewrite it into a different niche with the same idea, and use that.
+
+## Step 3. Ask AI (the A)
+
+You are not asking enough. Ask at every step: what bot am I even building, how should I structure it, what is missing, where should this new block go, why does it keep ignoring rule four. Habits that make the answers better:
+
+- Ask for its honest read, not confirmation: "you can say yes, no, or no opinion; tell me why."
+- Ask for reasoning; it thinks harder when it has to explain.
+- Refresh the chat between tasks; one chance to get it right beats a long muddied thread.
+- Separate ideate, generate, edit into different calls.
+- Use `###` as section separators; it reads them cleanly.
+- "Do not be afraid to use tokens; go as long as you can." Models conserve by default.
+- When optimising a prompt: **preserve, do not compress.** "Keep everything I wrote, only add what is missing, change words only where you say so explicitly." Left alone, the model simplifies and makes the prompt generic.
+- Feed the model the prompt plus two or three bad outputs and say: fix the prompt so it never does this again. Then ask it exactly where to paste the fix.
+
+## Step 4. Knowledge (the K)
+
+Domain knowledge is where the moat is. Three sources: theories that already exist, your own ideas, or examples you make the model find the pattern in. When the concept does not exist yet, build it with **expand, contract, refine**:
+
+1. **Expand.** "Give me every theory of X ever made." Then "more, you are missing some." Then "a detailed paragraph with examples for each." Push until it covers everything.
+2. **Contract.** Order it into one clear, unified system with a conceptual hierarchy (the model is bad at hierarchy on its own; it mixes levels). Ask the model to "organise all of these into a rigorous hierarchy: principles, then mechanisms, then moves, then examples, no level mixing."
+3. **Refine.** Read it. Argue with it. Cut. "Add anything we are missing." Expand again. Repeat until it is yours.
+
+For voice bots the knowledge is small: a paragraph on how they speak (language, tone, relationship to audience, personality) and a paragraph on what they say (point of view, philosophy). Twenty to thirty percent of the way is enough; the examples carry the rest.
+
+## Step 5. The advanced stack (when v1 is not good enough)
+
+Most of this was added by trial and error when a bot would not behave. Add pieces as the bot earns them; do not start here.
+
+- **Mandate at the top.** The one metric success is measured on, before identity. "Your success is measured solely by X. Err on the side of Y." It sets the lens for everything below.
+- **Elite intelligence unit** instead of one role. Name the task, then five to seven specialists whose skill sets serve it, each with credentials, purpose, and contribution. Include non-obvious ones (a method actor to embody the prospect, a courtroom psychologist for proof, a Disney experience designer for the user's journey). Give a rule for when they disagree.
+- **Operational protocol.** The exact steps the user sees: how to give inputs (two or three doors), what the bot does with them, what it asks before writing. Complex behind the scenes, simple in front. Menus as numbers for one list and letters for the next so it never confuses them.
+- **Decision rules, conditional.** Awareness level, traffic temperature, towards versus away motivation. "If solution-aware and towards, open with the differentiation; if problem-aware and away, open with pain amplification."
+- **Framework with explanation.** Whatever system the copy runs on (copy blocks, AIP, your own), explained with why each part matters, not just listed.
+- **Quality-control checklist.** A mandatory pre-delivery check per section, run before anything is shown. It makes the bot justify its choices; it does not stop every hallucination, but it catches most.
+- **Proof confirmation step.** Before writing, the bot lists the proof elements it will use and asks the user to strike any it cannot verify. Cheapest hallucination fix there is.
+- **Creative-freedom filter.** Permission to invent new hook types, structures, sequences, as long as the core principles hold. Without it the bot is a keyboard monkey; with it, consistency drops a little and the ceiling rises a lot.
+- **Automatic failure triggers.** "If the hook and the insight do not align, the script is a failure regardless of quality." Repeat the ones that matter at the start, in the middle, and at the end; the end recap uses recency.
+- **Anti-AI module.** The gnome list for this market plus the generic ones (triplets, "it's not X, it's Y", "here's the kicker", brutal truth, 2:47 AM, colons in headlines, inconsistent breaks). Kill gnomes in four places: the examples first, the module, the input method (voice notes keep the human in), then manual editing.
+- **Copy chief module** at the end of writing bots: a menu of dimensions the user can turn (more insight, stronger hook, shorter, more natural, more feminine, less salesy) so chiefing becomes "more like this, less like that."
+- **Prompt protection and a demo mode** when the bot faces other people.
+- **Tone with the model.** Be strict where it matters ("automatic failure", "you must"), and give it a reason. Redundancy is fine; the extra tokens are cheaper than a bad output.
+
+Mario's fully worked talking-head bot is a caricature on purpose: fifteen thousand words, too many specialists, every block present. Build the simple one first, then weed. The real expertise is curation: fewer specialists, better examples, tighter frameworks.
+
+## Step 6. Test and iterate
+
+1. Run it on a real input. Read the output cold.
+2. Write down everything you hate, in plain words. "It says 'here's the kicker'. It gave ten options when I wanted one. It invented a study."
+3. Give the model the prompt, the outputs, and the list. "Fix the prompt so this never happens. Preserve everything else. Tell me where you put each fix."
+4. Paste the fixes where it said. Run again.
+5. Stop when it saves you time and you would ship the output with light edits. The first bot takes five to ten hours. The tenth takes an afternoon, because you steal blocks from the previous nine.
+
+If the bot is meant to learn your taste over time, keep the before-and-after pairs from every edit; that is the instinct-transfer material.
+
+## Where it lives
+
+Same prompt, three homes. Pick by who runs it.
+
+**Exodus workflow: the Prompt node.** Author it when the bot is a step in a saved automation. The prompt is the node: what you write is sent as one call on the workspace's own LLM key, no Genesis slug needed. Every distinct `{{variable}}` in the body becomes a required input port (up to 12), fed by a text wire or a Primer node. Config: `model` (Claude ids work on any key; slashed ids need OpenRouter), `temperature` 0 to 1 (honoured here, ignored on Genesis-routed bots), `loops` 1 to 5 (self-critique-and-rewrite passes; only the final flows downstream) with `loopInstructions` per extra pass, `bankKeys` to ride the brand's hooks, headlines, body, or modules banks along as reference, `sessionMode` to keep a chat handle. Fan it out with a Splitter (one lane per item), close with a Collector, gate with a Checkpoint. Contract, YAML, and gotchas in `references/exodus-prompt-node.md`. Validate before import; the schema is live, pull it fresh.
+
+**Genesis bot via bot-builder-bot.** When the bot should be a reusable Genesis bot or you want a first draft of the whole prompt from a concept. The `bot-builder-bot` (slug in the live catalog) takes a concept and returns a complete prompt in the eight-block shape (identity, purpose, process, domain knowledge, examples placeholder, formatting, guidelines) plus implementation notes: type, temperature, model, testing priorities. It leaves the examples slot for you, correctly, and tells you what to put there. Prompt template that produced a clean node-safe draft in one shot: `references/prompt-blocks.md`, last section. Call it through the `genesis-bots` helper. Then run Step 6 on the draft; it is a v0.1, not a release.
+
+**Claude Code skill.** When the bot is a method you want fired by phrases in this folder, or handed to a collaborator as a zip. Same blocks, written as a SKILL.md with a pushy description. The skills in this folder are the examples.
+
+**The rule for offering it.** Any time a step in a session repeats (a third rip, a second grid, the same extraction on every swipe), say: this should be a bot, we will build it for you. Then run Step 0 in three lines and build the node version.
+
+## Worked example (fictional brand, real run)
+
+Concept: a "segments seen" node for the fictional Evenkeel account. Analytical, node. Input: a dump of competitor transcripts. Output: every segment the ads call out, as Outcome × Demographic × Facet, with the exact quote, the ad id, and a note on whether it is a segment, a copy line, or a hypothesis. Runs silently inside a workflow.
+
+Step 0 took four lines. Step 1: the bot-builder-bot returned identity (competitive intelligence analyst), purpose (silent, one in one out), a six-step process (inventory, extract signals in four categories, apply the grammar, copy-line test, mark hypotheses, compile), domain knowledge (the four facet families with examples, the validity rules, confidence tiers), an examples placeholder with instructions to include one copy-line case and one hypothesis case, a fixed output block per segment, and guidelines (quote exactly or not at all, silence is default, one signal one segment, volume does not equal validity, no editorial opinion, workflow-safe). Implementation notes: analytical one-shot, temperature 0.5, a high-reasoning model, four testing priorities. Step 2: three hand-marked transcripts go in the examples slot, best first. Step 6: test on five ads for quote fidelity, two ads with identical phrases for the copy-line trigger, one transcript-heavy ad for over-extraction, fifty ads for scale. Home: a Prompt node with `{{transcripts}}` as the one slot, temperature 0.3, loops 2 with the second pass told "check every quote against the source and drop any that are not verbatim", output wired to the segments-seen file.
+
+## What this skill is not
+
+It does not decide what the copy should say (copy-instincts), who it is for (odf), or why the product works (mechanism). It packages a job into a prompt that runs without you, and puts it where it runs.
+
+## Standards
+
+Before producing anything, read `STANDARDS.md` at the workspace root (and the section for this output type). Grade the draft against it before showing it; rewrite failures first. When the user reacts with a judgment, a banking phrase, or the same note twice, hand the reaction to `remember-that`. At the end of the session, `handoff` scrapes the chat and proposes entries.