rsc-universal 0.1.1

package/skills/landing-copy/SKILL.md

@@ -0,0 +1,153 @@
+---
+name: landing-copy
+description: "Use when writing the words on a single conversion page — the hero headline and subhead, the offer, the proof/testimonials, and one primary CTA — or rescuing a page that gets traffic but does not convert (a copy diagnosis, not a layout one). Triggers: 'write the hero headline and subhead', 'write the landing copy', 'turn these features into benefits', 'what should the button say', 'make the page headline match the ad', 'people land on the page and bounce', 'my headline is clever but nobody clicks the button', 'escríbeme el copy de la landing', 'el titular del hero no convierte'. NOT the paid ad that drives the click (that is ads), NOT the visual layout the words sit in (that is design), NOT the experiment that picks the winning variant (that is ab-testing)."
+tags: [landing-page, copywriting, conversion, hero-headline, cta, social-proof]
+recommends: [ads, design, brand-voice, ab-testing, case-studies]
+origin: risco
+---
+
+# Landing Copy — The Words That Convert on One Page
+
+*Hook, offer, proof, CTA. You write the words a visitor reads top to bottom; you do not draw the layout, build the page, or write the ad that sent them.*
+
+This skill owns **conversion copy for a single page**: a hero headline under ~8 words plus a benefit subhead, a top-to-bottom page skeleton, the offer stated as a benefit, proof slotted next to the ask, and one primary CTA repeated without competing. It is a copy job. The pixels are `design`'s, the React/Next build is `nextjs`'s, the ad that drives the click is `ads`'s.
+
+## When to use
+
+- Writing or rewriting a hero: H1 + subhead + button copy.
+- Structuring a full landing/sales page (hook → problem → offer → proof → CTA → objections).
+- Choosing and writing one primary CTA and its repeated instances.
+- Turning features into benefits ("AES-256 encryption" → "your security team signs off in days").
+- Slotting proof — testimonials, metrics, logos, a guarantee — next to the ask.
+- Making the page headline *match* the ad/email that drove the click (message match).
+- Rescuing a page that gets traffic but does not convert — when the failure is the words.
+
+## When NOT to use (route to the sibling that owns it)
+
+- Visual layout, hierarchy, spacing, component system → `design` (`../design/SKILL.md`).
+- Building the page in code, form wiring, routing → `nextjs` (`../nextjs/SKILL.md`) / `react`.
+- The paid Google/Meta ad copy that drives traffic *to* the page → `ads`.
+- The brand's tone, voice rules, lexicon, do/don't word list → `brand-voice`.
+- Ranking in organic search or getting cited by AI answer engines → `seo-geo`.
+- Designing and running the experiment that picks the winning variant → `ab-testing`.
+- Writing the standalone customer story as its own asset → `case-studies`.
+- A multi-channel launch plan, nurture emails, or campaign strategy → `marketing` (`../marketing/SKILL.md`).
+
+Boundary in one line: **you own the words that convert on one page; `ads` owns the click that arrives, `design` owns the layout they sit in, `ab-testing` owns the proof of which words win.**
+
+## The conversion reality (calibrate, never promise)
+
+These numbers set expectations. State them as a band; the moment you promise a flat conversion rate you are lying to the user.
+
+- **Cross-industry median is ~6.6%; strong pages in any vertical reach 10–15%+.** Per-vertical the spread is wide: Events & Entertainment ~12.3%, Financial Services ~8.4%, SaaS/Tech ~3.8%, Ecommerce ~2.35%, B2B services ~1–3%. *Why:* a SaaS team told "you'll hit 12%" was quoted the events median; quote the band for *their* vertical so the goal is real. (Foundry CRO benchmarks 2026, citing Unbounce's analysis of 464M visits / 41k pages.)
+- **Visitors decide whether to stay in ~5 seconds, and ~80% rarely scroll past the fold.** *Why:* the hero is the single highest-leverage copy on the page — if it does not answer "what is this and why should I care" before a scroll, the rest is unread. (Hero-section research / NN/g attention studies 2026.)
+
+## The four blocks — the spine of the page
+
+Every conversion page is these four jobs, top to bottom. Each has a distinct question, a home on the page, and a failure mode. Diagnose a dead page by finding which block is weak.
+
+| Block | Must answer | Lives where | Failure mode if weak |
+| --- | --- | --- | --- |
+| **Hook** | "What is this and why should I care?" in <5s | Hero, above the fold | Visitor bounces before scrolling; ~80% never see the rest |
+| **Offer** | "What exactly do I get, and what does it cost me?" | Right after the hook / problem | Feature dump; reader can't tell what they walk away with |
+| **Proof** | "Why should I believe you?" | Adjacent to each CTA | Claims read as marketing; trust never forms |
+| **CTA** | "What is the one thing to do next?" | Hero, repeated down the page | Competing asks → decision fatigue → no click |
+
+## The hook
+
+The H1 carries the *what*; the subhead carries the *benefit*; both must echo whatever the visitor clicked.
+
+- **H1 under ~8 words / ~44 characters.** The constraint forces clarity, and a clear headline beats a clever one every time. If you can't say it in 8 words you don't understand the offer yet.
+- **Subhead carries the benefit** — who it's for and the outcome they get, in one clause.
+- **Message match:** the headline must echo the promise of the ad/email that drove the click. Aligning a single claim across ad + page has produced a 66% CVR lift in documented cases (and 212% from fixing message match alone). *You match the page to the ad; writing the ad is `ads`.*
+
+```text
+Bad  — "Reimagine The Future Of Financial Operations"   (clever, 6 words, says nothing)
+Good — "Expense reports done in 30 seconds"             (clear, 5 words, names the outcome)
+         Subhead: For finance teams drowning in receipts — snap, submit, approved.
+```
+
+## The offer
+
+Name the thing, the outcome, and the cost in effort or money. Lead with the outcome the buyer gets, then the mechanism that delivers it. This feature→benefit transform is the highest-impact copy shift on most pages.
+
+The scaffold is **FAB** — Feature → Advantage → Benefit — but you stop at the benefit the reader cares about and back it with the mechanism as proof, not the other way round.
+
+```text
+Bad  — "Our platform has advanced AES-256 encryption."
+Good — "Protect customer data with AES-256 encryption, so your security team
+         signs off in days, not months."
+```
+
+Rule: every feature line answers "so what?" with an outcome. If it can't, cut it.
+
+## The proof
+
+Belief is built next to the ask, not in a wall of quotes elsewhere.
+
+- **3–5 specific, named testimonials, each with a concrete result.** "Great product!" persuades no one; "cut our close time from 9 days to 2 — Maria, CFO at Lumen" does. Specific beats superlative.
+- **Place proof adjacent to the primary CTA.** Social proof next to the ask has lifted conversion ~68% in documented cases; reviews/testimonials are decisive for ~93% of buyers and ~88% trust them like a personal recommendation. *Why:* belief and the decision happen in the same moment — put the evidence where the click is.
+- Numbers, recognizable logos, and a risk-reversal (money-back, no card required) are proof too. One hard number outweighs three adjectives.
+- **Never fabricate proof.** If a metric, quote, or logo isn't real, mark `[[NEEDS PROOF]]` and ask the user — do not invent it.
+
+```text
+Bad  — "Loved by teams everywhere. World-class results!"
+Good — "We cut expense-report time 82% in the first month."
+         — Maria Ortiz, CFO, Lumen (47-person finance team)
+```
+
+## The CTA
+
+One primary action, verb-led, repeated — not varied — down the page.
+
+- **One primary CTA per page.** Competing asks cause decision fatigue and lower conversion. The same action appears in the hero and again at each decision point; secondary links may exist but must not compete visually or verbally with the primary.
+- **Movement verbs, never "Submit".** "Start free trial", "Get my quote", "See plans" — the button states the value, not the form action.
+- **First-person framing often lifts clicks:** "Start my free trial" reads as the visitor's own intent. Pair the button with one line of friction-reducing microcopy ("No credit card required").
+
+```text
+Bad  buttons — [Submit]            [Learn more]        [Contact sales]
+Good buttons — [Start my free trial]  ...repeated...  [Start my free trial]
+                under it: No credit card. Cancel anytime.
+```
+
+## Frameworks as scaffolds (fill with the reader's words)
+
+These are skeletons to fill with the buyer's actual language, not fill-in templates:
+
+- **PAS** — Problem → Agitate → Solution. Best for pain-aware traffic.
+- **AIDA** — Attention → Interest → Desire → Action. Broad top-of-funnel.
+- **BAB** — Before → After → Bridge. Transformation stories.
+- **FAB** — Feature → Advantage → Benefit. The offer block.
+
+Common stack: **PAS/AIDA hook → FAB offer → proof → CTA.** How much you agitate the problem before the offer depends on traffic temperature (cold needs more, warm goes straight to the offer). Full explanations with fresh examples and the awareness-stage note → `references/frameworks.md`.
+
+## Anti-patterns → fix
+
+| Rationalization | Reality / Fix |
+| --- | --- |
+| "A clever headline will stand out" | Clever is unclear. Name the outcome in <8 words; clear beats clever. |
+| "More features = more value shown" | Feature dumps bury the benefit. Lead with the outcome, then the mechanism. |
+| "Give them several CTAs to choose from" | Choice kills conversion. One primary action, repeated, not varied. |
+| "Any testimonials will do" | Generic raves don't persuade. 3–5 named quotes with a hard result, near the CTA. |
+| "World-class, cutting-edge, game-changing" | Hype words signal AI-template copy. Replace with a number or a named result. |
+| "The page can say its own thing" | If the headline ignores the ad's promise, you lose the message-match lift. Echo the click. |
+| "Promise them a 12% conversion rate" | Never promise a flat number. Quote the band for their vertical. |
+| "I'll invent a plausible metric" | Never. Mark `[[NEEDS PROOF]]` and ask the user. |
+
+## Page skeleton + worked example
+
+The annotated top-to-bottom skeleton (hook → problem → offer → proof → CTA → objections/FAQ → final CTA), with one fully worked B2B SaaS example and the variable slots marked, lives in `references/page-skeleton.md`. Start there when you write a full page rather than a single block.
+
+## Verify your copy
+
+Run `scripts/verify.sh` over the file you wrote (or your project) before claiming done. It is a read-only, dependency-free static check: H1 length, exactly one primary CTA verb (flags competing asks), presence of a proof block and a benefit subhead, a banlist of hype/AI-tell phrases, and a "Submit" warning. It warns on soft issues and exits non-zero only on hard ones (no CTA, no proof). It is a backstop, not the judgement — the four-block table is.
+
+## See also
+
+- `../design/SKILL.md` — the pixels: layout, hierarchy, the visual system the words sit in.
+- `../nextjs/SKILL.md` — the build: rendering the page in code.
+- `../marketing/SKILL.md` — the broader campaign: email sequences, channels, launch arc.
+- `ads` — the paid ad copy that drives the click (route here; you only match the page to it).
+- `ab-testing` — the experiment that proves which headline/CTA wins.
+- `case-studies` · `brand-voice` · `seo-geo` — the proof asset, the voice rules, the search layer.
+- References: `references/frameworks.md`, `references/page-skeleton.md`.

package/skills/landing-copy/evals/README.md

@@ -0,0 +1,18 @@
+# Eval harness — `landing-copy` skill
+
+These cases are read and run by the catalog's agent harness (a Claude Code agent
+with the full skill catalog loaded for routing) plus a human spot-check — there
+is no bundled shell runner, because both triggering and copy quality are
+judgement calls. `scripts/verify.sh` is a separate, narrower static linter for a
+*generated copy file*, not a runner for these cases.
+
+`should_trigger` asserts that the description + body would make a router load
+`landing-copy` for that prompt (run each cold, 3–5 trials, score the fraction
+that load the skill). `should_not_trigger` asserts a near-miss routes to the
+named real sibling instead (`ads`, `design`, `nextjs`, `ab-testing`,
+`brand-voice`) — these are the known traps: a "landing page" prompt that is
+actually the ad, the pixels, the build, or the experiment. `capability` is a
+rubric-scored generation: run the scenario with and without the skill loaded and
+grade each output against `must_include` (one point per item); the skill passes
+if WITH covers >= 80% and clearly beats WITHOUT. Report raw fractions, not a
+rounded pass, and re-run after any edit to `SKILL.md` or the references.

