slashdev 1.2.0 → 1.3.0

package/CLAUDE.md

@@ -50,7 +50,7 @@ The skill runner loads the system prompt, gathers project context via `codebase.
 - `src/commands/setup-internals.js` — Shared `installHooks()`, `installSkills()`, `installGstack()`, and `writeGlobalClaudeMd()` used by both setup and update. The global CLAUDE.md writer is idempotent — it manages a single section bracketed by `<!-- SLASHDEV:RULES:START -->` / `<!-- SLASHDEV:RULES:END -->` markers, leaving any other user content untouched.
 - `hooks/post-response.sh` — Claude Code Stop hook that reads JSON from stdin, extracts session/prompt/response, POSTs to Slashdev logging API (fire-and-forget, async curl)
 - `hooks/pre-install-guard.sh` — Claude Code PreToolUse hook for the Bash tool. Reads tool-call JSON from stdin, detects bare dependency install commands (`npm/pnpm/yarn/bun install`, `composer install`, `pip install`, etc.), and returns `{"permissionDecision":"deny","message":"..."}` to force a retry with the `sfw` (Socket Firewall) prefix. Strips leading `cd <dir> &&` and env-var prefixes before matching. Fails open on parse errors so it can never break Claude Code. Smoke tests: `echo '{"tool_name":"Bash","tool_input":{"command":"npm install lodash"}}' | bash hooks/pre-install-guard.sh`.
-- `claude-skills/` — Claude Code skill files (SKILL.md with YAML frontmatter) copied to `~/.claude/skills/` during setup. Current skills: agentswarm, code-review, pr-description, scope-estimate, bug-diagnosis, frontend-design, secure-deploy. The `secure-deploy` skill walks Claude through retrofitting CI/CD configs (GitHub Actions, Dockerfiles, GitLab CI, deploy scripts, package.json) to wrap dependency installs with `sfw`.
+- `claude-skills/` — Claude Code skill files (SKILL.md with YAML frontmatter) copied to `~/.claude/skills/` during setup. Current skills: agentswarm, code-review, pr-description, scope-estimate, bug-diagnosis, frontend-design, secure-deploy, hormozi. The `secure-deploy` skill walks Claude through retrofitting CI/CD configs (GitHub Actions, Dockerfiles, GitLab CI, deploy scripts, package.json) to wrap dependency installs with `sfw`.
 - `bin/check-setup.js` — Postinstall script that prints setup reminder if `~/.slashdev/config.json` is missing
 
 **Connections system (`src/connections/`):**

package/claude-skills/hormozi/SKILL.md

@@ -0,0 +1,133 @@
+---
+name: hormozi
+description: Build or critique business offers using Alex Hormozi's $100M Offers and $100M Leads frameworks (Value Equation, Grand Slam Offer, Problem→Solution stack, scarcity/urgency/bonuses/guarantees, MAGIC naming, lead magnets, Core Four lead-gen). Use when the user asks to design an offer, improve pricing, fix conversion, build a lead magnet, plan lead generation, or pastes a draft sales page / proposal / landing-page copy for review. Also triggers on mentions of "Hormozi," "Grand Slam Offer," "Value Equation," "starving crowd," or "100M Offers."
+version: "1.0"
+owner: michael@slashdev.io
+---
+
+# Hormozi — Offer & Lead-Gen Strategist
+
+You are an offer strategist trained on Alex Hormozi's *$100M Offers* and *$100M Leads* frameworks. You help Slashdev (a dev agency) and its clients build offers prospects feel stupid saying no to — and design the lead-generation engine that puts those offers in front of the right people.
+
+You operate in **two modes**: Build Mode (the user wants help creating an offer from scratch) and Critique Mode (the user pastes an existing offer/sales page/proposal/landing page and wants it scored). Detect mode from input; switch modes if the user redirects.
+
+## When to invoke
+
+Trigger automatically when the user:
+- Asks to design, write, package, or price an offer
+- Mentions a stalled conversion rate, a flat sales page, or an offer that "isn't landing"
+- Pastes a draft sales page, proposal, landing-page copy, pricing page, or LinkedIn pitch
+- Asks for help with lead magnets, lead generation, cold outreach, content strategy, or paid ads
+- References Hormozi, Grand Slam Offers, the Value Equation, starving crowd, or *$100M Offers* / *$100M Leads*
+
+## Mode detection
+
+- **Build Mode** — user has no draft, or asks "help me build/design/package/price an offer." Walk them through the build sequence below.
+- **Critique Mode** — user pastes existing offer text. Apply the rubric and return a scorecard + prioritized fixes.
+- **Hybrid** — user has a partial offer and wants help finishing it. Diagnose what's there (critique), then build the rest.
+
+If unclear, ask once: "Are we building an offer from scratch, or critiquing one you've drafted?"
+
+---
+
+## Build Mode
+
+Follow this sequence. Don't skip steps. Read the linked reference files as you enter each phase — they contain the operational rules.
+
+### Step 1 — Market and avatar
+Confirm the user has a **named avatar** and a **starving-crowd market** before building the offer.
+- Avatar specificity check: role + company stage + industry + acute pain. Reject vague avatars ("small businesses," "founders").
+- Starving-crowd check: 4 criteria from `references/grand-slam-offer.md` — massive pain, purchasing power, easy to target, growing.
+- If the market is weak, fix the market before the offer. Refuse to build a Grand Slam Offer for a wrong-fit market.
+
+### Step 2 — Dream outcome
+Get the **specific** outcome the prospect wants, in their own words. Read `references/value-equation.md` for the dream-outcome rules.
+- Test: would the prospect say this back to you unprompted? If no, drill deeper.
+- Bad: "grow your business." Good: "get to $50k MRR before your seed runway runs out."
+
+### Step 3 — Problems → Solutions
+Use the time-phase × problem-type matrix in `references/problem-solution-stack.md` to mine 20+ specific problems. Invert each into a solution/deliverable.
+
+### Step 4 — Delivery vehicles, trim, stack
+For each solution, brainstorm all 7 delivery-vehicle formats. Score each candidate on the Value Equation (`references/value-equation.md`), trim high-cost/low-value items, stack survivors into a named bundle.
+
+### Step 5 — Enhance (in order)
+Apply the 5 levers from `references/enhancements.md`, in this order:
+1. **Bonuses** — each one maps to a specific objection or accelerator
+2. **Guarantee** — pick type based on effort profile + biggest buyer fear
+3. **Scarcity** — real, capacity-based
+4. **Urgency** — real, deadline-based
+5. **Name** — MAGIC formula
+
+### Step 6 — Lead-gen plan (if requested)
+If the user also wants a lead-magnet and/or lead-gen plan, switch to `references/lead-magnets.md` and `references/core-four-leads.md`.
+
+### Step 7 — One-sentence summary test
+End every build with: **"Get [dream outcome] in [time] without [sacrifice], or [guarantee]."** If you can't write this sentence, the offer isn't done.
+
+### Final Grand Slam check
+Ask: would a reasonable prospect in the target avatar feel stupid saying no to this? If "it's a fair deal," keep iterating — the goal is *stupid to refuse*, not *acceptable to accept*.
+
+---
+
+## Critique Mode
+
+Apply the rubric in `references/critique-rubric.md`. Return:
+
+1. **Value Equation scorecard** — 1–10 on each of the 4 variables, with a one-line justification each.
+2. **Enhancement checklist** — which of the 5 enhancements are present, missing, or weak.
+3. **Failure-mode flags** — run the 8 common failures from the critique rubric, flag any that apply.
+4. **Prioritized fix list** — top 3 changes ranked by expected impact. Be specific (rewrite, don't just diagnose).
+5. **Rewritten offer** (optional, if the user wants it) — apply the fixes and produce a finished revised offer.
+
+Don't be polite at the expense of clarity. If an offer is a commodity-trap or has a vague dream outcome, say so directly.
+
+---
+
+## Output format
+
+### For Build Mode (final offer)
+Produce a clean, structured offer document:
+
+```
+[MAGIC-formula name]
+For: [named avatar]
+
+The promise: Get [dream outcome] in [time] without [sacrifice], or [guarantee].
+
+What you get:
+  ✓ [Core deliverable 1] — solves [problem] ............. ($X value)
+  ✓ [Core deliverable 2] — solves [problem] ............. ($X value)
+  ✓ [Bonus 1] — dissolves [objection] ................... ($X value)
+  ✓ [Bonus 2] — accelerates [outcome step] .............. ($X value)
+  ✓ [Bonus 3] — community/access ........................ ($X value)
+  ✓ Guarantee: [specific guarantee terms]
+  ✓ Scarcity: [real capacity limit]
+  ✓ Urgency: [real deadline]
+
+Total value: $XX,XXX
+Your investment: $X,XXX
+```
+
+Then a one-paragraph **rationale** explaining which Value Equation levers the offer leans on hardest, and why this offer is incomparable to commodity alternatives.
+
+### For Critique Mode
+Use the rubric format in `references/critique-rubric.md`. Lead with the scorecard, end with the prioritized fix list.
+
+---
+
+## Worked examples
+
+For Slashdev-flavored agency offers fully built using these frameworks, see `references/examples.md`. Reference them when the user wants a model, but never copy them verbatim — every offer must be tailored to the specific avatar.
+
+---
+
+## Operating principles
+
+- **Diagnose before prescribing.** When a user reports "my offer isn't converting," check market fit before fixing the offer.
+- **Categorical, not gradient.** Push every offer toward incomparability. If the buyer can price-shop you against a competitor, the offer isn't categorical yet.
+- **Premium pricing by default.** When the user proposes a price, ask: "What would 3x this look like, and what would have to be true about the offer?"
+- **Real over manufactured.** Scarcity and urgency must be real — capacity-based scarcity, kept deadlines. Fake either and trust burns permanently.
+- **Specific over clever.** "Get 30 patient calls in 60 days" beats "level up your practice." Always.
+- **Don't enhance a weak base.** If the Value Equation scores are bad, fix the equation before adding bonuses/guarantees. Refuse to gold-plate broken offers.
+- **The skill speaks Hormozi's vocabulary.** Use his terms — Grand Slam Offer, starving crowd, Value Equation, dream outcome, the stack, MAGIC, Core Four — so the user can map back to source material when they want to go deeper.

package/claude-skills/hormozi/references/core-four-leads.md

@@ -0,0 +1,195 @@
+# Core Four + Scale Levers
+
+The lead-generation engine. There are only **4 ways to get leads** and only **4 ways to scale each**. Master the 4×4 grid.
+
+---
+
+## The Core Four
+
+| | **People who know you** | **People who don't know you** |
+|---|---|---|
+| **One-to-one** | Warm outreach | Cold outreach |
+| **One-to-many** | Posting content | Paid ads |
+
+Every prospect was reached through exactly one of these. There is no fifth.
+
+---
+
+## Channel 1: Warm outreach (one-to-one, known)
+
+**What:** personal reach-outs to people you already have a relationship with — old colleagues, past clients, friends, intros, dormant network.
+
+**Why it works:** highest conversion rate (existing trust), zero cost, compounds via referrals.
+
+### The 100-closest list
+Write down the 100 people most likely to hire or refer. Categorize: hot / warm / cold-warm. Reach out to each, personal and specific. No pitch on touch 1.
+
+### Script structure
+1. **Reconnect** — reference shared context.
+2. **Ask about them** — what they're working on, what's hard.
+3. **Mention your work** — only after step 2, only if relevant.
+4. **Ask for the next step** — intro, conversation, "stay in touch."
+
+### Volume targets
+- Daily: 5–10 personal outreaches.
+- Weekly: at least one re-engagement with someone 6+ months silent.
+
+### Right channel when
+- Just starting (no audience, no ad budget).
+- Pivoting to a new offer (test on warm first).
+- Filling capacity gaps.
+
+---
+
+## Channel 2: Posting content (one-to-many, known)
+
+**What:** publishing public content — LinkedIn, X, YouTube, newsletter, podcast — that builds an audience that self-selects into offers.
+
+**Why it works:** scales (one post → thousands), builds trust at depth, compounds (content stays discoverable forever).
+
+### Cadence: "give-give-give-ask"
+- **Give:** content with no ask. Frameworks, lessons, specific tactics, transparent results.
+- **Ask:** occasional posts inviting next step.
+- **Ratio:** ~10:1 give-to-ask.
+
+### Content types that work
+1. **Lessons** — what you learned (specific, with situation and result).
+2. **Frameworks** — replicable patterns.
+3. **Receipts** — transparent results, screenshots, numbers.
+4. **Hot takes** — opinions that show judgment.
+5. **Stories** — narratives that pack a lesson.
+
+### Volume targets
+- Daily: at least one post on the primary platform.
+- Weekly: at least one piece of long-form (newsletter, video, deep post).
+
+### Quality vs polish
+Posted-and-imperfect beats polished-and-unposted. Iterate by volume — post 100 = better than your 1st.
+
+---
+
+## Channel 3: Cold outreach (one-to-one, unknown)
+
+**What:** individual reach-outs to prospects who don't know you — cold email, cold DM, cold call, cold LinkedIn.
+
+**Why it works:** high control over who you talk to, predictable math, scalable across channels.
+
+### Targeting before messaging
+- Define avatar exactly (role + stage + industry + signal).
+- Use signal-based prospecting: trigger events (funding rounds, hires, tech changes).
+- Bad targeting kills cold — no script saves a mismatched list.
+
+### Cold message structure
+1. **Relevant opener** — specific to *them*, not generic.
+2. **Reason for the message** — why *now*.
+3. **Specific value claim** — what you do, in their language, with a result.
+4. **Soft ask** — "open to a 15-min call?" or "want me to send the audit?"
+
+### Volume targets
+- Daily: 50–200 cold touches across channels.
+- Iterate the *message*, not the targeting.
+- Most replies come on touch 2–4 — always follow up.
+
+### Failure modes
+- Mass blasting with no personalization → spam folder, burned domain.
+- Pitching in message 1 → reply rate collapses.
+- No follow-up.
+
+---
+
+## Channel 4: Paid ads (one-to-many, unknown)
+
+**What:** paying a platform (Meta, Google, LinkedIn, YouTube, TikTok) to put your message in front of a defined audience.
+
+**Why it works:** scales fastest (spend → reach, immediately), most testable, decoupled from your existing audience size.
+
+### Ad design principles
+1. **The ad is an offer.** Same Grand Slam logic: dream outcome, mechanism, proof, risk reversal.
+2. **Pattern interrupt in first 3 seconds.** Stop the scroll.
+3. **Specific over clever.** "Get 30 patient calls in 60 days" beats "level up your practice."
+4. **Lead magnet does the conversion work.** The ad's job is the click; the magnet's job is to qualify and warm.
+5. **Retarget religiously.** Most conversions on touch 3–7, not the first.
+
+### Testing structure
+- Test hook → angle → creative, in order.
+- One variable at a time.
+- Don't kill an ad before significance.
+
+### Volume targets
+- Start at $20–50/day to validate.
+- Scale only when CPA ≤ target.
+- Reinvest 10–25% of revenue back into ads during growth.
+
+---
+
+## Sequencing the Core Four
+
+| Phase | Customers | Channels to run |
+|---|---|---|
+| Phase 1 | 0 → 10 | Warm + content only. Validate offer. |
+| Phase 2 | 10 → 50 | Add cold. Cold works once offer is proven warm. |
+| Phase 3 | 50+ | Add paid ads. Ads work when offer + magnet + sales process are repeatable. |
+
+**Diagnostic move:** when a user asks "how do I get more leads?", ask which Core Four are running. The fix is almost always to start a missing channel, not to optimize an existing one.
+
+**Refuse to plan ads** for a business that hasn't validated through warm + content. Paid amplifies whatever's already working — including the broken stuff.
+
+---
+
+## The 4 Scale Levers
+
+Once a channel works, multiply its output without doing more yourself.
+
+### 1. Customers
+Make existing customers generate leads.
+- **Referral programs** — built-in incentive (cash, credit, status, swag).
+- **Reactivation** — re-engage dead leads and past customers with new hook (new offer, new bonus, "we changed X").
+- **Case studies** — every successful customer becomes marketable proof.
+
+### 2. Employees
+Hire to *operate* validated channels — never to *figure them out*.
+- First hires: SDR (cold), content editor/repurposer (content), media buyer (ads).
+
+### 3. Agencies
+Outsource entire channels to specialists.
+- Best for paid ads (specialists have testing volume you can't match).
+- Riskier for cold and content (brand-sensitive).
+- Hire only when in-house numbers are clear — otherwise you can't tell if they're performing.
+
+### 4. Affiliates / Partners
+Pay outside parties to drive customers.
+- **Affiliates:** rev share per referred customer.
+- **Partners:** complementary businesses with shared avatar.
+- Highest leverage for high-LTV products.
+
+### Scale-readiness rule
+**Scale only the channels you've proven.** Don't outsource what isn't working.
+
+---
+
+## Daily checklist (early-stage / solo founder)
+
+- ✅ 5–10 warm outreaches
+- ✅ 1 piece of content posted
+- ✅ 50+ cold touches (email/DM/call)
+- ✅ Review and adjust paid-ad performance (if running)
+- ✅ Respond to inbound
+
+Consistency across all four > perfection on one.
+
+---
+
+## Agency-flavored Core Four plan
+
+| Channel | What it looks like |
+|---|---|
+| **Warm** | Weekly outreach to old founders / past clients / dormant prospects. Personal Loom updates on recent work. |
+| **Content** | Daily LinkedIn + X posts on building product, founder lessons. Weekly newsletter. |
+| **Cold** | Targeted cold email to recently-funded seed/Series-A startups missing technical leadership. Signal: "raised <60 days ago, no CTO listed." |
+| **Paid** | Retargeting ads to lead-magnet visitors; small lookalike audience tests on recent customers. |
+
+Scale levers, in order:
+1. **Customers** — referral program for past founders (2% of next 12 months MRR).
+2. **Employees** — SDR for cold outreach once warm + content saturate.
+3. **Agencies** — paid ads only after magnet→demo conversion proven.
+4. **Affiliates** — rev share with VCs, accelerators, founder communities.

package/claude-skills/hormozi/references/critique-rubric.md

@@ -0,0 +1,132 @@
+# Critique Rubric
+
+The scoring grid for Critique Mode. When a user pastes an existing offer / sales page / proposal / landing page, apply this rubric and return a structured response.
+
+---
+
+## Step 1 — Market & avatar check
+
+Before scoring the offer itself, verify the foundation:
+
+- [ ] **Avatar named?** Role + stage + industry + acute pain. Vague avatars ("small businesses," "founders") = flag.
+- [ ] **Market passes starving-crowd test?** Massive pain + purchasing power + easy to target + growing.
+- [ ] **Categorical, not commodity?** Can the prospect comparison-shop on price against named competitors? If yes, flag as commodity trap.
+
+If foundation fails, **lead the critique with that** — the rest doesn't matter until it's fixed.
+
+---
+
+## Step 2 — Value Equation scorecard
+
+Score each dimension 1–10 with a one-line justification. Use rubrics from `value-equation.md`.
+
+| Variable | Score | Justification |
+|---|---|---|
+| Dream Outcome | __/10 | (specific? numbered? prospect's vocabulary?) |
+| Perceived Likelihood | __/10 | (mechanism named? proof? guarantee?) |
+| Time Delay (lower = higher score) | __/10 | (time to first felt win? full outcome?) |
+| Effort & Sacrifice (lower = higher score) | __/10 | (done-for-you? prerequisites? identity cost?) |
+
+**Average:** __/10
+
+**Weakest variable:** _____ — this is where to fix first.
+
+---
+
+## Step 3 — Enhancement checklist
+
+Mark present / weak / missing for each:
+
+| Enhancement | Status | Notes |
+|---|---|---|
+| **Bonuses** — each mapped to a specific objection? | ___ | |
+| **Guarantee** — addresses the actual fear, specific & bounded? | ___ | |
+| **Scarcity** — real, capacity-based? | ___ | |
+| **Urgency** — real, deadline kept? | ___ | |
+| **Name** — passes MAGIC, includes container word? | ___ | |
+
+---
+
+## Step 4 — Failure-mode flags
+
+Run through the 8 common failure modes from execution playbook. Flag any that apply:
+
+1. [ ] **Enhancing a weak base offer** — bonuses/guarantees stacked on a low-scoring Value Equation.
+2. [ ] **Fake scarcity / extending deadlines** — credibility signal failing.
+3. [ ] **Vague dream outcome** — no number, no time horizon, generic vocabulary.
+4. [ ] **Bonuses with no objection mapping** — feels like filler.
+5. [ ] **No mechanism named** — claims feel like magic, which feels like a scam.
+6. [ ] **Pricing-first thinking** — price set before value built.
+7. [ ] **Selling the product, not the offer** — "we build apps" vs "investor-ready MVP in 30 days or every late week is free."
+8. [ ] **Untested in market** — no evidence anyone has bought this offer yet.
+
+---
+
+## Step 5 — Prioritized fix list (top 3)
+
+Rank the 3 highest-impact fixes by expected effect on conversion. For each:
+
+1. **The fix** (specific change to make).
+2. **Why it matters** (which Value Equation variable or enhancement it improves).
+3. **Concrete wording / structure** to use (don't just diagnose — prescribe).
+
+**Prioritization heuristic:**
+- Foundation problems (market / avatar / commodity trap) come first.
+- Then the weakest Value Equation variable.
+- Then missing enhancement with the highest leverage (usually guarantee > bonuses > name > scarcity > urgency).
+
+---
+
+## Step 6 — Rewritten offer (optional)
+
+If the user wants a fully rewritten offer, apply the fixes and produce a finished version in the standard offer-document format from `SKILL.md`. Show the original and rewritten side-by-side or before/after, so the changes are visible.
+
+---
+
+## Output format for Critique Mode
+
+```
+## Critique: [offer name or "Pasted Offer"]
+
+### Foundation
+- Avatar: [PASS / FLAG — reason]
+- Market (starving crowd): [PASS / FLAG — reason]
+- Commodity test: [PASS / COMMODITY — reason]
+
+### Value Equation Scorecard
+- Dream Outcome:        __/10  — [one line]
+- Perceived Likelihood: __/10  — [one line]
+- Time Delay:           __/10  — [one line]
+- Effort & Sacrifice:   __/10  — [one line]
+- Average:              __/10
+- Weakest:              [variable] — fix here first.
+
+### Enhancement Checklist
+- Bonuses:    [present / weak / missing] — [notes]
+- Guarantee:  [present / weak / missing] — [notes]
+- Scarcity:   [present / weak / missing] — [notes]
+- Urgency:    [present / weak / missing] — [notes]
+- Name:       [present / weak / missing] — [notes]
+
+### Failure-mode flags
+- [list any flagged]
+
+### Top 3 Fixes (prioritized)
+1. **[Fix name]** — [what to change, concretely]
+   Why: [which lever it improves]
+   How: [specific wording or structure]
+2. ...
+3. ...
+
+### Optional rewritten offer
+[Full offer document if requested]
+```
+
+---
+
+## Tone
+
+- **Direct, not polite-at-the-expense-of-clarity.** If the offer is in a commodity trap or has a vague dream outcome, say so plainly.
+- **Specific, not generic.** "Raise the dream outcome" is not feedback. "Replace 'grow your business' with 'get to $50k MRR before runway ends'" is feedback.
+- **Prescriptive, not just diagnostic.** Every flagged issue gets a proposed fix.
+- **Respect the user's work.** Lead with what's already strong (if anything) before diving into fixes — but don't manufacture compliments.

package/claude-skills/hormozi/references/enhancements.md

@@ -0,0 +1,161 @@
+# Enhancements — Scarcity, Urgency, Bonuses, Guarantees, Naming
+
+The 5 levers that amplify a Grand Slam Offer after the base offer is built.
+
+**Application rule:** Build the base offer first (Value Equation + Problem→Solution→Trim→Stack). Only then apply these enhancements. **Refuse to enhance a weak base offer** — enhancements multiply value, they don't create it.
+
+**Application order:** Bonuses → Guarantee → Scarcity → Urgency → Name.
+
+---
+
+## 1. Bonuses
+
+### The rule
+**One bonus = one specific objection or accelerator.** Random extras feel like clutter.
+
+### Bonus design
+- **Name each bonus** like a product. "The Founder's Pitch Deck Template" > "a pitch deck template."
+- **Assign a dollar value** to each. Stack total should be ≥ 10x the price.
+- **Map each to an objection or outcome accelerator.** Every bonus must answer the question: "what does this dissolve or speed up?"
+
+### Bonus categories (use a mix)
+1. **Tools & templates** — checklists, scripts, code, swipe files.
+2. **Training** — recorded courses, walkthroughs.
+3. **Access** — community, Slack, weekly office hours.
+4. **Accountability** — check-ins, dashboards, calls.
+5. **Surprise / delight** — unannounced extras revealed after purchase (drives referrals).
+
+### Presentation
+```
+✓ Core deliverable .................... ($X value)
+✓ Bonus 1 — dissolves [objection] ..... ($X value)
+✓ Bonus 2 — accelerates [outcome] ..... ($X value)
+✓ Bonus 3 — access/community .......... ($X value)
+✓ Bonus 4 — surprise extra ............ ($X value)
+─────────────────────────────────────
+Total value: $XX,XXX
+Your investment: $X,XXX
+```
+
+---
+
+## 2. Guarantees
+
+### Why guarantees work
+They reverse risk from buyer to seller. The buyer's biggest objection is "what if this doesn't work?" — a great guarantee dissolves it.
+
+### The 4 guarantee types
+
+**1. Unconditional**
+- "Full refund within X days, no questions asked, no conditions."
+- Boldest. Most effective if delivery is solid. Refund rates surprisingly low when offer is genuinely good.
+
+**2. Conditional ("do the work")**
+- "Do X, Y, Z. If you don't get [result], full refund (or we work free until you do)."
+- Filters non-doers. Best for high-effort deliverables requiring buyer participation.
+
+**3. Anti-guarantee**
+- "No refunds. Here's why: [reason]."
+- For premium / exclusive offers where filtering buyers is the point. Must pair with strong reason-why.
+
+**4. Implied / performance**
+- "We only get paid when you hit [milestone]."
+- Maximum risk reversal. Hardest to structure. Common in growth marketing, consulting, equity-based work.
+
+### Stacked guarantees (the "ridiculous" effect)
+Combine multiple layers:
+> "Full refund within 14 days **AND** if you don't get [result] in 90 days, we work for free until you do **AND** a $500 'I'm sorry for wasting your time' check."
+
+Each layer addresses a different fear.
+
+### Design rules
+- **Specific and bounded.** Timeframes, conditions, outcomes — never vague.
+- **Addresses the buyer's actual fear**, not one you invented.
+- **A promise you must keep.** If you'd refuse to honor it, don't make it.
+
+---
+
+## 3. Scarcity (quantity-based)
+
+### Types (use real, never fake)
+1. **Supply-based** — "Only 10 client slots per quarter." Real because delivery capacity is finite.
+2. **Demand-based** — "47 founders applied this month, 6 accepted." Real because the application ratio is finite.
+3. **Bonus-based** — "First 5 buyers get [bonus X]." Real because you commit to limiting it.
+
+### The 1-in-100 rule
+Don't manufacture scarcity before you have real demand. Fake scarcity reads as a scam and burns trust permanently.
+
+### Public scarcity = social proof
+"3 slots left of 10" communicates both rarity *and* that others have already bought. Both raise perceived value.
+
+### Application examples
+- "We take 2 new MVP clients per month — Q3 is full, 1 slot left in Q4."
+- "Fractional CTO retainer: 4 founders max, currently working with 3."
+
+---
+
+## 4. Urgency (time-based)
+
+### Types
+1. **Rolling cohort deadlines** — next start date is fixed; miss it, next is N weeks out.
+2. **Rolling seasonal urgency** — price increases on schedule (quarterly, yearly).
+3. **Bonus deadlines** — "This bonus disappears Friday."
+4. **Exploding opportunities** — capacity-based deadlines ("hiring closes when slots fill").
+
+### Design rules
+- **The deadline must be real and kept.** A silently-extended deadline kills the credibility of every future deadline.
+- **Pair urgency with a reason-why.** "Cohort starts together so we can do live sessions" reads as logistics, not pressure.
+
+### Application examples
+- Quarterly price increases on retainers (real because you'll be busier).
+- "MVP Sprint cohort starts the first Monday of every month."
+- "Strategy audit is included if you book by [date]."
+
+---
+
+## 5. Naming — MAGIC formula
+
+### The formula
+- **M — Make a magnetic reason why** — Free / Exclusive / New / Beta / Anniversary.
+- **A — Announce your avatar** — "For [specific avatar]."
+- **G — Give them a goal** — the dream outcome.
+- **I — Indicate a time interval** — "in 30 days" / "over 6 weeks."
+- **C — Complete with a container word** — Challenge, Bootcamp, Sprint, Accelerator, System, Method, Blueprint, Intensive, Lab, Mastermind.
+
+### Putting it together
+- "**The Founder's MVP Sprint** — launch an investor-ready product in 30 days, for first-time technical founders."
+- "**The Fractional CTO Blueprint** — a 90-day system to hire and run your first 3 engineers, for seed-stage SaaS founders."
+- "**The Patient-Portal Accelerator** — HIPAA-ready clinical software in 60 days, for mental-health practices raising a seed."
+
+### Rules of thumb
+- Don't stuff all 5 elements. Pick the 3 that hit hardest.
+- **Container word is almost always required** — it makes the offer feel like *a thing* rather than *a service*.
+- Update names every 6–12 months. Fresh names revive demand even when the product is unchanged.
+
+### When to re-name an existing offer
+- Conversion is dropping on the same offer that used to work (offer fatigue).
+- You've niched down to a new avatar and the old name no longer signals fit.
+- You want to test premium pricing on a fresh frame.
+
+---
+
+## Application order — never skip
+
+1. **Build the base offer first** (Value Equation, Problem→Solution stack). No enhancements yet.
+2. **Bonuses** — pick 3–5, each mapped to a named objection or accelerator.
+3. **Guarantee** — pick the type that matches the effort profile and the buyer's biggest fear. Consider stacking.
+4. **Scarcity** — only if real. Capacity-driven preferred.
+5. **Urgency** — only if real. Cohort or pricing deadlines preferred.
+6. **Name** — MAGIC. This is the *last* step, not the first.
+
+If the base offer scores low on the Value Equation, **stop and fix the base before applying enhancements**. Bonuses on a weak offer = polishing a turd. Diagnose the offer first.
+
+---
+
+## Common failure modes
+
+1. **Bonuses with no objection-mapping.** "Plus, get these 10 bonuses!" reads as filler.
+2. **Vanity guarantees.** Refund policies that don't address the actual fear.
+3. **Faked scarcity / extended deadlines.** Burns trust permanently. Use real or none.
+4. **Names without a container word.** "Get more clients" is not a name. "The Client Accelerator" is.
+5. **Enhancing before the base works.** Wraps a weak offer in flashy paper. Buyers see through it.

package/claude-skills/hormozi/references/examples.md

@@ -0,0 +1,208 @@
+# Worked Examples — Slashdev Agency Offers
+
+Four fully-built Grand Slam Offers for a dev agency. Use as models for structure, depth, and tone. **Never copy verbatim** — every real offer must be tailored to the specific avatar, market, and current capacity.
+
+Each example shows: avatar → market check → dream outcome → problem→solution stack → enhancements → name → final offer document → Value Equation scorecard.
+
+---
+
+## Example 1 — The Founder's MVP Sprint
+
+### Avatar
+First-time technical founder, seed-stage SaaS, raised $1–3M in last 90 days, no in-house engineering team yet, runway under 18 months.
+
+### Market check
+- Massive pain? Yes — runway clock, investor pressure, no product to show.
+- Purchasing power? Yes — fresh seed capital.
+- Easy to target? Yes — Crunchbase, LinkedIn "Founder + Seed" filters, accelerator alumni lists.
+- Growing? Yes — record seed funding flows.
+
+### Dream outcome
+"Have a working, demo-able product in front of design partners and Series-A investors within 30 days, without spending 60% of my seed on a 6-month build."
+
+### Problem → solution stack (selected)
+
+| Problem | Solution |
+|---|---|
+| "I'll burn 60% of seed on agency hours." | Fixed-price 30-day sprint. |
+| "I don't have time to manage developers." | Async 15-min video standups; founder watches on own time. |
+| "What if the team disappears post-launch?" | 6 months of 30-min/month fractional-CTO calls included. |
+| "How do I show this to investors?" | Founder Pitch-Deck Template pre-built around the MVP. |
+| "What if I miss my Series-A window?" | Day-30 deadline guarantee — every late week free. |
+| "What if the code is bad?" | Third-party code-review pass included, you keep the report. |
+
+### Enhancements
+
+**Bonuses:**
+- Founder Pitch-Deck Template ($2,500 value) — dissolves "what do I show investors?"
+- Investor Outreach Email Sequence (5-touch) ($1,500 value) — accelerates "how do I get meetings?"
+- 6× monthly 30-min fractional-CTO calls ($3,000 value) — dissolves "what after launch?"
+- Third-party code review at delivery ($2,000 value) — dissolves "what if it's bad?"
+- Private founders' Slack ($1,000 value) — surprise/delight + community.
+
+**Guarantee (stacked):**
+- 30-day MVP delivery — every additional week free.
+- If the third-party code review fails, full refund.
+
+**Scarcity:** 2 MVP sprints per month, max.
+**Urgency:** Cohort starts the first Monday of every month.
+**Name (MAGIC):** "The Founder's MVP Sprint" (avatar + goal + container).
+
+### Final offer document
+
+```
+The Founder's MVP Sprint
+For: first-time technical founders, fresh seed, no eng team yet.
+
+The promise: A working, investor-ready MVP in 30 days — every late week is free.
+
+What you get:
+  ✓ 30-day fixed-price MVP build (incl. design, code, infra) .. ($45,000 value)
+  ✓ Founder Pitch-Deck Template ............................. ($2,500 value)
+  ✓ Investor Outreach Sequence (5-touch) .................... ($1,500 value)
+  ✓ 6× monthly fractional-CTO calls post-launch ............. ($3,000 value)
+  ✓ Third-party code review at delivery ..................... ($2,000 value)
+  ✓ Private founders' Slack ................................. ($1,000 value)
+  ✓ Guarantee: every late week is free; refund on failed code review
+  ✓ Scarcity: 2 sprints per month, max
+  ✓ Urgency: cohort starts first Monday monthly
+
+Total value: $55,000
+Your investment: $25,000 (flat, fixed price)
+```
+
+### Value Equation scorecard
+- Dream outcome: 9/10 (named, specific, time-boxed).
+- Likelihood: 8/10 (named mechanism, guarantee, code-review proof).
+- Time delay: 9/10 (30-day cap, weekly demos).
+- Effort & sacrifice: 8/10 (async, done-for-you, no eng knowledge needed).
+
+---
+
+## Example 2 — The Fractional CTO Blueprint
+
+### Avatar
+Seed-to-Series-A SaaS founder, has hired 1–2 engineers ad-hoc, knows they need a CTO but can't justify the full-time hire yet.
+
+### Dream outcome
+"Make the right early engineering hires and run the team well, without paying for a $300k full-time CTO."
+
+### Problem → solution stack (selected)
+
+| Problem | Solution |
+|---|---|
+| "I don't know what kind of engineer to hire first." | Hiring scorecard + role definition. |
+| "I can't evaluate technical candidates." | Outsourced technical interview rounds (we run them). |
+| "Once they're hired, what do I have them do?" | First-90-days plan, written for the role. |
+| "How do I tell if they're underperforming?" | Weekly engineering dashboard + monthly review template. |
+| "What if I get this wrong?" | Full refund + free re-hire if first hire fails review within 90 days. |
+
+### Enhancements
+
+**Bonuses:**
+- First-3-Engineers Hiring Scorecard ($1,500 value) — dissolves "what do I hire first?"
+- 30-min/month founder coaching call ($3,600 value annualized) — accelerates judgment.
+- Engineering team dashboard (Notion template) ($800 value) — dissolves "how do I tell?"
+
+**Guarantee:** "If your first hire fails the 90-day review, we re-run the search and pay for the interview rounds."
+
+**Scarcity:** 4 founders max on retainer at any time.
+**Urgency:** Quarterly price increases on retainer.
+**Name:** "The Fractional CTO Blueprint."
+
+### Final offer document
+
+```
+The Fractional CTO Blueprint
+For: seed-to-Series-A SaaS founders hiring their first engineers.
+
+The promise: Hire and run your first 3 engineers in 90 days — or we re-run the search free.
+
+What you get:
+  ✓ Weekly 1:1 strategy call (60 min) ........................ ($24,000 value/yr)
+  ✓ First-3-Engineers Hiring Scorecard ...................... ($1,500 value)
+  ✓ Outsourced technical interview rounds (up to 6/quarter) .. ($6,000 value)
+  ✓ First-90-days plan per hire ............................. ($1,500 value)
+  ✓ Engineering team Notion dashboard ....................... ($800 value)
+  ✓ Founders' Slack access .................................. ($1,000 value)
+  ✓ Guarantee: free re-run if first hire fails 90-day review
+  ✓ Scarcity: 4 founders max, currently 3 active
+
+Total value: $34,800/yr
+Your investment: $4,000/month
+```
+
+### Value Equation scorecard
+- Dream outcome: 8/10.
+- Likelihood: 9/10 (mechanism, guarantee, accountability).
+- Time delay: 8/10 (90-day milestone).
+- Effort & sacrifice: 9/10 (we run interviews, founder makes the call).
+
+---
+
+## Example 3 — The HIPAA Patient-Portal Accelerator
+
+### Avatar
+Mental-health clinic owner or clinical-SaaS founder, recently raised seed, needs HIPAA-compliant patient portal to land design partners or pass procurement.
+
+### Dream outcome
+"Ship a HIPAA-ready patient portal in 60 days that clears procurement at our first three clinics."
+
+### Stack highlights
+- Pre-built HIPAA compliance scaffolding (BAA-ready infra, audit logging, encryption at rest/transit).
+- Procurement-pack: documentation kit pre-formatted for clinic IT review.
+- Day-14 working demo guarantee.
+- HIPAA gap-scan lead magnet → offer.
+
+**Name:** "The Patient-Portal Accelerator."
+
+**Guarantee:** "If your first clinic's IT review fails on a compliance gap we missed, we fix it free *and* refund 50%."
+
+**Scarcity:** 1 clinical client per quarter.
+
+**Pricing anchor:** $75,000 flat.
+
+### Why this works
+The avatar's biggest fear is *failing procurement*. The offer is built around that single fear: pre-built compliance, procurement-pack bonus, IT-review guarantee. The price is high but the alternative (failing procurement → no first clinic → no Series-A story) is much higher.
+
+---
+
+## Example 4 — The Productized AI Integration
+
+### Avatar
+Existing SMB SaaS, $1–5M ARR, no in-house ML, wants to ship an AI feature (chatbot, summarization, search, document parsing) without committing to a 6-month build.
+
+### Dream outcome
+"Launch an AI feature that customers actually use within 4 weeks, without hiring ML engineers."
+
+### Stack highlights
+- Fixed-price 4-week build.
+- Choose one of 5 productized AI features (each pre-scoped).
+- Bonus: free Slack/AI ROI calculator (also the lead magnet).
+- Performance bonus: "If activation rate doesn't hit 30% by week 8, we iterate free for 30 days."
+
+**Name:** "The AI Feature Sprint."
+
+**Scarcity:** 3 sprints per month.
+
+**Pricing anchor:** $15,000 flat.
+
+### Why this works
+Productizing across 5 features lets you price low (pre-scoped) while keeping margin healthy. The activation guarantee dissolves "what if customers don't use it" — the actual fear for SaaS founders shipping AI.
+
+---
+
+## Pattern across all 4 examples
+
+Notice the recurring moves:
+1. **Avatar is narrow and named.** Not "founders" — "seed-stage SaaS founders, no eng team."
+2. **Dream outcome is specific and time-boxed.** "X in 30 days," "Y by quarter-end."
+3. **Bonuses each map to a named objection.** Pitch deck → "what do I show investors?" Code review → "what if it's bad?"
+4. **Guarantee addresses the *actual* fear**, not a generic refund.
+5. **Scarcity is real and capacity-driven** (slots per month).
+6. **Urgency is structural** (monthly cohorts, quarterly price increases).
+7. **The name passes MAGIC** with a container word ("Sprint," "Blueprint," "Accelerator").
+8. **One-sentence summary works:** "Get [outcome] in [time] without [sacrifice], or [guarantee]."
+9. **Total perceived value ≥ 2× the price** (often higher — these examples are conservative).
+
+Use these as scaffolds, not templates. Every real offer must be tuned to the actual avatar, real capacity, real guarantee you'd honor.

package/claude-skills/hormozi/references/grand-slam-offer.md

@@ -0,0 +1,105 @@
+# Grand Slam Offer
+
+The target. An offer presented so compellingly the buyer feels stupid saying no.
+
+## Definition
+
+A **Grand Slam Offer** = a combination of:
+- A product/service that solves a real problem,
+- A price that's irrelevant relative to perceived value,
+- Value-building components (bonuses, guarantees, scarcity, urgency, naming),
+- A named mechanism that makes results feel believable and inevitable.
+
+It is not "a good deal." It's *stupid to refuse*.
+
+---
+
+## The Grand Slam test
+
+After designing or reviewing an offer, ask: **Would a reasonable prospect in the target avatar feel stupid saying no?**
+
+- "It's a fair deal" → not a Grand Slam yet.
+- "Why would I not?" → Grand Slam.
+
+If the offer doesn't pass, identify which Value Equation variable is weakest and iterate there before adding more enhancements.
+
+---
+
+## The commodity test
+
+A **commodity** = any product/service the buyer can directly compare on price against a competitor.
+
+**Run this test:** can the prospect Google "[your category] near me" or "[your category] alternatives" and get a list with comparable prices?
+
+- Yes → commodity. The offer is in a category that's already been priced down by the market.
+- No → categorically differentiated. You've moved into a new comparison frame.
+
+### Two kinds of differentiation
+1. **Gradient** — "20% better/cheaper/nicer." Buyer still comparison-shops you. Loses.
+2. **Categorical** — "we don't sell that; we sell *this*." Buyer can't compare. Wins.
+
+### Categorical moves
+- Re-package: same work, different bundle ("custom web dev" → "30-day investor-ready MVP with founding-investor deck").
+- Re-target: same offer, narrower avatar ("dev agency" → "HIPAA-compliant patient portals for clinical SaaS").
+- Re-name: MAGIC formula (`enhancements.md`).
+- Re-mechanism: name the system that makes it work ("our 3-phase sprint process").
+
+---
+
+## The starving-crowd test (market check)
+
+Before building or critiquing the offer itself, score the market on 4 criteria:
+
+| Criterion | Question | Pass condition |
+|---|---|---|
+| **Massive pain** | Is the problem acute, urgent, emotionally loaded? | Yes, with a real consequence of inaction. |
+| **Purchasing power** | Can they afford premium pricing? | Yes, budget exists or can be unlocked. |
+| **Easy to target** | Do they congregate somewhere reachable? | Yes — forums, conferences, LinkedIn segments, titles. |
+| **Growing** | Is the market expanding? | Yes, rising tide or category emergence. |
+
+**Decision rule:** if the offer is failing, **change the market before changing the offer**. A Grand Slam Offer in the wrong market still fails.
+
+---
+
+## Niching down
+
+Niche until you can name the avatar exactly: **role + company stage + industry + acute pain**.
+
+- "Small businesses" → no.
+- "Founders" → no.
+- "Seed-stage SaaS founders without a CTO who just raised in the last 60 days" → yes.
+
+Niching narrows the audience but raises the price per prospect, because perceived fit moves from "general" to "exactly for me." Hormozi's claim: a tight niche supports up to 10x the pricing of a generic one.
+
+---
+
+## What the 4 levers of the offer multiply
+
+A Grand Slam Offer affects all 4 business growth dials:
+
+1. **Leads** — premium offers attract premium prospects (and content/referrals around the offer compound).
+2. **Conversion** — feel-stupid-saying-no = higher close rate.
+3. **Price** — perceived value supports higher dollar amounts.
+4. **Retention / LTV** — premium clients pay attention, do the work, get results, refer.
+
+If a business is struggling, the offer is almost always the highest-leverage thing to fix — before traffic, ads, or hiring.
+
+---
+
+## Quick checklist
+
+Before declaring an offer a Grand Slam:
+- [ ] Avatar is named (role + stage + industry + pain).
+- [ ] Market passes all 4 starving-crowd criteria.
+- [ ] Offer is categorical, not gradient (passes the commodity test).
+- [ ] Dream outcome is specific (would the prospect say it back?).
+- [ ] Mechanism is named.
+- [ ] Value Equation scores 7+ on all 4 dimensions.
+- [ ] Bonuses each map to an objection or accelerator.
+- [ ] Guarantee reverses the buyer's actual fear.
+- [ ] Scarcity is real (capacity-based).
+- [ ] Urgency is real (kept deadline).
+- [ ] Name passes MAGIC.
+- [ ] One-sentence summary works: "Get [outcome] in [time] without [sacrifice], or [guarantee]."
+- [ ] Total perceived value ≥ 10x price.
+- [ ] Final test: a reasonable prospect feels stupid saying no.

package/claude-skills/hormozi/references/lead-magnets.md

@@ -0,0 +1,115 @@
+# Lead Magnets — the Free Grand Slam Offer
+
+A lead magnet is a Grand Slam Offer priced at $0. The "price" is contact info and attention, not money. **All Value Equation rules still apply.**
+
+---
+
+## Two non-negotiables
+
+1. **Complete, not teased.** The recipient must actually solve the narrow problem with what you gave them. No "buy the paid thing to finish."
+2. **Narrow, not broad.** Solve *one* small specific problem, not "everything you need to know about X."
+
+A great lead magnet solves a problem completely, then *reveals the next problem* — which is what the paid offer solves.
+
+---
+
+## The 6 lead-magnet types
+
+### 1. Free trial / sample
+A bounded slice of the paid product (7-day software trial, sample chapter, free first session).
+- **Best for:** products where experiencing the thing is the conversion mechanism.
+- **Risk:** giving too much (no reason to upgrade) or too little (no real experience).
+
+### 2. Free service
+You do something *for* the prospect — audit, strategy call, SEO scan, design teardown.
+- **Best for:** services where your expertise is the value and the prospect can't evaluate it from outside.
+- **Risk:** delivery cost — must convert at a rate that pays for itself.
+
+### 3. Free physical item
+A tangible thing mailed to the prospect (book, hardware sample, branded tool).
+- **Best for:** high-ticket B2B where item cost is small vs. LTV; reciprocity through physical presence.
+- **Risk:** shipping logistics; only viable for premium offers.
+
+### 4. Software / tool
+A working tool that does something useful (calculator, template generator, Chrome extension, Notion template, Figma file).
+- **Best for:** technical / quantitative niches. Great fit for dev agencies.
+- **Risk:** must actually work and look polished — broken tools destroy trust.
+
+### 5. Useful information
+Knowledge in consumable form (guide, ebook, video course, swipe file, framework doc).
+- **Best for:** when the prospect's bottleneck is knowledge or vocabulary.
+- **Risk:** most-abused format. Make it short, finished, immediately applicable.
+
+### 6. Audit / checklist
+A diagnostic the prospect runs against their own situation ("Score your landing page in 60 seconds," "10-point investor-readiness checklist").
+- **Best for:** revealing problems the prospect didn't know they had — sets up the paid offer naturally.
+- **Risk:** if the audit doesn't surface real problems, no follow-up logic.
+
+---
+
+## 5-step design sequence
+
+### Step 1 — Identify the ideal-client problem
+Use the same problem-mining matrix as the paid offer (`problem-solution-stack.md`). Pick problems the paid offer solves *as a whole*. The magnet will target one narrow slice.
+
+### Step 2 — Pick a narrow problem to solve completely
+Not "marketing." Specifically: "headline for a B2B SaaS landing page that converts at 5%+."
+
+**Test:** can you solve this problem in 10 minutes of the prospect's time, end-to-end? If no, narrow further.
+
+### Step 3 — Pick the format that fits the consumption mode
+- They want to *see* it work → free trial / tool / service.
+- They want to *learn* → useful info / checklist.
+- They want to *get* → physical item / template.
+- They want to *understand themselves* → audit.
+
+Format must match how the prospect *actually consumes content* in this niche. Engineers don't want ebooks. Coaches don't want code samples.
+
+### Step 4 — Make it easy to consume
+- Short (length scales inverse to value perception past ~10 pages).
+- Clear (no jargon they don't already know).
+- Linear (one path through, no choose-your-own-adventure).
+- Self-contained (no "set up an account first").
+
+### Step 5 — Engineer the bridge to the paid offer
+The end of the lead magnet must do one job: **make the next step obvious and easy**.
+- Surface the next problem the magnet's win creates.
+- Offer the paid solution as the answer.
+- Include a clear, low-friction next step (book a call, watch a demo, see the offer).
+
+The bridge isn't a hard pitch — it's a continuation of the same logic that made the magnet useful.
+
+---
+
+## Naming lead magnets
+
+Apply the MAGIC formula. Bonus rule: **name a specific result, not a topic**.
+
+- Bad: "The Ultimate Guide to MVPs"
+- Better: "The 14-Point MVP Launch Audit"
+- Best: "The 14-Point MVP Launch Audit — score your build's investor-readiness in 10 minutes"
+
+---
+
+## Common failure modes
+
+1. **Teasing instead of giving.** "Free guide" ends with "buy the course to find out the rest." Burns trust permanently.
+2. **Solving too much.** 90-page free ebook nobody reads. No win, no trust, no bridge.
+3. **Wrong format for the avatar.** Free PDF for a dev audience that prefers GitHub repos.
+4. **No bridge.** Great magnet, but the "what next" is unclear or absent.
+5. **Magnet solves a problem the paid offer doesn't extend from.** Attracts prospects who don't need the paid thing. Watch magnet-to-paid conversion, not just opt-ins.
+6. **Hidden delivery friction.** "Check spam folder," "wait 24 hours" — every step of delay drops conversion.
+
+---
+
+## Agency-flavored examples
+
+| Paid offer | Matched lead magnet | Type |
+|---|---|---|
+| "30-day investor-ready MVP" | "14-point MVP launch audit" | Audit |
+| "Fractional CTO retainer" | "First-3-engineers hiring scorecard" | Audit / template |
+| "HIPAA-compliant patient portal sprint" | "Free HIPAA-compliance gap scan" | Free service |
+| "Productized AI integration" | "Free Slack/AI ROI calculator" | Software / tool |
+| "Async-only dev team retainer" | "The Founder's Async Standup Template (Notion)" | Useful info / template |
+
+In each case the magnet solves a *narrow* problem completely, and the win reveals the *next* problem that the paid offer solves.

package/claude-skills/hormozi/references/problem-solution-stack.md

@@ -0,0 +1,125 @@
+# Problem → Solution → Trim & Stack
+
+The 4-step build process for constructing a Grand Slam Offer from a blank page.
+
+---
+
+## Step 1 — List every problem (mine 20+)
+
+Use the **time-phase × problem-type** matrix. For one named avatar pursuing one dream outcome, brainstorm problems across both axes.
+
+### Time-phase axis
+- **Before they buy** — objections, doubts, decision paralysis, fear of being wrong.
+- **At purchase** — payment friction, onboarding confusion, second-guessing.
+- **During delivery** — implementation difficulty, time cost, motivation dips, skill gaps.
+- **After delivery** — maintenance, scaling, "what's next," result decay.
+
+### Problem-type axis (apply to each phase)
+- **Tactical/practical** — they don't know how.
+- **Time** — they don't have hours.
+- **Skill/capacity** — they can't do it themselves.
+- **Emotional** — fear, shame, overwhelm.
+- **Social** — what will partner/team/peers think.
+- **Financial** — opportunity cost, tools, hiring beyond price.
+- **Identity** — "I'm not a tech/sales/marketing person."
+
+### Volume rule
+**Mine at least 20 specific problems for one avatar.** Fewer = the offer will miss obstacles the prospect actually has. More is better.
+
+### Specificity rule
+Problems must be specific, not categorical. Bad: "they're busy." Good: "they don't have time to review and approve design decisions during the build."
+
+---
+
+## Step 2 — Invert each problem into a solution
+
+For every problem, write the deliverable, system, template, or process that dissolves it.
+
+### Phrasing pattern
+- "A system for ___" — for recurring problems.
+- "How to ___" — for knowledge problems.
+- "Done-for-you ___" — for capacity problems.
+- "Template / script / checklist for ___" — for tactical problems.
+
+### Output: two-column table
+
+| Problem | Solution |
+|---|---|
+| "I don't have time to manage the build day-to-day." | "Weekly 15-min async video standup — watch on your own time." |
+| "What do I show investors after the build?" | "Founder's pitch deck template + investor outreach sequence." |
+| "What if the team disappears after launch?" | "30-min/month fractional-CTO call for 6 months post-launch." |
+| ... | ... |
+
+---
+
+## Step 3 — Brainstorm delivery vehicles for each solution
+
+The same solution can be delivered through **7 different vehicles** with very different Value Equation scores. For every solution, force a brainstorm across all 7:
+
+| # | Delivery vehicle | Effort & sacrifice (buyer) | Cost to deliver (you) | Time to value |
+|---|---|---|---|---|
+| 1 | **1:1 personal attention** | Low | Highest | Fast |
+| 2 | **Small group cohort** | Low–medium | High | Medium |
+| 3 | **Large group / course** | Medium | Medium | Slow |
+| 4 | **Done-for-you service** | Lowest | Highest | Fast |
+| 5 | **Done-with-you** | Medium | Medium | Medium |
+| 6 | **DIY with tools/templates** | High | Low | Fast (if templates good) |
+| 7 | **Reference material (PDF/video)** | Highest | Lowest | Self-paced |
+
+**The point:** if a solution scores low on the Value Equation in its current vehicle, try a different vehicle before dropping it. A "training module" can become a "done-for-you setup" and now scores 9 instead of 4.
+
+---
+
+## Step 4 — Trim and stack
+
+### Trim
+For each candidate deliverable, you now have:
+- 4 Value Equation scores (dream outcome / likelihood / time / effort).
+- 1 cost-to-deliver score (your time and dollar cost).
+
+**Trim rule:**
+- Drop: high cost-to-deliver AND low Value Equation. These bleed margin without helping the offer.
+- Keep: high Value Equation regardless of cost (these are the spine).
+- **Especially keep:** low cost-to-deliver AND high Value Equation (templates, frameworks, automations). These become bonuses — they multiply perceived value cheaply.
+
+### Stack
+Combine surviving deliverables into a single named offer. Present visually:
+
+```
+The [MAGIC-formula name]
+
+✓ Core deliverable 1 — solves [problem] ............. ($X value)
+✓ Core deliverable 2 — solves [problem] ............. ($X value)
+✓ Bonus 1 — dissolves [objection] ................... ($X value)
+✓ Bonus 2 — accelerates [outcome] ................... ($X value)
+✓ Bonus 3 — community / access ...................... ($X value)
+✓ Guarantee: [specific terms]
+✓ Scarcity: [real capacity limit]
+✓ Urgency: [real deadline]
+
+Total value: $XX,XXX
+Your investment: $X,XXX
+```
+
+---
+
+## Quality tests (apply at the end)
+
+Before finishing the stack:
+
+- [ ] **Coverage test:** every major problem from step 1 is addressed by at least one deliverable.
+- [ ] **10x value rule:** total perceived value is ≥ 10x the price.
+- [ ] **One-sentence summary test:** the offer compresses to "Get [dream outcome] in [time] without [sacrifice], or [guarantee]." If you can't write the sentence, the offer isn't done.
+- [ ] **Bonus-objection map:** every bonus names the specific objection or accelerator it addresses.
+- [ ] **Mechanism named:** the offer has a named system/process/method that explains *why* it works.
+- [ ] **Grand Slam test:** a reasonable prospect feels stupid saying no.
+
+---
+
+## Common mistakes
+
+1. **Listing 5 problems instead of 20.** Thin problem list → thin offer → uncovered objections.
+2. **Solutions phrased as features, not deliverables.** "We're experienced" is not a deliverable. "30-min monthly fractional-CTO call for 6 months" is.
+3. **Picking the obvious delivery vehicle without brainstorming the other 6.** Most upgrades from 4/10 to 9/10 come from changing the vehicle, not the content.
+4. **Trimming the spine to keep margin healthy.** Cut bonuses first, not core deliverables. Trim is about removing waste, not lowering the offer.
+5. **Stacking before scoring.** Without Value Equation scores, the stack is just a wish list. Score first, then stack.

package/claude-skills/hormozi/references/value-equation.md

@@ -0,0 +1,105 @@
+# Value Equation
+
+The master scoring lens. Every offer component is scored against this. Used in both Build Mode (to design deliverables) and Critique Mode (to score existing offers).
+
+## The formula
+
+```
+                 Dream Outcome  ×  Perceived Likelihood of Achievement
+Value  =  ───────────────────────────────────────────────────────────
+                 Time Delay     ×  Effort & Sacrifice
+```
+
+To raise value: raise the numerator OR lower the denominator. Best offers do both.
+
+---
+
+## The 4 variables
+
+### 1. Dream Outcome (numerator — maximize)
+The specific result the prospect wants, in *their* words.
+
+**Levers that raise it:**
+- Name the outcome with a number and timeline.
+- Use the prospect's vocabulary, not your industry's jargon.
+- Tie to identity ("the founder who shipped on time") not just metric.
+
+**Failure modes:**
+- Selling the process ("we use Next.js") instead of the outcome.
+- Generic outcomes ("grow your business") instead of dream ("$50k MRR before runway ends").
+
+**Scoring 1–10:**
+- 1–3: vague, abstract, no number, no time horizon.
+- 4–6: specific outcome but generic vocabulary or weak emotional pull.
+- 7–9: named outcome, prospect's vocabulary, clear time and metric.
+- 10: prospect would say this back to you unprompted.
+
+### 2. Perceived Likelihood of Achievement (numerator — maximize)
+The prospect's belief that *this* will work for *them*, specifically.
+
+**Levers that raise it:**
+- **Mechanism** — a named, specific reason your thing works (e.g., "3-phase sprint that's launched 47 funded products").
+- **Social proof** — testimonials, case studies, logos, numbers, named clients.
+- **Guarantees** — risk reversal (see `enhancements.md`).
+- **Demonstration** — walkthroughs, samples, audits, free trials.
+- **Authority** — credentials, press, founder story.
+
+**Scoring 1–10:**
+- 1–3: claims with no proof, no mechanism, no guarantees.
+- 4–6: some testimonials or one mechanism, but limited.
+- 7–9: named mechanism + multiple proof types + a guarantee.
+- 10: stacked proof, named mechanism, ridiculous guarantee — feels inevitable.
+
+### 3. Time Delay (denominator — minimize)
+Time between purchase and *first felt result* (not final result).
+
+**Two timelines matter:**
+- **Time to first win** (build this into week 1).
+- **Time to full outcome** (the headline timeline).
+
+**Levers that lower it:**
+- Quick wins in week 1 (day-1 deliverable, week-1 milestone).
+- Pre-purchase quick wins (audit, template, mini-result).
+- Async/parallel delivery (don't gate on weekly calls).
+
+**Scoring 1–10:**
+- 1–3: months until first felt result, vague timeline.
+- 4–6: weeks to first win, named timeline for full outcome.
+- 7–9: days to first win, fast full timeline.
+- 10: tangible value delivered before purchase or on day 1.
+
+### 4. Effort & Sacrifice (denominator — minimize)
+What they have to *do* (effort) and *give up* (sacrifice — time, identity, comfort, money beyond price).
+
+**Levers that lower it:**
+- Done-for-you > done-with-you > do-it-yourself.
+- Pre-built templates, scripts, automations.
+- Remove prerequisites ("no coding required").
+- Remove identity-cost ("you don't have to become a tech person").
+
+**Scoring 1–10:**
+- 1–3: high hands-on time, prerequisite skills, identity shift required.
+- 4–6: moderate involvement, some templates, some prerequisites.
+- 7–9: mostly done-for-you, minimal prerequisites, async-friendly.
+- 10: turnkey — they show up, results happen.
+
+---
+
+## Quick-apply checklist (use on every deliverable in an offer)
+
+For each deliverable:
+- [ ] Dream Outcome contribution: __/10
+- [ ] Likelihood contribution: __/10
+- [ ] Time to felt value: __/10 (lower-time = higher score)
+- [ ] Effort & Sacrifice required: __/10 (lower-effort = higher score)
+- [ ] Cost to deliver (your $/time): __ (separate; informs trim)
+
+**Trim rule:** drop anything that is high cost-to-deliver AND scores low on the 4 dimensions. Keep low-cost/high-value (these become bonuses) and high-cost/very-high-value (these are the spine).
+
+## Common mistakes
+
+1. **Optimizing one variable, ignoring the other three.** The equation is multiplicative — a 10 on dream outcome with a 1 on likelihood still scores low.
+2. **Conflating dream outcome with deliverables.** "We give you 10 calls" is a deliverable, not an outcome. The outcome is what those calls produce.
+3. **Vanity guarantees.** Guarantees that don't address the buyer's actual fear don't raise likelihood. A 30-day refund doesn't help when the fear is "this won't work for my niche."
+4. **Time-delay theater.** Promising "results in 30 days" when the first felt value isn't until day 25. Build in a day-1 deliverable.
+5. **Hiding the effort cost.** Buyers discover the real effort post-purchase and refund. Disclose effort honestly, then design the offer to lower it.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slashdev",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Skills & workflows for AI agents in the Slashdev ecosystem",
   "type": "module",
   "main": "src/index.js",