Landing Page
A landing page is an argument with a URL. /direct-response-copy owns the words;
this skill owns everything that happens to them on the way to a visitor: section
architecture, the build, the ship. "Done" is a page that renders the approved copy
verbatim, survives the 5-second test on a phone, and is one command from live. This is
the floor, not the ceiling. When the situation argues for a better path, take it and
say why.
Context
Only if ./brand/, ./brands/ or MARKETING.md exists (nothing to load otherwise), run:
python3 ${CLAUDE_SKILL_DIR}/../start-here/scripts/brand_context.py --for landing-page
(${CLAUDE_SKILL_DIR} is this skill's folder; outside Claude Code use the folder this
file was read from, e.g. .agents/skills/landing-page. If the script or python3 is
unavailable, read the brand folder directly: ./brands/<slug>/ when ./brands/active
names one, else ./brand/; then MARKETING.md, preferences.md and the files in
reads:. If none exist, proceed standalone and ask only for the offer, where
the traffic comes from, and whether approved copy exists.)
If learnings.md holds relevant priors (which sections converted, form-length results,
past teardown outcomes), apply them. One line in the Sources and assumptions note, only
when a prior changed the page.
Teardown scraping uses the web-scrape capability, free either way; no spend gate applies. WebFetch reads the page as a summary. We use Firecrawl to read the real rendered page (JavaScript included) as clean text, with a free tier of 1,000 credits a month and no card. Without it, the note says the teardown worked from a summary.
Modes
| Situation | Mode | Path |
|---|---|---|
| No copy exists yet (default) | FULL BUILD | Copy phase via /direct-response-copy's method → Architecture → Build → Ship |
| Approved, scored copy exists | BUILD FROM COPY | Architecture → Build → Ship |
| A live page isn't converting | TEARDOWN | Scrape → section-by-section score → prioritized rewrite plan |
FULL BUILD copy phase: load ${CLAUDE_SKILL_DIR}/../direct-response-copy/SKILL.md
(If that sibling skill isn't installed, score without anchors and say so in one line in
the note.) and execute its method: Phase 0 VoC mining through the 7-dimension score loop.
Its scoring rules apply unchanged, run silently: build from copy that passes, never ship
below-threshold copy, and show the client the passing copy, not the scores.
If the Architecture phase below then cuts or reorders sections, update the copy file to
match before building. The copy file stays the single source the build diffs against.
Local service business? (plumber, roofer, dentist, med spa, cleaner, auto shop: the goal is a call, an estimate visit or a booking.) Run LOCAL OFFERS below before Architecture. It picks the page type and adds the phone first-screen checklist. Every other business skips it.
Iteration detection: if ./campaigns/{name}/page/ already exists, read it before
touching anything and ask: revise the page, add a variant, or rebuild. Never silently
overwrite a shipped page: copy the old one to page/.prev/ first.
ARCHITECTURE: the page earns its sections
Copy answers "what do we say." Architecture answers "what does this visitor need to
see, in what order, before they'll act". Different for every traffic source. Write
the decisions to ./campaigns/{name}/architecture.md before building: page job, each
section's one job, friction budget, and what got cut and why.
Offer type × awareness picks the sections
Name the page job first. A section list copied from "what landing pages have" is how cold-traffic pages end up with a nav full of exits and waitlist pages end up with testimonials nobody has given yet.
| Page job | Traffic reality | Keep | Cut |
|---|---|---|---|
| Cold-traffic offer (paid/social, awareness 1-3) | They didn't ask to be here; the page must make the whole argument | Pain-led hero, problem, mechanism, proof, offer, objection FAQ, closing CTA | The nav (every link is an exit), footer link farms |
| Warm-list page (email/newsletter clicks, awareness 4-5) | Trust transferred from the sender; they arrive pre-sold on the problem | Offer-led hero, what-you-get, proof, FAQ, CTA | Problem education and mechanism: re-explaining what they already believe reads as padding |
| Waitlist / pre-launch | No product proof exists yet | Vision-led hero, why-this-will-work mechanism, founder story, single-field CTA | Testimonials (never fabricate), pricing, long FAQ |
| Lead-magnet opt-in | A value exchange, not a sale; the goal is one screen | Hero + what's-inside bullets + one field | Almost everything else: every added section delays the trade |
| High-ticket / book-a-call | Qualifying matters more than volume | Hero, heavy proof, disqualification ("not for you if…"), calendar CTA | Impulse mechanics: countdowns and discount banners cheapen a considered purchase |
| Local service page (search, map or ad clicks to a plumber, dentist, roofer) | Comparing three businesses on a phone, often with a problem right now | Promise headline, tap-to-call, one proof line, what we fix, real pricing, recent reviews, service area | Nav exits, sliders, stock photos, long forms. Pick call, quote or booking in LOCAL OFFERS |
Awareness level comes from the copy brief (direct-response-copy Phase 1 already established it). When traffic sources mix, architect for the coldest segment you're paying for: warm visitors skim past education; cold visitors can't skip what isn't there.
The proven default stack (cold-traffic offer pages)
The battle-tested skeleton for a paid/cold conversion page. Start here, then apply the keep/cut table above. Every section states its one job, which is also its deletion test:
| # | Section | Anatomy | Job |
|---|---|---|---|
| 1 | Hero | Eyebrow → Headline → Subheadline → CTA → Trust signals | Get email or get scroll |
| 2 | Success (conditional: post-conversion state) | Checkmark → Confirmation → Deliverable list | Kill buyer's remorse |
| 3 | Problem-Agitate | 3 problems with agitation → personal transition | Make status quo painful |
| 4 | Value Stack | 4 tiers descending → total value → your price | Make saying no feel stupid |
| 5 | Social Proof | Header → 3 testimonials with specific results | Let others convince them |
| 6 | Transformation | 4 stages: quick win → compound → advantage → 10x | Make outcome tangible |
| 7 | Secondary CTA | Avatar stack → question headline → "Yes" button | Catch the scrollers |
| 8 | Footer | Logo → nav → legal → social (lean: legitimacy, not a link farm) | Professional legitimacy |
Three details that get lost when people copy this shape: the Success section is the same page in its converted state (swap it in after submit; the deliverable list kills remorse, and the visitor already converted); the Transformation ladder is time-sequenced, not a feature list: each stage answers "then what?" until the outcome feels inevitable; and the Secondary CTA reframes as a question ("Ready to X?"): by that scroll depth they've heard the pitch, so asking beats repeating.
One job per section
Each section answers exactly one visitor question, in the order a skeptic would ask: what is this → is it for me → does it actually work → what's the catch → what now. A section doing two jobs does neither. The deletion test: if removing a section doesn't break the argument chain, remove it. Pages fail from accumulation more than omission.
Message hierarchy: the 5-second test
Most visitors never scroll, so headline + subhead + CTA must carry the entire argument: what it is, who it's for, what to do next. If a stranger shown only the above-the-fold for five seconds can't answer all three, the page is broken no matter how good section four is. Everything below the fold exists for the minority who need more convincing: it supports the argument, it is not the argument.
The same hierarchy repeats inside sections: a scanner reading only headings and bolded lines should get a coherent (if compressed) version of the pitch. Write the heading skeleton, read it alone, and check it still sells.
Promise match: the first screen repeats the ad
When the page takes ad traffic, the visitor arrives carrying one phrase from the ad and scans for it. The headline, or the line directly under it, repeats the ad's promise word for word, on the first screen at phone width. "Free for teams under 10" in the ad means "Free for teams under 10" in the hero, not "Affordable plans for growing teams". "Same-day water heater replacement" means those words, not "Fast, reliable service". A paraphrase reads as a different offer, and the visitor goes back to the results with the click already paid for.
Default: one page (or one variant headline) per distinct ad promise. When three ad
groups promise three different things and all land on one page, the page matches none of
them. Write the ad's exact text into architecture.md next to the headline so the SHIP
diff can check it. If the business can't keep the promise (nobody answers at 2am, the
free tier has a catch), fix the ad, not the page.
How often this breaks, from local service sites checked on a phone: most businesses running ads that promise 24/7 or same-day service don't say it on the first screen of the page the ad opens, and many never say it anywhere on that page (self-selected sample, Nov 2026).
Proof placement
Proof belongs adjacent to the claim it supports, not quarantined in a testimonial section visitors skip. The mapping: a results claim gets the data point or case study beside it; the price gets the testimonial that mentions value; the CTA gets the risk reversal and the "join N others" line (real N only); a bold mechanism claim gets its source linked inline. The single strongest proof element on the page belongs near the first CTA: that's where doubt peaks. A logo wall earns its place only when the names are recognizable to this audience; six unknown logos read as filler.
Friction audit
Every field, click, and decision costs conversion: extra form fields commonly cost double-digit relative drops (illustrative; the direction is reliable, the magnitude is yours to measure). Budget friction deliberately:
- Fields: only what the next step strictly requires. A magnet needs an email. A sales call may genuinely need company size for routing: "may genuinely need" is the test, not "would be nice to have in the CRM."
- Steps: click → form → confirm is three exits. Collapse where possible; put the form on the page rather than behind a button when the page job is opt-in.
- Decisions: one primary CTA, repeated, not three different offers competing. Secondary links (docs, pricing detail) only when the page job is considered-purchase.
- Exits: nav and footer links are exits. Cold-traffic pages get a logo and a CTA, not a menu.
Count the friction in architecture.md (fields, steps, exit links) so the teardown of
your own page later has a baseline.
Mobile-first reality
Most paid traffic opens this page on a phone. Architect at 375px first: a headline that wraps to five lines isn't a headline, a sticky header eats a third of the viewport, and the form must be thumb-reachable without zoom. Desktop is the enhancement pass. The build reference enforces this in code; architecture enforces it in section count: a page that's "complete" on desktop and exhausting on mobile has too many sections.
LOCAL OFFERS: call, quote or booking (local service businesses only)
A local service page has one of three jobs, and picking the wrong one is the local
version of the wrong page job for the traffic. Load references/local-pages.md for the
section stack, the thank-you page and a worked example.
Pick the page by the job's urgency and size, then adjust for the traffic:
| The customer's situation | Page | Primary action | Second path |
|---|---|---|---|
| Something is broken now (burst pipe, no heat, locked out, toothache) | Call-first page | Tap to call | Short form ("text me back") for those who can't talk |
| A routine, known-price job (drain cleaning, tune-up, cleaning, oil change, hygiene visit) | Booking page (zip or address first, then a time slot) | Book a time | Call |
| A big, considered job (water heater or HVAC replacement, roof, remodel, implants) | Quote page (free estimate or inspection visit) | Request the estimate | Call |
The logic underneath, from direct-response funnel practice: the size of the decision sets the mechanism (a few hundred dollars books on a page; thousands need a conversation, so the page's job is to get the estimate visit, not to sell the job), the traffic sets the front end, and awareness sets the first page's job.
- Traffic adjusts the page. Search and map traffic is already looking for the service and can land on any of the three. Social ads reach people who weren't looking, so they need a reason first: an offer (a seasonal tune-up price, a free roof inspection) or a short "what will this cost me" quiz that ends at the quote form.
- Awareness sets the headline's job. "Water heater leaking" is a problem search: name the problem and say you fix it today. "Water heater replacement cost" is a price search: show real price ranges and book the estimate. "Plumber near me" is ready to call: the number and the proof, nothing else in the way.
- One primary action, one quieter second path. This deviates from the one-action rule on purpose: local visitors split between people who can talk now and people at work who can't. The second path is a smaller button or a text link, never a competing offer.
- What the next page assumes. After a form, the visitor assumes someone will get back
to them and is probably still comparing. The thank-you page says when they'll hear back
("within 15 minutes, 7am to 7pm"), shows the number to call now, and stops. A form
answered an hour later has often already called someone else;
/speed-to-leadsets up the follow-up.
The local first-screen checklist (check in a 390px phone screenshot before shipping;
/first-screen-check runs the full version on any live page):
- The ad's or search's promise, in the same words, in the headline or right under it.
- The service and the area in plain words ("Emergency Plumber in Dallas").
- The number visible and one tap to call, plus a call bar that stays on scroll.
- The strongest true proof in one line: star rating with review count and source, years, licensed and insured.
- The second path (booking or a short form) reachable from the first screen.
- A reason to call today: availability, response time or an offer that's real.
- Nothing covering it: no popup, chat bubble or offer bar over the number or headline.
- Fast on a phone: the hero image sized for phones, no background video.
BUILD
Load references/landing-page-build.md and follow it: it is the build standard.
What it produces, in brief:
- Single-file HTML by default (inline CSS, no framework, opens from
file://, deploys anywhere), or a Next.js page component when the project'spackage.jsonhas anextdependency, styled the way the project already styles things. - Copy mapped 1:1 onto the architecture's section plan, verbatim, never re-drafted during the build. A section that reads weak mid-build goes back through /direct-response-copy's gate; it doesn't get quietly rewritten in HTML.
- Design tokens from
./brand/creative-kit.mdwhen present; tasteful neutral defaults otherwise. - A/B variant routes when two approved copy variants exist:
?v=a|bwith localStorage-sticky assignment (HTML) or/a/bstatic routes (Next.js), plus marked// ANALYTICS:stubs showing exactly where to wire pageview and CTA-click events. The page emits no tracking until the user wires them. Say so. - Meta/OG tags and FAQ JSON-LD from the copy (its remaining value is LLM parseability, which serves the AI-reader layer the copy was written for).
SHIP
- Verify before handoff:
- Diff the rendered page text against the approved copy file: headline, subhead, price, CTA labels, friction reducers must match verbatim. Builds drift; the diff catches it. A mismatch is a build bug: fix the build, never the copy.
- Both variants render (
?v=a/?v=bor the/a/broutes). - The built hero passes the 5-second test at 375px width.
- Promise match: when the page takes ad traffic, the ad's promise from
architecture.mdappears word for word on the first screen. - Local pages: the local first-screen checklist passes in a phone screenshot.
- Section count, form fields, and exit links match
architecture.md's friction budget. Run these checks silently. Fix and recheck (about 2 passes usually settles it), show only the passing page, and put anything still off in one line in the note.
- Deploy (optional): if the Vercel CLI is available or the project is already Vercel-linked, offer a preview deploy (preview by default; production only on an explicit ask). Otherwise hand off hosting-agnostic: a single HTML file deploys to any static host unchanged.
- Handoff notes (the client uses these): the page path and how to open it, the
one-line retheme instruction (
:roottokens), where the two analytics stubs live, and the A/B sample-honesty rule: under ~1,000 visitors/week, only big-swing variants produce readable results.
TEARDOWN: score a live page
For "my page isn't converting" with a URL. This is the conversion-audit capability: the Architecture principles above are the rubric, applied to someone else's decisions.
- Scrape the page (web-scrape capability). Capture the full text in section order,
form fields, nav/footer links, CTAs and their labels, meta title/description. If
nothing can fetch it, ask for a paste and say plainly the audit covers copy and
structure but not rendering. Say which it was once, in plain words, in the note
("Read the live page on {date}" or "Worked from pasted copy"). Keep the captured
evidence in
notes.md. - Establish the page job. Ask where the traffic comes from if not stated: a "failing" page is often the wrong page job for its traffic, and that finding outranks every section-level fix. If you infer instead of asking, say so.
- Score, section by section:
- Above-the-fold 5-second test: what is it, who's it for, what do I do (can a stranger answer all three?)
- Promise match, when the page takes ad traffic: get the ad's text (the user, the ad account, or Google's Ads Transparency Center by advertiser name) and check the first screen for its exact words. A miss here ranks with a wrong headline.
- Local pages: the local first-screen checklist, on a phone screenshot when one can
be taken (or hand the live page to
/first-screen-check). - Per section: which job is it doing, is it one job, does it match the page job's keep/cut table, is the proof adjacent to its claim?
- Friction count: fields, steps, competing CTAs, exit links, against what the page job actually requires.
- Copy quality: load
${CLAUDE_SKILL_DIR}/../direct-response-copy/references/calibration-anchors.md(If that sibling skill isn't installed, score without anchors and say so in the note.) and score the page copy on that skill's 7 dimensions. Don't re-derive the rubric; it's theirs. The scores are a lens: report only the weak lines and what they should become, inside the ranked plan.
- Write the prioritized rewrite plan to
./campaigns/{name}/teardown.md, ranked by leverage, not by page order: message hierarchy first (a wrong headline caps every other fix), then section selection (cut/add/reorder), then proof placement, then friction, then copy-line polish. Each item: what to change, why (which principle), and what it should become. End by offering BUILD FROM COPY (or FULL BUILD if the copy itself scored badly) to execute the plan.
Output
./campaigns/{name}/
├── landing-page.md # approved copy (produced via /direct-response-copy's method)
├── architecture.md # page job, section plan, friction budget, cuts + reasons
├── page/ # index.html (or Next.js files) + variants
├── teardown.md # TEARDOWN mode: the ranked rewrite plan
└── notes.md # working file: what was captured, per-section evidence, check results
Files first, summary second, per ${CLAUDE_SKILL_DIR}/../start-here/references/output-format.md. Append one line per asset
to ./brand/assets.md.
What the client reads in chat. The header, then the work: for a built page, what shipped, how to open or deploy it, the retheme line and the analytics note; for a teardown, the ranked plan. Architecture, friction counts and diff results stay in the saved files. Then one Sources and assumptions note (10 lines max). Page copy runs about 800 to 1,500 words; a teardown plan about 1,200 to 2,500.
What's next (pick 2-4, tailored):
- After a shipped page →
/paid-adsto drive traffic to it (~15 min);/creativefor the hero and proof image placeholders the build marked (~15 min) - Once traffic flows →
/performance-reviewto read variant results and write them to learnings (that's what makes the next page smarter) - If the offer feels thin during architecture →
/lead-magnetto build the sweetener the opt-in needs (~20 min) - After a teardown → BUILD FROM COPY here to execute the rewrite plan
- Local pages:
/first-screen-checkon the live page once it ships (~10 min);/google-ads-trackingso the ads count the calls and forms it produces (~30 min);/speed-to-leadso form leads get a reply in minutes (~20 min)
When the user edits your work
Apply the edit, then make it stick: save a gold case to ./brand/gold/<this skill>/ and
one to three yes/no checks to ./brand/checks.md, and confirm in one line. Before handing
over any work, answer the checks the context block loaded, silently, and fix every no.
How: ${CLAUDE_SKILL_DIR}/../start-here/references/taste-loop.md.