package/skills/landing-copy/evals/cases.yaml

@@ -0,0 +1,63 @@
+skill: landing-copy
+
+# Prompts that MUST load `landing-copy`. The skill owns the WORDS that convert on
+# one page: hook (hero H1 + subhead), offer (feature->benefit), proof
+# (result-bearing testimonials near the ask), and one primary CTA. It does NOT
+# own the ad (ads), the layout (design), the build (nextjs), or the experiment
+# (ab-testing).
+should_trigger:
+  - prompt: "Write the hero headline and subhead for our project-management SaaS landing page."
+    why: "Hero H1 + benefit subhead is the core hook block — the highest-leverage copy the skill owns."
+
+  - prompt: "We get plenty of traffic but almost nobody clicks the signup button — fix the page copy."
+    why: "Non-obvious: a symptom, not a keyword. 'Traffic but no conversion' with the fix scoped to copy (not layout) is exactly the page-rescue case; routes to copy diagnosis, not design or ab-testing."
+
+  - prompt: "Turn these five product features into benefit-led copy with one CTA."
+    why: "Feature->benefit transform (FAB) plus a single primary CTA are two named jobs of the offer and CTA blocks."
+
+  - prompt: "Escríbeme el copy de la landing para nuestro curso, con titular, oferta, prueba social y CTA."
+    why: "Spanish phrasing naming all four blocks (titular/oferta/prueba social/CTA) — the full single-page copy job."
+
+  - prompt: "Make the landing page headline match the Google ad that sends people there."
+    why: "Message match — aligning the page H1 to the ad's promise is owned here; note the skill matches the page copy, it does NOT write the ad (that is ads)."
+
+  - prompt: "Our testimonials are a wall of generic 'great product' quotes — rewrite them so they actually convert next to the signup."
+    why: "Non-obvious: proof block. Specific-beats-superlative result-bearing testimonials placed adjacent to the CTA is the proof job."
+
+# NEAR-MISS prompts that must NOT load `landing-copy`. Each routes to the real
+# sibling that owns it. The recurring trap: anything that touches a 'landing
+# page' but is actually the ad, the pixels, the build, or the experiment.
+should_not_trigger:
+  - prompt: "Write the Google Ads and Meta ad copy that drives traffic to our landing page."
+    route_to: ads
+    why: "Writing the paid ad that creates the click is ads; landing-copy only matches the page to whatever ad already exists."
+
+  - prompt: "Design the layout, type scale, and visual hierarchy of the hero section."
+    route_to: design
+    why: "Layout/hierarchy/spacing is the pixels — design owns the visual container; landing-copy only owns the words inside it."
+
+  - prompt: "Build this landing page as a Next.js component with the signup form wired up."
+    route_to: nextjs
+    why: "Implementing the page in code — components, form wiring, routing — is the build, owned by nextjs (or react)."
+
+  - prompt: "Set up an A/B test to find which of our two headline variants converts best."
+    route_to: ab-testing
+    why: "Designing and running the experiment that picks the winning variant is ab-testing; landing-copy writes the variants, it does not run the test."
+
+  - prompt: "Define our brand's tone of voice, lexicon, and do/don't word list."
+    route_to: brand-voice
+    why: "The reusable voice rules and word lists are brand-voice; landing-copy consumes that voice on one page, it does not author it."
+
+# CAPABILITY: prove the skill changes the output, not just routing.
+capability:
+  - scenario: "Write the full hero + offer + proof + CTA copy for a B2B SaaS that automates expense reports. Traffic comes from a Google ad reading 'Cut expense-report time 80%'."
+    must_include:
+      - "H1 is under ~8 words / ~44 chars and is clear, not clever (names the outcome)."
+      - "Subhead carries the benefit and names who it is for."
+      - "Headline echoes the ad's '80%' promise (message match), not a disconnected claim."
+      - "Offer lines are feature->benefit (FAB), benefit on top with the mechanism beneath — not a bare feature list."
+      - "3-5 specific, named testimonials each with a concrete numeric result, placed adjacent to the CTA."
+      - "Exactly one primary CTA with a movement verb (e.g. 'Start my free trial'), repeated unchanged — no competing asks, no 'Submit'."
+      - "No banned superlatives ('world-class', 'cutting-edge', 'game-changer', 'revolutionize', 'seamlessly')."
+      - "Conversion expectation, if mentioned, is given as a per-vertical band (SaaS ~3.8%), never a flat promised number."
+      - "Any proof that is not real is marked [[NEEDS PROOF]], not fabricated."

