The best Claude skills for landing pages do the two things a template library can't: they audit the page you already have before you rebuild it, and they design the next variant from a real diagnosis rather than a taste call. This post picks the 8 free Claude Code skills a designer, marketer or founder should run on landing pages: leak finder, PDP reviewer, checkout auditor, page shipper, hook lab, variant router, hypothesis engine and the first-mile mapper. Every skill returns a defensible read against your own numbers.
Every landing page team runs into the same failure mode. A page is not converting well. Somebody picks the page that feels the most wrong, redesigns it, ships a test, watches the number come out flat, rotates to the next guess. Between the picking and the shipping, no diagnosis actually happens - the pattern is redesign-first, and it is expensive.
The real leverage is upstream of the CRO tool. Localizing where the funnel is actually leaking, auditing the surface at the field level, writing a hypothesis with a stopping rule before the test runs - these are the moves that separate a test result you can build on from a lift you talked yourself into. And they are exactly the moves that get compressed when the team is under pressure to "just ship something".
Claude Code skills fix that at the reasoning layer. A skill is a versioned SKILL.md file with a stated method - the inputs it asks for, the framework it applies, the output shape it returns. Two designers running the-leak-finder on the same funnel get the same red-yellow-green stage-by-stage read. Same skill, same shape, every run. That is what makes redesign-first stop being the default.
What is a Claude Code skill
A Claude Code skill is a versioned SKILL.md file that Claude Code reads from a local .claude/skills/ folder. For landing page work, the inputs are usually stage-by-stage funnel numbers, screenshots or a walkthrough of the current page, and your brand tokens. The output is a structured read - what to fix, in what order, and where the skill hits its ceiling.
For the primitive-layer explainer, see the hub: Claude Code skills: what they are and which ones earn their install. For the full CRO pack write-up, see 10 best Claude skills for CRO and A/B testing.
Why landing page teams need Claude skills now
Two shifts have made landing page work harder. First, the number of surfaces a customer touches before they convert has grown - a paid ad, a comparison page, a docs page, a webinar signup, a demo request page. Each is a real page, each rots on a different clock, and nobody has time to audit all of them. Second, generic AI copy tools have flooded the space with pages that read plausible but do not answer any real buyer objection - the same seven headlines rotating through every SaaS category.
The skills below answer three questions a page team keeps re-asking:
- Which stage of the funnel is losing people relative to benchmark, not just in absolute terms?
- On that stage, what specifically is wrong - fields, trust, proof, unanswered objections, or something else entirely?
- For the change we design, what has to hold true for the test to actually prove it worked?
Install the packs in about 30 seconds
The 8 skills below live across three packs. Install them with one command each, then restart Claude Code.
npx skills add sidchaudhary/gtm-skills/skills/experimentation-lead
npx skills add sidchaudhary/gtm-skills/skills/brand-designer
npx skills add sidchaudhary/gtm-skills/skills/performance-marketer
# Restart Claude Code, then confirm:
# "What landing page skills do you have available?"8 best Claude skills for landing page optimization
1. the-leak-finder - name the leaking stage before you touch a page
The first-install skill for every landing page team. Takes your stage-by-stage funnel numbers and compares them against benchmarks to name which stage is losing people relative to normal, flagged green, yellow or red. Diagnoses from there - deliberately refuses to suggest fixes before the diagnosis is done. If you skip it, everything downstream is aimed at a guess.
When to use: First. Before any surface audit, before any test design, before touching a single page.
How to run:
You: "Run the-leak-finder on our funnel."
[paste: stage-by-stage conversion from GA4]
Claude: -> each stage flagged green / yellow / red vs benchmark
-> the diagnosis for red stages (not just "it's low")
-> which auditor skill to run next
-> deliberately no fix suggestions before diagnosisBest used with: Real stage-by-stage numbers from GA4 or your analytics tool. "Conversion is bad" produces nothing useful; "session → PDP 42 percent, PDP → cart 18 percent" produces a diagnosis.
Where this skill hits its ceiling: Benchmarks are context-free. A red stage against a benchmark still needs your judgment on whether it matters for your business.
With Intempt: The Analyze agent runs stage-by-stage diagnosis continuously against live GA4 data, so leak detection is a running signal, not a one-time paste.
2. the-pdp-reviewer - audit the product page against the objections it never answers
Reads a product page along with its reviews and real buyer questions, then returns a prioritized edit brief - clarity gaps, trust gaps, proof gaps, unanswered objections. The trick is the input: it does not just review the copy, it cross-references what buyers keep asking against what the page never says. The gap is where the conversion loss lives.
When to use: When the-leak-finder flags session-to-cart as the red stage, or when a specific PDP has been underperforming and the fix list has been guesswork.
How to run:
You: "Run the-pdp-reviewer on this page."
[paste: page copy/screenshots + top reviews + buyer questions]
Claude: edit brief, prioritized
-> clarity gaps (what the page never says)
-> trust gaps (what it asks you to take on faith)
-> objection gaps (what reviews keep asking that the page ignores)
-> proof gaps (unsupported claims, or missing social proof)Best used with: The page copy, its top reviews, and any buyer question thread (Amazon Q&A, support tickets, live chat logs).
Where this skill hits its ceiling: Copy and structure. It does not judge product-market fit. If reviews are saying the product itself is wrong, that is a different conversation.
With Intempt: Objection gaps become briefs for the Brand Designer pack's hook and copy skills - real buyer language, not guessed positioning.
3. the-checkout-auditor - the friction list nobody has walked in months
Direct UX audit of a cart and checkout flow from screenshots or a walkthrough plus policy details. Names the friction: fields nobody needs, missing payment methods, absent trust signals, an extra step that could be one. Not a redesign - a friction list you can prioritize.
When to use: When the-leak-finder flags cart-to-purchase as the red stage, or when checkout abandonment has been high enough long enough that nobody has walked the flow step by step.
How to run:
You: "Run the-checkout-auditor on our flow."
[paste: screenshots or walkthrough + payment methods + policy details]
Claude: -> field-by-field friction call (needed / optional / drop)
-> payment method coverage gaps
-> trust signal presence (SSL, reviews, guarantee, address)
-> step count vs benchmark
-> prioritized fix list, ranked by expected impactBest used with: Real screenshots of the actual checkout, not a wireframe, and your real policy details.
Where this skill hits its ceiling: UX friction. If your issue is address-verification failures or payment routing declines, that is an ops problem, not a UX one.
With Intempt: Findings feed on-site experiments through the Sell agent, so the priority list becomes a test queue, not a Notion doc.
4. the-page-shipper - conversion-focused pages, this week not next month
Produces conversion-optimized landing pages as prototype-ready HTML and Tailwind, not a wireframe. Meant for when design and dev cycles are slowing campaign velocity and you need something live this week for a paid push or an experiment variant. Copy framework is matched to traffic source and awareness stage; section order, form length, proof placement are decided from the brief, not from a template.
When to use: When a campaign needs a page in days rather than weeks, or when you want a variant B for a test that is not just a copy tweak.
How to run:
You: "Run the-page-shipper for a demo-request landing page."
[context: audience, offer, proof points, brand tokens]
Claude: -> section-by-section layout with reasoning
-> copy per section, in brand voice
-> prototype-ready HTML + Tailwind classes
-> A/B testing hooks pre-wired (data attributes)
-> a note on what would defeat this pageBest used with: Real proof points and brand tokens. Without them the page reads like every other SaaS landing page, because the model's default is exactly that.
Where this skill hits its ceiling: Prototype-ready, not production-ready. Accessibility, performance and analytics integration are the dev team's pass.
With Intempt: Pages become tested surfaces inside campaigns with test hooks already wired for the Analyze agent.
5. the-hook-lab - the top 30 pixels, tested against real frameworks
Takes a landing page hero or a LinkedIn post draft and generates four scored hook variants for the opening line, each built on a distinct psychological framework, with a recommendation and the reason it wins. On a landing page, the top hero line is doing the same job as the see-more-cutoff line on LinkedIn - deciding whether the read continues.
When to use: When the hero is flat and rewriting it three times has produced three flat variants. Also before a paid ad push where the landing page hero has to match the ad's angle.
How to run:
You: "Run the-hook-lab on our landing page hero."
[paste: current hero + audience + offer]
Claude: -> 4 hook variants, each on a distinct framework
-> psychological framework named per variant
-> weighted score per variant
-> the recommendation with the reason
-> the framework we did NOT use (and why)Best used with: A real audience and a real offer. "Better hero" is not a brief.
Where this skill hits its ceiling: Top of the page, not the whole page. For section-by-section rewrites, run the-page-shipper.
With Intempt: Winning hooks feed the Marketing agent as anchor lines so downstream nurture inherits the angle.
6. the-variant-router - personalization with a measurement plan
Maps audience segments to content variants with a measurement plan. Stops the personalization pattern where every visitor sees the same generic page because nobody wrote down which segment gets which variant or how you would know it worked. Includes an anti-fragmentation check: do not build 12 variants for 3 audiences.
When to use: When content is reading generic to every audience and personalization rules are not tied to a measurable outcome.
How to run:
You: "Run the-variant-router for our homepage."
[context: audience segments, current variants, traffic split]
Claude: -> segment-to-variant mapping (who sees what, why)
-> measurement plan per segment (metric, threshold, timeframe)
-> fallback rule (what unmatched traffic sees)
-> anti-fragmentation checkBest used with: Real segment definitions from the-lifecycle-mapper, not personas.
Where this skill hits its ceiling: It designs the routing. Building the variants themselves is a copy job.
With Intempt: Variant routing runs against real segments in the Marketing agent with measurement attached to the campaign rather than a separate tracker.
7. the-hypothesis-engine - design the test with the stopping rule written down
The core A/B testing skill in the pack. Designs a test around a specific change: Bayesian design with Thompson sampling, a real sample-size calculation, guardrail metrics, and exit criteria written down before the test starts. A stopping rule decided in advance is what separates a landing page win you can build on from a number you talked yourself into.
When to use: After a diagnosis skill has named the change. Running it before the audit is designing a test for a guess.
How to run:
You: "Design a test for the new hero."
[context: baseline CR, weekly traffic, min effect worth detecting]
Claude: -> hypothesis, stated as a falsifiable claim
-> sample size per variant
-> how long that takes at your traffic
-> guardrails (what must NOT get worse - AOV, refund rate)
-> exit criteria, written BEFORE launch
-> stop-early rule using Thompson samplingBest used with: A specific change, baseline conversion rate, weekly traffic to the surface, and the smallest lift worth shipping.
Where this skill hits its ceiling: If the sample-size math says 11 weeks and you do not have 11 weeks of traffic, the number itself is the useful output. Ship on judgment or pick a higher-traffic surface.
With Intempt: Test designs, guardrails and exit criteria are logged against the experiment so the stopping rule cannot be quietly renegotiated after launch.
8. the-first-mile-mapper - the landing page after the landing page
Maps the post-signup activation flow - what happens between signup and the aha moment, and how drop-off gets diagnosed at each step. Different job from checkout: this is SaaS or product-led conversion, where the "purchase" is the first meaningful action, not a payment. The landing page's job is to get the signup; this skill's job is to make sure the signup was worth getting.
When to use: When signups are climbing but activation is not, or when the drop-off between signup and aha has never been diagnosed on purpose.
How to run:
You: "Run the-first-mile-mapper for our onboarding."
[context: signup flow, named aha moment, current activation rate]
Claude: -> step-by-step activation flow mapped
-> drop-off diagnosis at each step
-> what is missing before the aha (product, prompt, prerequisite)
-> a redesign of the flow if the current one skips the aha entirelyBest used with: A named aha moment - not "user is happy" - and real activation rate numbers by step.
Where this skill hits its ceiling: It designs the flow. Building it inside your product is engineering work, not a skill output.
With Intempt: Activation flows plug into lifecycle workflows so the aha step is a first-class event in the journey.
Which skill to run first, per page problem
| The problem | Run this first | Why |
|---|---|---|
| Conversion is down and nobody knows where | the-leak-finder | Localize before you touch the surface |
| Session to cart is losing people | the-pdp-reviewer | Objections drive that stage more than layout |
| Cart to purchase is losing people | the-checkout-auditor | Friction, trust and payment methods |
| Campaign needs a page this week | the-page-shipper | Prototype-ready HTML from a real brief |
| Hero copy is flat | the-hook-lab | Four frameworks, one recommendation |
| Personalization has no measurement plan | the-variant-router | Segment-to-variant with a fallback |
| Test needs a stopping rule | the-hypothesis-engine | Exit criteria BEFORE launch, not after |
| Signups are up but activation is not | the-first-mile-mapper | The aha moment is the whole variable |
The pattern here: a diagnostic skill goes first, then the surface audit, then the design. Redesign-first is the failure mode this catalog is built to eliminate.
Where Claude Code skills fit alongside Intempt
Skills produce briefs, diagnoses and prototype pages. Intempt runs the live campaigns, the identity graph and the shared profile every page reads. The handoff is one-directional: a skill drafts the page or the test, you review it, it runs inside Intempt Marketing against a real audience.
This matters because a landing page is only as good as the segment it is served to. A great page for the wrong audience is a converted signup that never activates - the first-mile mapper's whole point. When the page's audience and the marketing agent's audience are the same audience, the test result tells you something. When they are not, the test tells you nothing.
What to install this week
- Install the experimentation-lead pack first. the-leak-finder, the-hypothesis-engine and the surface auditors all live there.
- Do not run a surface audit before the leak finder points at that surface. Auditing the wrong page is faster and cheaper than redesigning it, but still a waste.
- Ship the prototype from the-page-shipper as a test variant, not as the new page. The point is that the test tells you which to keep.
- Write the exit criteria on the ticket before the test goes live. If the criteria live in a chat log, they will be renegotiated the day the numbers look ambiguous.
For a full CRO pack walkthrough, see 10 best Claude skills for CRO and A/B testing. Start for free on Intempt if you would rather test pages against a live shared profile than a spreadsheet.
Frequently asked questions. Answered.
Claude skills for landing page optimization are versioned SKILL.md files that Claude Code reads from a local folder to diagnose a landing page or ship a new one with a stated method. The pack covers funnel leak diagnosis, PDP reviews, checkout audits, prototype-ready page shipping, hook variants, personalization routing, Bayesian test design, and activation flow mapping. Install with npx skills add sidchaudhary/gtm-skills/skills/experimentation-lead, .../brand-designer, and .../performance-marketer.
