Communitygithub.com

Offer-to-Landing Page

Turns an offer into a shipped landing page: section architecture by offer type and awareness, a first screen that repeats the ad promise, a single-file HTML or Next.js build with A/B routes, and a teardown that scores a live page into a rewrite plan. Local services get a call, quote, or booking path.

What is Offer-to-Landing Page?

A direct-response landing-page builder that ships a real page from an offer or approved copy, and audits a live page section by section when it is not converting.

Works with✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/boringmarketer/boring-marketing-skills/tree/HEAD/skills/landing-page

Ask in your favorite AI

Open a new chat with this agent skill pre-loaded.

Documentation

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

SituationModePath
No copy exists yet (default)FULL BUILDCopy phase via /direct-response-copy's method → Architecture → Build → Ship
Approved, scored copy existsBUILD FROM COPYArchitecture → Build → Ship
A live page isn't convertingTEARDOWNScrape → 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 jobTraffic realityKeepCut
Cold-traffic offer (paid/social, awareness 1-3)They didn't ask to be here; the page must make the whole argumentPain-led hero, problem, mechanism, proof, offer, objection FAQ, closing CTAThe 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 problemOffer-led hero, what-you-get, proof, FAQ, CTAProblem education and mechanism: re-explaining what they already believe reads as padding
Waitlist / pre-launchNo product proof exists yetVision-led hero, why-this-will-work mechanism, founder story, single-field CTATestimonials (never fabricate), pricing, long FAQ
Lead-magnet opt-inA value exchange, not a sale; the goal is one screenHero + what's-inside bullets + one fieldAlmost everything else: every added section delays the trade
High-ticket / book-a-callQualifying matters more than volumeHero, heavy proof, disqualification ("not for you if…"), calendar CTAImpulse 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 nowPromise headline, tap-to-call, one proof line, what we fix, real pricing, recent reviews, service areaNav 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:

#SectionAnatomyJob
1HeroEyebrow → Headline → Subheadline → CTA → Trust signalsGet email or get scroll
2Success (conditional: post-conversion state)Checkmark → Confirmation → Deliverable listKill buyer's remorse
3Problem-Agitate3 problems with agitation → personal transitionMake status quo painful
4Value Stack4 tiers descending → total value → your priceMake saying no feel stupid
5Social ProofHeader → 3 testimonials with specific resultsLet others convince them
6Transformation4 stages: quick win → compound → advantage → 10xMake outcome tangible
7Secondary CTAAvatar stack → question headline → "Yes" buttonCatch the scrollers
8FooterLogo → 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 situationPagePrimary actionSecond path
Something is broken now (burst pipe, no heat, locked out, toothache)Call-first pageTap to callShort 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 timeCall
A big, considered job (water heater or HVAC replacement, roof, remodel, implants)Quote page (free estimate or inspection visit)Request the estimateCall

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-lead sets 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):

  1. The ad's or search's promise, in the same words, in the headline or right under it.
  2. The service and the area in plain words ("Emergency Plumber in Dallas").
  3. The number visible and one tap to call, plus a call bar that stays on scroll.
  4. The strongest true proof in one line: star rating with review count and source, years, licensed and insured.
  5. The second path (booking or a short form) reachable from the first screen.
  6. A reason to call today: availability, response time or an offer that's real.
  7. Nothing covering it: no popup, chat bubble or offer bar over the number or headline.
  8. 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's package.json has a next dependency, 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.md when present; tasteful neutral defaults otherwise.
  • A/B variant routes when two approved copy variants exist: ?v=a|b with localStorage-sticky assignment (HTML) or /a /b static 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

  1. 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=b or the /a /b routes).
    • 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.md appears 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.
  2. 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.
  3. Handoff notes (the client uses these): the page path and how to open it, the one-line retheme instruction (:root tokens), 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.

  1. 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.
  2. 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.
  3. 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.
  4. 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-ads to drive traffic to it (~15 min); /creative for the hero and proof image placeholders the build marked (~15 min)
  • Once traffic flows → /performance-review to read variant results and write them to learnings (that's what makes the next page smarter)
  • If the offer feels thin during architecture → /lead-magnet to 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-check on the live page once it ships (~10 min); /google-ads-tracking so the ads count the calls and forms it produces (~30 min); /speed-to-lead so 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.

Related Skills