package/skills/landing-copy/references/frameworks.md

@@ -0,0 +1,61 @@
+# Copy frameworks as scaffolds
+
+Frameworks are skeletons you fill with the **buyer's own words** — never fill-in
+templates you ship as-is. Pick one for the page's spine and one (FAB) for the
+offer block. Each example below is fresh; mine the structure, not the wording.
+
+## PAS — Problem, Agitate, Solution
+
+Best for **pain-aware** traffic that already feels the problem.
+
+- **Problem** — name the pain in the reader's language. "Closing the books takes you nine days every month."
+- **Agitate** — make the cost vivid, briefly. "Nine days your team isn't forecasting, isn't planning — just chasing receipts."
+- **Solution** — present the offer as the relief. "Lumen closes in two. Snap, submit, done."
+
+Don't over-agitate warm traffic; it reads as manipulation. Agitation length scales with how cold the visitor is (see awareness note below).
+
+## AIDA — Attention, Interest, Desire, Action
+
+Broad **top-of-funnel** traffic that may not yet know the category.
+
+- **Attention** — the hook headline stops the scroll.
+- **Interest** — the subhead and first section make it relevant ("for finance teams of 20–200").
+- **Desire** — the offer + proof make them want the outcome (the result-bearing testimonial).
+- **Action** — the single CTA, repeated.
+
+## BAB — Before, After, Bridge
+
+Strong for **transformation** stories and pages built around a customer journey.
+
+- **Before** — the world today: "Month-end was three late nights and a spreadsheet you didn't trust."
+- **After** — the world with the product: "Now it's a Tuesday afternoon and the numbers reconcile themselves."
+- **Bridge** — the product is how you cross from one to the other: "Lumen is the bridge — connect your cards, set the rules once."
+
+## FAB — Feature, Advantage, Benefit (the offer block)
+
+This is the feature→benefit transform. Climb the ladder, then **stop at the benefit** the reader cares about and use the feature/mechanism as the proof underneath.
+
+- **Feature** — what it has: "AES-256 encryption."
+- **Advantage** — what that does: "data is unreadable if intercepted."
+- **Benefit** — what the buyer gets: "your security team signs off in days, not months."
+
+Write the benefit as the line; keep the feature as the evidence beneath it.
+
+```text
+Bad  — "Includes SSO, SCIM provisioning, and audit logs."
+Good — "Onboard a new hire in one click and prove who touched what in an audit —
+         SSO, SCIM, and full audit logs handle the rest."
+```
+
+## Awareness stage changes how much you agitate
+
+How much problem-agitation you do **before** the offer depends on traffic temperature:
+
+| Traffic | Awareness | Copy move |
+| --- | --- | --- |
+| Cold (broad ad, first touch) | Problem-unaware / problem-aware | Lead with the problem, agitate, *then* offer (PAS/AIDA). They need to feel the pain first. |
+| Warm (retargeting, email list, referral) | Solution-aware / product-aware | Go straight to the offer and proof. Re-agitating insults them and adds friction. |
+| Hot (pricing page, "buy" intent) | Most aware | Minimal copy: offer, proof, CTA. Remove everything between them and the button. |
+
+Match the framework to where the visitor is, not to a habit. A retargeting page that
+re-explains the problem the visitor already knows loses them to impatience.

