first-screen-check — Claude Code skill: what it does, how to install
first-screen-check is a Claude Code skill that audits mobile landing screens. It spots missing call buttons, review badges, and unkept ad promises.
MIT ★ 778 updated 2026-11-16
/plugin marketplace add boringmarketer/boring-marketing-skills
/plugin install boring-marketing@boring-marketing-skillsWhat first-screen-check does
Inspects landing pages inside a mobile viewport of 390 by 664 pixels. The skill checks whether elements promised in ads or search listings, such as same-day service or emergency hours, actually appear before the user scrolls. It outputs a ranked list of conversion leaks along with a single priority fix.
Local captures rely on Playwright. Running npx playwright install chromium is required beforehand, otherwise the screenshot step fails. When a local browser is absent, it can fetch rendered pages and screenshots via Firecrawl using FIRECRAWL_API_KEY. As a fallback, a Python 3 script parses the raw HTML structure directly.
What it helps with
- find mismatches between ad promises and mobile first-screen copy
- verify tap-to-call phone links on smartphones
- check the visibility of star ratings and review counts on mobile screens
- audit a prospect's landing page before a sales pitch
Example prompts for the agent
- Check my site on a phone: <url>
- My ads get clicks but no calls, inspect <url> with promise "same-day"
- Review the first screen of this prospect landing page before our call
How to install first-screen-check
1Plugin marketplace
/plugin marketplace add boringmarketer/boring-marketing-skills/plugin install boring-marketing@boring-marketing-skillsThis installs the whole boring-marketing plugin with all its skills
2Skills CLI (Vercel)
npx skills add boringmarketer/boring-marketing-skills --skill first-screen-check -a claude-code3Manually: put the files in place
~/.claude/skills/first-screen-check/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/first-screen-check/
1Skills CLI (Vercel)
npx skills add boringmarketer/boring-marketing-skills --skill first-screen-check -a codex2Manually: put the files in place
.agents/skills/first-screen-check/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add boringmarketer/boring-marketing-skills --skill first-screen-check -a cursor2Manually: put the files in place
.cursor/skills/first-screen-check/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install boringmarketer/boring-marketing-skills skills/first-screen-check2Manually: put the files in place
.github/skills/first-screen-check/SKILL.md1Skills CLI (Vercel)
npx skills add boringmarketer/boring-marketing-skills --skill first-screen-check -a gemini-cli2Platform CLI
gemini skills install https://github.com/boringmarketer/boring-marketing-skills --path skills/first-screen-checkManually: put the files in place
.devin/skills/first-screen-check/SKILL.mdThe legacy .windsurf/skills/ path still works
Claude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about first-screen-check
How to install first-screen-check in Claude Code?
Add the marketplace by running /plugin marketplace add boringmarketer/boring-marketing-skills. Then install the package with /plugin install boring-marketing@boring-marketing-skills.
What does first-screen-check do?
It checks what mobile visitors see before scrolling, specifically looking for tap-to-call buttons, star ratings, and ad commitments. It returns an actionable list ranked by lost calls.
What is required to run first-screen-check?
Capturing screenshots requires Chromium installed via npx playwright install chromium or a FIRECRAWL_API_KEY. Without them, it falls back to Python 3 to parse the page HTML.
Source text
SKILL.md · MIT
---
name: first-screen-check
description: Looks at a local business's site, or the page its ad opens, the way a customer sees it on a phone, and reports what the first screen is missing (the number with tap-to-call, the promise the ad made, the star rating and other proof, a way to book) plus the site faults that quietly break trust, as a short ranked list with one thing to fix first. Use when the site or the ads aren't making the phone ring, when someone wants a page checked on a phone, or when sizing up a prospect's site before a pitch.
when_to_use: check my site on a phone, why isn't my website getting calls, first screen check, is my phone number easy to find, check the page my ad goes to, does my page match my ad, my ads get clicks but no calls, what's wrong with this website, check a plumber's site, check a prospect's site, mobile site check
argument-hint: "[site URL or the URL an ad opens] [optional: the ad's text or promise]"
metadata:
boring:
version: 4.1.1
layer: execution
reads: [positioning#chosen-angle, competitors]
writes: [assets]
optional-keys: [FIRECRAWL_API_KEY]
enhances_with:
- toolset: web-scrape
gains: "reads pages that build themselves with JavaScript and can return a phone-size screenshot when no local browser is installed"
---
# First Screen Check
Most local customers meet a business on a phone, from a Google search, a map listing or
an ad, and decide in the first screen whether to call, go back, or call the next
result. This skill looks at that screen the way they do and reports what's missing,
ranked by how many calls it costs, with one fix to make first. Done means a short list
an owner can act on today, each item backed by what the page actually shows. The checks
are a floor. When the business in front of you argues for a different order, change 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 first-screen-check`
(`${CLAUDE_SKILL_DIR}` is this skill's folder; outside Claude Code use the folder this
file was read from, e.g. `.agents/skills/first-screen-check`. 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. Ask only for the URL, and for the
ad's text if the page is an ad's landing page.)
Checking a prospect's site rather than the user's own? Don't load or write brand files
for it. The report lands in `./campaigns/` and nothing else changes.
No URL given, or only a placeholder (example.com, yourdomain.com)? Ask for the URL in one
line. Never run the checks or the redirect and structured-data commands against a
placeholder.
## What the data says
From hundreds of local business sites checked on a phone in November 2026.
The sample is self-selected (businesses that people chose to look up, mostly US home
services), so read the shares as "common", not as a census.
- Very few passed every check. Most had 3 or more gaps.
- 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.
- Most have 4.5 stars or better and 100 or more reviews, and most of those don't show the rating on the first screen.
The common failures aren't about design taste. They are things the business already has (a promise it pays to advertise, a rating it earned) that never
reach the screen where the customer decides. Look for those first.
## Phase 1: Pick the page and the promise
**The page.** Check the page customers actually land on, not the one the owner thinks
of as "the site". In order of how much traffic it usually carries:
1. The page each ad opens (its final URL). Paid clicks are the most expensive visitors.
2. The page the Google Business Profile's website button opens (often the homepage,
sometimes a location page).
3. The page that ranks for "<main service> <city>".
If several differ, check the ad page and the profile page. Two good checks beat five
thin ones.
**The promise.** Write down, word for word, what the customer was promised before
they tapped: the ad's headline and description, the profile's hours ("Open 24 hours"),
and any offer ("$49 drain cleaning", "free estimates"). Free ways to get the ad text:
- The user pastes it, or a screenshot from their ad account.
- Google's Ads Transparency Center (adstransparency.google.com): search the business
name or domain, set the region, and read the text ads. It searches by advertiser, not
by keyword.
- A search for "<service> <city>" on a phone in the service area. Ads change by location
and hour, so say when and where you looked.
No ad running? The promise is whatever the profile and the search snippet said:
the hours, the services, the rating shown beside the listing.
## Phase 2: See the first screen on a phone
Take the best path the agent has. The report says only whether it rests on a phone
screenshot or on the page HTML.
**A. A browser on the machine (best).** Playwright takes a phone-size screenshot from
the command line. The first time on a machine, download its browser with
`npx playwright install chromium`; without it the screenshot command fails with
"Executable doesn't exist".
```bash
npx playwright install chromium # once per machine
npx playwright screenshot --viewport-size "390,664" --wait-for-timeout 3000 --timeout 45000 <url> first-screen.png
npx playwright screenshot --viewport-size "390,664" --full-page --timeout 45000 <url> full-page.png
```
390 by 664 is what an iPhone 13 shows inside the browser bars. The 3-second wait lets
late popups, chat bubbles and cookie banners load, because the customer sees those too.
(`--device "iPhone 13"` also works but runs WebKit, which needs
`npx playwright install webkit` first.) Read both images. Count how many phone screens
tall the full page is and where the number, the promise and the rating first appear.
A browser extension or MCP browser works the same way: set the window to 390 wide,
load, wait, capture.
**B. No browser, Firecrawl keyed.** We use Firecrawl for this: its scrape returns a
phone-size screenshot and the rendered HTML with no browser installed, and it reads pages
that build themselves with JavaScript (free tier of 1,000 credits a month, no card). Ask for
the mobile screenshot and the rendered HTML. Same reading as A. Without it, path A or C
does the same check.
**C. Neither (fallback).** Read the HTML in order. If python3 is available, run:
```bash
python3 ${CLAUDE_SKILL_DIR}/scripts/page_facts.py <url> --promise "24/7" --promise "same-day"
```
It prints facts only: redirect hops, the H1 and where it starts, the opening words in
reading order (menus left out), tap-to-call links, phone numbers, where each promise
word and "reviews" first appear (as a word position), forms and their fields, the
structured data, the weight of the first images, and widgets that tend to cover the
screen. Without python3, WebFetch the page and read the same things by hand.
**Estimating the first screen from HTML.** It usually holds the header, the headline and
somewhere between 20 and 70 words of copy, fewer when a big photo, video or offer banner
sits above the headline. Anything the script places past about word 80 is usually below the
first screen. In Sources and assumptions, say once in plain words that the first screen is
estimated from the page HTML and that popups and JavaScript-built parts can't be seen this
way.
Two traps that make a page look better or worse than it is:
- **Call tracking swaps numbers.** The HTML can carry one number and the rendered page
another. That is normal. What matters is that the number on screen rings the business
and is the same one the customer can tap.
- **Rating badges load by JavaScript.** "Reviews" missing from the HTML doesn't prove
the rating is missing from the screen. Only a screenshot settles it.
> Optional: boringfunnels (made by the author of this library, paid Pro with a free search) helps with this step: its prospect tool reads a named business's Google rating, newest reviews and ads, and its teardown opens one real page that sells well, section by section with phone-size pictures, to hold your read against. The free path above gets the same answer by hand.
## Phase 3: The first-screen checks
Each check is a question the customer asks in the first few seconds. Load
`references/checks.md` for how to verify each one, what passes, and the edge cases.
| # | The customer's question | What to look for on the first screen |
|---|---|---|
| 1 | Did I land where the ad said? | The promise from Phase 1 in the same words: "24/7", "same-day", the price, the free estimate |
| 2 | Can I call right now? | The number, visible, as one tap (a `tel:` link that dials the right number); a call bar that stays once they scroll |
| 3 | Is this the right kind of business? | A headline that says the service and the area in plain words |
| 4 | Are they any good? | Star rating and review count (when they're strong), years in business, licensed and insured, a guarantee |
| 5 | What if I can't talk right now? | A way to book or a short form reachable from the first screen |
| 6 | Why call today? | Availability ("techs available today"), a response time, or an offer |
| 7 | Is anything in the way? | A popup, chat bubble, cookie banner or offer bar covering the number or the headline |
| 8 | Does it show up fast? | The page appears quickly on a phone; the main photo isn't megabytes |
Judgment for the close calls:
- **Promise match is literal.** If the ad says "same-day" and the page says "fast
service", that's a miss. The customer is scanning for the word they tapped on.
- **A rating only counts when it helps.** 4.8 from 300 reviews belongs under the
headline. 3.9 from 11 doesn't, and the fix is in `/reviews`, not on the page.
- **Booking matters more for routine jobs.** For an emergency plumber the call is the
whole game. For a dentist, a cleaner or a tune-up, people book from work at 9pm, and a
missing booking link is a top-three item.
- **Speed is a fix only when it's slow enough to see.** Run PageSpeed Insights in a
browser (pagespeed.web.dev, mobile tab). The keyless API often returns a quota error;
a free API key from Google Cloud fixes it. The cheapest tell needs no tool: the
weight of the main photo. A hero image over 1 MB on a phone page is a fix.
## Phase 4: The faults that break trust
These sit below the first screen, in the page source or the site structure, and cost
calls more slowly: through rankings, AI answers, and customers who feel misled. Check
them after Phase 3, and load `references/site-faults.md` for the commands and the
common versions of each. The short list:
- **Made-up prices.** A price range in the FAQ structured data or text that isn't what
the business charges, such as an hourly range the owner never quotes.
- **Hardcoded review data.** A rating baked into the page's structured data (a perfect
5.0 that never changes) that doesn't match the live Google profile. Google ignores
self-serving review markup for local businesses anyway, so it earns nothing and tells
on the site.
- **Old links that land on a 404.** Links from the Google profile, ads or other sites
that redirect into an error page.
- **A multi-megabyte hero image.** A desktop-size photo sent to every phone.
- **Duplicate town pages.** Town pages that are the same page with the city swapped.
- **Numbers that don't match.** A different phone number on the site, in the structured
data, or in a corner of the Google profile, so some calls reach a line nobody tracks.
## Phase 5: Rank and write
Rank by calls lost, then by effort. The default order, which you can change with a
stated reason:
1. **Anything that stops the call outright.** An ad or the profile opening an error
page, no number on the first screen, a number that isn't tappable or dials wrong, a
popup covering the screen.
2. **The paid promise missing.** Every click on that ad is paid for, and the visitor
came for that word.
3. **Proof they have but hide.** Strong rating not shown, license and insurance buried.
4. **A headline that doesn't say what they do and where.**
5. **No way to act without calling** (move up for routine and booked services).
6. **Slow, heavy pages.**
7. **The trust faults from Phase 4.** Move a fault to the top when it's visible to
customers (a fake price they'll be quoted against) or when it breaks a paid link.
Weight by traffic. A fault on the page every ad opens outranks the same fault on the
About page. A 10-minute fix that unblocks calls goes ahead of a redesign.
Keep the list short: 5 to 7 items. More than that and the owner fixes none of them.
**Fix first** is one item, chosen because it costs the most calls per minute of work,
with that reason in one sentence.
Every item names what the customer sees (quote the page or point at the screenshot),
why it costs calls in plain words, the fix (the actual words or element to add), and
rough effort. No item rests on a guess: if you couldn't see it, say so in the note.
## Output
Write `./campaigns/<business-slug>-first-screen/first-screen-check.md`, plus
`first-screen.png` and `full-page.png` beside it when a screenshot was taken. Append one
line to `./brand/assets.md` when a brand folder exists (never for a prospect). Then the
chat summary: header, the ranked list, **Files saved**, **What's next**.
Write the report for the owner, in plain words, with the screenshot first. Length: the
plan budget (about 1,200 to 2,500 words) is a ceiling, and five to seven items usually
need far less. **Fix first** carries item 1 in full and the table holds the rest in order,
so nothing is said twice. Sources and assumptions closes the report, 10 lines at most:
what the report rests on (page, date, screenshot or HTML), what was not checked, and what
the owner should confirm. A sample, for the sample business Hartline Plumbing, Dallas TX
(illustrative, not a real site):
```markdown
## FIRST SCREEN CHECK: hartlineplumbing.com (sample)
Nov 13, 2026 · the page the ad opens, /emergency-plumber-dallas, on a 390px phone

**Fix first:** put "24/7" and "same-day" in the headline. The ad says "24/7 Emergency
Plumber, Same-Day" and the first screen says "Quality Plumbing Since 1998". A click that
doesn't see what the ad promised goes back to Google, and the click is still paid for.
New headline: "24/7 Emergency Plumber in Dallas. Same-Day Service." Ten minutes of work
on the page every paid click lands on.
**Then, in this order:**
| # | What a customer sees | Why it costs calls | Fix | Effort |
|---|---|---|---|---|
| 2 | The number is in the header as plain text | A caller who can't tap it rings the next result | Make it a tap-to-call link and add a call bar that stays on scroll | 15 min |
| 3 | 4.8 stars from 312 Google reviews, shown only in the footer | Their best proof never reaches the person choosing who to call | One line under the headline: "4.8 stars from 312 Google reviews" | 15 min |
| 4 | A chat bubble covers the call button after 3 seconds | The first thing they see is something to close | Move the bubble left or delay it until scroll | 5 min |
| 5 | The FAQ data says "$89-$149 per hour"; the owner quotes a flat price after seeing the job | A customer quoted differently feels baited, and AI answers can repeat the wrong price | Replace with the real pricing in words | 20 min |
**Sources and assumptions:**
- Based on a phone-size screenshot and the rendered page taken Nov 13, 2026, and the ad
text the owner pasted.
- Not checked: the booking flow past the first step (needs a test booking).
- Confirm with the owner what they actually charge before changing the pricing text.
```
## 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`.
## What's next
- `/landing-page`: build the page each ad should open, with the promise in the headline
and the call bar built in (~30 min)
- `/reviews`: when the rating or the review count is the weak spot, fix the source
before showing it off (~20 min)
- `/google-ads-tracking`: once the page gets calls, make sure the ads count them (~30 min)
- `/pitch-the-fix`: checking a prospect? Turn the fix-first item into a short email (~10 min)
© James Dickerson (@boringmarketer) · MIT · boringmarketer/boring-marketing-skills