package/skills/landing-copy/references/page-skeleton.md

@@ -0,0 +1,92 @@
+# Page skeleton + worked example
+
+The top-to-bottom skeleton of a conversion page. Each block has one job (see the
+four-block table in `SKILL.md`). Variable slots are marked `{{like_this}}` — fill
+them with the buyer's real words and *real* proof. Cut any block that has no job
+for this product; do not pad.
+
+## The skeleton
+
+```text
+1. HOOK (above the fold)
+   H1:       {{outcome in <8 words / ~44 chars}}
+   Subhead:  For {{who}}, {{benefit}} — {{how, one clause}}.
+   CTA:      [{{movement verb + value}}]    e.g. [Start my free trial]
+   Microcopy: {{friction reducer}}          e.g. No credit card required
+   (Message match: the H1 echoes the ad/email that drove the click.)
+
+2. PROBLEM  (skip or shorten for warm/hot traffic — see frameworks.md)
+   Name the pain in the reader's words: "{{the friction they live with today}}."
+   One line of agitation if traffic is cold. No more.
+
+3. OFFER
+   What they get: {{the thing}}.
+   Benefit-led feature lines (FAB — benefit on top, mechanism beneath):
+     - {{benefit}}, because {{feature/mechanism}}.
+     - {{benefit}}, because {{feature/mechanism}}.
+     - {{benefit}}, because {{feature/mechanism}}.
+   Cost/effort: {{price or "free to start" or "5-minute setup"}}.
+
+4. PROOF  (place adjacent to the CTA below it)
+   3–5 named testimonials, each with a concrete result:
+     "{{result, with a number}}" — {{Name, Role, Company}}
+   Plus: {{metric}} · {{recognizable logos}} · {{risk reversal / guarantee}}.
+
+5. CTA (repeated — same verb as the hero, not a new one)
+   [{{same movement verb + value}}]
+   Microcopy: {{same friction reducer}}
+
+6. OBJECTIONS / FAQ
+   Pre-empt the top 3–5 reasons not to act, each as a question → direct answer.
+   "Do I need a card?" "What if it doesn't work for my team?" "How long is setup?"
+
+7. FINAL CTA
+   [{{same movement verb + value}}]   — last chance, same single action.
+```
+
+## Worked example — B2B SaaS (expense automation)
+
+Traffic source: a Google ad reading **"Cut expense-report time 80%"**. The hero
+must echo that promise (message match).
+
+```text
+1. HOOK
+   H1:        Expense reports done in 30 seconds
+   Subhead:   For finance teams of 20–200 drowning in receipts — snap a photo,
+              we file and route it for approval automatically.
+   CTA:       [Start my free trial]
+   Microcopy: No credit card. 5-minute setup.
+
+2. PROBLEM
+   Month-end means chasing 40 people for crumpled receipts and reconciling a
+   spreadsheet you don't fully trust. It eats the days you should spend forecasting.
+
+3. OFFER
+   Lumen turns every receipt into a filed, categorized, approval-ready report.
+     - Close the month in 2 days instead of 9, because rules auto-categorize every line.
+     - Catch policy breaches before they post, because checks run at submit time.
+     - Audit-ready in one export, because every approval is logged automatically.
+   Free for your first 50 reports. $8 / active user / month after.
+
+4. PROOF  (sits right above the CTA)
+   "We cut expense-report time 82% in the first month — month-end went from three
+    late nights to a Tuesday afternoon." — Maria Ortiz, CFO, Lumen (47-person team)
+   "Closed our books in 2 days for the first time ever." — Daniel Roca, Controller, Vora
+   Trusted by 1,200 finance teams · SOC 2 Type II · 30-day money-back guarantee
+
+5. CTA
+   [Start my free trial]    No credit card. 5-minute setup.
+
+6. FAQ
+   Q: Do I need a credit card to start? A: No — the first 50 reports are free.
+   Q: Will it work with my accounting tool? A: Syncs with QuickBooks, Xero, NetSuite.
+   Q: How long is setup? A: Five minutes — connect your cards, set rules once.
+
+7. FINAL CTA
+   [Start my free trial]
+```
+
+Note what carries the weight: the H1 echoes the ad ("80%" → "30 seconds / 82%"),
+the offer lines are benefits-with-mechanism (FAB), the proof is named and numeric
+and sits next to the ask, and the **one** CTA verb ("Start my free trial") repeats
+unchanged. No "world-class", no second competing button, no promised conversion rate.

package/skills/landing-copy/scripts/verify.sh

@@ -0,0 +1,164 @@
+#!/usr/bin/env bash
+#
+# verify.sh — static copy linter for the `landing-copy` skill.
+#
+# WHAT IT DOES (read-only; never edits a file)
+#   Network-free static checks over a generated landing-copy file (or a tree):
+#     1. HARD  no CTA at all (no button-style line, no movement-verb call to act).
+#     2. HARD  no proof block (no testimonial/quote marker and no metric).
+#     3. SOFT  H1 over ~8 words or ~60 chars (warn — clarity beats clever).
+#     4. SOFT  competing CTAs — more than one distinct primary action verb used
+#              as a button-style line (decision fatigue).
+#     5. SOFT  no benefit-led subhead detected under the headline.
+#     6. SOFT  banlist hype / AI-tell phrases (world-class, cutting-edge,
+#              revolutionize, game-changer, seamlessly, unlock the power,
+#              "in today's fast-paced world").
+#     7. SOFT  "Submit" as button copy (prefer a movement verb).
+#
+#   Hard violations exit 1. Soft violations warn and exit 0 (copy is judgement).
+#   An empty or clean target is a clean pass (exit 0) — no false failure.
+#
+# HOW TO RUN (point it at YOUR copy, not the skills repo)
+#   ./verify.sh path/to/landing.md     # check one file
+#   ./verify.sh                        # scan ./ for *.{md,mdx,txt,html,tsx,jsx}
+#   ./verify.sh --path src             # scan a subdirectory
+#   ./verify.sh --strict               # treat soft warnings as failure (exit 1)
+#
+# EXIT CODES
+#   0  clean, empty target, or warnings-only without --strict
+#   1  a hard violation, or --strict with any warning
+#   2  bad usage
+#
+# POSIX sh, no external deps beyond grep/wc. Runs on stock macOS /bin/sh.
+
+set -eu
+
+if [ -t 1 ]; then
+  RED=$(printf '\033[31m'); GRN=$(printf '\033[32m'); YEL=$(printf '\033[33m'); NC=$(printf '\033[0m')
+else
+  RED=''; GRN=''; YEL=''; NC=''
+fi
+
+warn_count=0
+fail_count=0
+
+ok()   { printf '%s[ ok ]%s %s\n'  "$GRN" "$NC" "$*"; }
+warn() { printf '%s[warn]%s %s\n'  "$YEL" "$NC" "$*"; warn_count=$((warn_count + 1)); }
+fail() { printf '%s[fail]%s %s\n'  "$RED" "$NC" "$*"; fail_count=$((fail_count + 1)); }
+
+usage() { sed -n '2,33p' "$0" | sed 's/^#\{0,1\} \{0,1\}//'; }
+
+TARGET=""
+STRICT=0
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --strict) STRICT=1 ;;
+    --path) shift; TARGET="${1:-}" ;;
+    -h|--help) usage; exit 0 ;;
+    -*) printf 'unknown option: %s\n' "$1" >&2; usage >&2; exit 2 ;;
+    *) TARGET="$1" ;;
+  esac
+  shift
+done
+[ -n "$TARGET" ] || TARGET="."
+
+# --- collect files ----------------------------------------------------------
+FILES=""
+if [ -f "$TARGET" ]; then
+  FILES="$TARGET"
+elif [ -d "$TARGET" ]; then
+  FILES=$(find "$TARGET" -type f \
+    \( -name '*.md' -o -name '*.mdx' -o -name '*.txt' \
+       -o -name '*.html' -o -name '*.tsx' -o -name '*.jsx' \) 2>/dev/null \
+    | grep -v '/node_modules/' || true)
+else
+  printf 'no such file or directory: %s\n' "$TARGET" >&2
+  exit 2
+fi
+
+if [ -z "$FILES" ]; then
+  ok "no copy files found under '$TARGET' — nothing to check"
+  exit 0
+fi
+
+# movement verbs that mark a real CTA (case-insensitive)
+CTA_VERBS='start|get|see|book|claim|try|join|download|create|build|grab|reserve|unlock my|request|schedule|sign up|buy'
+
+# banlist of hype / AI-tell phrases
+BANLIST='world-class|cutting-edge|revolutioni[sz]e|game-changer|game changer|seamlessly|unlock the power|in today.?s fast-paced world|next-level|best-in-class'
+
+checked=0
+for f in $FILES; do
+  [ -f "$f" ] || continue
+  [ -s "$f" ] || continue
+  checked=$((checked + 1))
+
+  # 1. HARD: CTA present? look for a movement verb on a short line (button-style)
+  #    or any markdown/HTML button-like construct.
+  if grep -Eiq "$CTA_VERBS" "$f" || grep -Eiq '<button|\[[^]]+\]\(|role="button"' "$f"; then
+    :
+  else
+    fail "$f: no CTA found (no movement verb, no button) — a page needs one primary action"
+  fi
+
+  # 2. HARD: proof present? a quote/testimonial marker OR a number/metric.
+  if grep -Eq '"|“|”|>|—|--|testimonial|trusted by|review' "$f" \
+     || grep -Eq '[0-9]+%|[0-9]+x|\$[0-9]|[0-9][0-9,]+ (customers|teams|users)' "$f"; then
+    :
+  else
+    fail "$f: no proof block found (no testimonial/quote and no metric) — belief is built next to the ask"
+  fi
+
+  # 3. SOFT: H1 length. First markdown '# ' heading or first non-empty line.
+  h1=$(grep -m1 -E '^#[^#]' "$f" 2>/dev/null | sed 's/^#\{1,6\} *//' || true)
+  [ -n "$h1" ] || h1=$(grep -m1 -E '.' "$f" 2>/dev/null || true)
+  if [ -n "$h1" ]; then
+    words=$(printf '%s' "$h1" | wc -w | tr -d ' ')
+    chars=$(printf '%s' "$h1" | wc -m | tr -d ' ')
+    if [ "$words" -gt 8 ] || [ "$chars" -gt 60 ]; then
+      warn "$f: headline is ${words} words / ${chars} chars (aim <=8 words / ~44-60 chars; clear beats clever)"
+    fi
+  fi
+
+  # 4. SOFT: competing CTAs — count DISTINCT movement-verb button-style lines.
+  #    a short line (<=6 words) that starts with a CTA verb counts as a button.
+  distinct=$(grep -Eio "$CTA_VERBS" "$f" 2>/dev/null \
+    | tr 'A-Z' 'a-z' | sort -u | wc -l | tr -d ' ')
+  if [ "${distinct:-0}" -gt 1 ]; then
+    warn "$f: ${distinct} distinct CTA verbs detected — use ONE primary action, repeated (decision fatigue)"
+  fi
+
+  # 5. SOFT: benefit-led subhead. Heuristic: a line near the top that frames an
+  #    outcome ("so ", "for ", "without ", "in <n> ") under the headline.
+  if grep -Eiq '(^|[^a-z])(so |so you|for [a-z]|without |in [0-9])' "$f"; then
+    :
+  else
+    warn "$f: no benefit-led subhead detected — the subhead should carry the outcome (who + benefit)"
+  fi
+
+  # 6. SOFT: banlist hits.
+  hits=$(grep -Eio "$BANLIST" "$f" 2>/dev/null | sort -u || true)
+  if [ -n "$hits" ]; then
+    for h in $hits; do
+      warn "$f: hype/AI-tell phrase '$h' — replace with a number or a named result"
+    done
+  fi
+
+  # 7. SOFT: "Submit" as button copy.
+  if grep -Eiq '(^|[^a-z])submit([^a-z]|$)' "$f"; then
+    warn "$f: 'Submit' as button copy — use a movement verb that states the value (e.g. 'Start my free trial')"
+  fi
+done
+
+printf '\n'
+if [ "$fail_count" -gt 0 ]; then
+  fail "$fail_count hard violation(s), $warn_count warning(s) across $checked file(s)"
+  exit 1
+fi
+if [ "$warn_count" -gt 0 ]; then
+  warn "$warn_count warning(s) across $checked file(s)"
+  [ "$STRICT" -eq 1 ] && { printf '%s--strict: treating warnings as failure%s\n' "$RED" "$NC"; exit 1; }
+  exit 0
+fi
+ok "clean — $checked file(s) checked, no violations"
+exit 0