Skip to content
Back to search

webbuild

SkillWorks with Claude CodeGitHub

Build professional, distinctive, pitch-ready business websites — including scroll-driven "3D" heroes (AI video scrubbed by scroll), real-time Three.js / React Three Fiber scenes, GSAP + Lenis motion, and treated-video shaders — that do NOT look AI-generated. Covers the brief, reverse-engineering reference sites, design system (type, colour, layout, copy), hero/asset pipeline, performance and accessibility, visual QA with screenshots, a slop linter, deployment, and pitching the site to a local business. Use this whenever the user wants to build, redesign or polish a website or landing page, mentions 3D websites, scroll animations, Awwwards-style or "$10K" sites, Three.js/GSAP/Spline, wants a site "like" another site, wants to rebuild a business's site to pitch or sell it, or complains a site looks generic / like AI slop — even if they don't say "webbuild".

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/harishisonline--webbuild-skill/badge.svg)](/listings/harishisonline--webbuild-skill)

HTML

<a href="/listings/harishisonline--webbuild-skill"><img src="/api/listings/harishisonline--webbuild-skill/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

git clone https://github.com/Harishisonline/webbuild-skill ~/.claude/skills/webbuild

Restart Claude Code, then ask for a website ("build a premium homepage for the barbershop on my street", "make a 3D landing page for my coffee brand", "this site looks like AI slop, fix it"). The skill triggers on its own. You can also say "use webbuild".

The browser scripts need Playwright once per project:

npm i -D playwright && npx playwright install chromium

`frames.sh` needs ffmpeg (`brew install ffmpeg`). `rea-teardown.sh` needs Google Chrome (or Playwright's Chromium); it fetches REA and a compatible Node through npx on first run.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 173 lines
  1. ---
  2. name: webbuild
  3. description: Build professional, distinctive, pitch-ready business websites — including scroll-driven "3D" heroes (AI video scrubbed by scroll), real-time Three.js / React Three Fiber scenes, GSAP + Lenis motion, and treated-video shaders — that do NOT look AI-generated. Covers the brief, reverse-engineering reference sites, design system (type, colour, layout, copy), hero/asset pipeline, performance and accessibility, visual QA with screenshots, a slop linter, deployment, and pitching the site to a local business. Use this whenever the user wants to build, redesign or polish a website or landing page, mentions 3D websites, scroll animations, Awwwards-style or "$10K" sites, Three.js/GSAP/Spline, wants a site "like" another site, wants to rebuild a business's site to pitch or sell it, or complains a site looks generic / like AI slop — even if they don't say "webbuild".
  4. ---
  5. # webbuild
  6. Make websites a business owner would pay for: specific to *them*, fast on a phone, one
  7. memorable moment, and nothing that screams "an AI made this". The craft is mostly in the
  8. choices before code and in looking at the result honestly afterwards.
  9. Paths below are relative to this skill's folder (`scripts/`, `references/`, `assets/`).
  10. ## 0. Set up the project (2 min)
  11. - New site → copy `assets/starter/` into the project folder (plain HTML + CSS + ES modules,
  12. pinned CDN imports, no build step: deploys anywhere, easy to edit). Use Next.js / Astro / R3F
  13. only if the user asks or the project already uses them (`references/3d-playbook.md` §5).
  14. - Existing project → keep its framework, tokens and components; this skill adds direction,
  15. motion and QA, not a rewrite.
  16. - Create `BUILD_NOTES.md` in the project. It's the memory across context resets: brief,
  17. decisions, open questions, fixes that worked.
  18. ## 1. Brief — get the real business
  19. Gather (from the user, the business's current site, Google Business Profile, Instagram):
  20. name, what they sell, where, since when, the **one primary action** (call / book / order /
  21. quote / visit), real proof (rating + count, years, licences, press), real photos, logo/colours,
  22. hours, address, phone. Write the 5-line brief from `references/design-system.md` §2 into
  23. `BUILD_NOTES.md`.
  24. Never invent facts — fabricated reviews, stats, prices or addresses in a pitch destroy trust
  25. the moment the owner reads them. Instead:
  26. - **Write around unknowns** so the demo still reads finished: "Koregaon Park, Pune" instead of
  27. a made-up street number; "Rated 4.7 on Google" instead of invented quotes; service names
  28. without prices, or "from ₹…" only if known.
  29. - Where a fact is genuinely required (phone, exact address, hours), use a visible
  30. `{{placeholder}}` — `slop_check.py` blocks shipping until it's filled.
  31. - Put every unknown and assumption on an "Ask the client" list for the final report.
  32. For a creator or channel site, ask for (or pull) the dashboard numbers and the profile
  33. picture up front: YouTube Studio / Instagram insights screenshots, plus vidIQ or similar if
  34. connected. A Results section built from real numbers is what sells it.
  35. If the brief is thin and the user is around, ask at most 3 questions (business + city,
  36. primary action, any site they love). If they want you to just go, make sensible assumptions,
  37. write them down, and keep moving.
  38. ## 2. Reference (when the user names a site, sends a recording, or wants a "rebuild")
  39. Follow `references/reverse-engineer.md`: `node scripts/teardown.mjs <url>` measures the stack,
  40. fonts, palette, media and shader evidence and screenshots the scroll; screen recordings become
  41. frames you read and turn into a beat-by-beat motion spec. When that quick pass can't explain
  42. an effect, go deeper with REA's engine: `scripts/rea-teardown.sh <url>` captures the page,
  43. fingerprints the bundle and exports every script so you can read how it's actually built
  44. (guides in `references/rea/`). Record OBSERVED → INFERENCE → DECISION. Learn the technique;
  45. never copy brand, copy, assets or code.
  46. ## 3. Direction — plan, then attack the plan
  47. Read `references/design-system.md` (the anti-slop rules — classic *and* the newer
  48. "tasteful AI" tells like cream + terracotta, ALL-CAPS eyebrows, editorial hairlines). In
  49. `BUILD_NOTES.md` write:
  50. - 4–6 named colour tokens taken from the business, type pairing + roles, radius language
  51. - ASCII wireframe of each section (vary the rhythm — no hero → 3 cards → logos → testimonials)
  52. - the **signature moment** (exactly one) and why it fits *this* business
  53. - 3 principles that make it distinctive
  54. Then review the plan against the tell list and, for each choice that reads as a default,
  55. justify it for this business or change it. Asking "could this belong to another business if
  56. I swapped the logo?" catches most problems here, where they're cheap.
  57. For an undecided direction the user wants to choose, show 2–3 genuinely different directions
  58. (a still or a quick HTML sketch each) before building — `21st-ui-explore` can help if installed.
  59. ## 4. Hero — pick the mode that serves the business
  60. `references/3d-playbook.md` §1 has the decision table. Short version:
  61. - **still** (great photo/type) — places, food, salons, clinics, services. Often the right call.
  62. - **video** — atmosphere loop, ideally *treated* with `assets/starter/grade.js` so AI/stock
  63. footage gets a bespoke grade (grain, halation, lift/gamma/gain, vignette). Pick a LOOK and
  64. keep it subtle.
  65. - **frames** — the "$10K 3D website": AI start/end keyframes → first/last-frame video →
  66. `scripts/frames.sh` → canvas scrubbed by scroll. Read `references/scroll-video-playbook.md`
  67. for the keyframe rules, prompts and blending.
  68. - **scene** — live Three.js / R3F when 3D *is* the product story (configurable product,
  69. architecture, tech). Subject must be the business's thing, never the placeholder knot.
  70. - **whole page** — when the owner asks for a "3D website", they usually mean 3D throughout,
  71. not a 3D hero. Use one fixed scene with a camera station per section
  72. (`references/3d-playbook.md` §6).
  73. Generate assets with whatever is connected (Higgsfield / Kling / kie.ai / Nano Banana MCPs or
  74. skills), or ask the user to drop files in. If nothing is available, build with a clearly
  75. labelled placeholder and list exactly what asset to generate, with the prompt.
  76. ## 5. Build
  77. Order: tokens (`styles.css :root`) → semantic HTML sections with real copy → layout at 390px
  78. and 1440px → hero mode → motion last.
  79. - Copy rules: `references/design-system.md` §8 (outcome + place + specifics, real CTA verbs,
  80. banned words).
  81. - Required for a business site: one obvious CTA above the fold and again at the end, `tel:` /
  82. booking / form, hours + address + map link, real proof, title + description + OG image,
  83. LocalBusiness JSON-LD, favicon, sticky call/book bar on mobile when the action is a call.
  84. - Motion: one signature moment + quiet 150–300 ms micro-feedback; ease-out, never bounce;
  85. `transform`/`opacity` only; reduced-motion shows end states.
  86. - Components: search `references/resources.md` registries (21st.dev, React Bits, Aceternity,
  87. Motion Primitives…) before hand-writing complex effects, then restyle to the tokens. In a
  88. static site, rebuild React components in vanilla rather than adding React for one effect.
  89. - Footer: build it to `references/design-system.md` §11 (brand block, link columns with
  90. platform logos, contact buttons, oversized wordmark, bottom row). Owners judge the whole site
  91. by it. The small builder credit is already in the starter; the client can ask to remove it.
  92. - Buttons and scroll: follow `references/design-system.md` §12 (tactile 0.16 s buttons, cursor
  93. ring via the starter's `cursor.js`, no native scrollbar: the starter's `blockbar.js` replaces it).
  94. - Before you call it done, reread `references/design-system.md` §10: the things owners still
  95. call slop after every rule passes.
  96. ## 6. Look at it — this is where good sites are made
  97. Serve locally (`npx serve .` or the project's dev server), then:
  98. 1. `node scripts/shoot.mjs http://localhost:3000 ./shots` — phone / laptop / desktop
  99. screenshots along the scroll + console errors, overflow, LCP, weight. **Read the PNGs.**
  100. (Or use the browser pane / Playwright MCP if available.) Also run once with
  101. `--reduced-motion`.
  102. 2. `python3 scripts/slop_check.py .` — must end with 0 FAIL. Treat WARNs as questions.
  103. (`npx impeccable detect` is a good second opinion if installed.)
  104. 3. Critique honestly against the brief: hierarchy, type, colour, the signature moment, mobile,
  105. copy specificity. Fix in batches with clear intent ("lower sections feel generic — make
  106. them more expensive, not busier").
  107. 4. **Subtract one decorative element** before calling it done.
  108. Expect 3–6 rounds; nobody one-shots this. Log what fixed what in `BUILD_NOTES.md`.
  109. ## 7. Ship + pitch
  110. - Deploy: Vercel / Netlify / Cloudflare Pages / GitHub Pages. **Commit the frames folder**
  111. (the most common "the hero vanished in production" bug). Add `<meta name="robots"
  112. content="noindex">` to spec demos until the client buys.
  113. - If it's a pitch, read `references/pitch-and-sell.md`: before/after video, outreach scripts,
  114. pricing anchors, the pitch-ready checklist, handover.
  115. ## Final report to the user
  116. Keep it short and concrete:
  117. - What was built (direction in one line, signature moment, hero mode) and where (paths, URL)
  118. - How to run it (`npx serve .` or the dev command)
  119. - QA results: slop_check FAIL/WARN counts, shoot.mjs LCP / errors per viewport, what you
  120. looked at and fixed
  121. - **Ask the client** list: every `{{placeholder}}` and assumption
  122. - Assets still to generate (with ready-to-use prompts), if any
  123. ## Reference map
  124. | Read | When |
  125. |---|---|
  126. | `references/design-system.md` | Always, before choosing colour/type/layout/copy |
  127. | `references/3d-playbook.md` | Choosing the hero; any Three.js/R3F; performance + a11y budget |
  128. | `references/scroll-video-playbook.md` | Scroll-scrubbed "3D" hero from AI video |
  129. | `references/reverse-engineer.md` | A reference site, a recording, or rebuilding a prospect's site |
  130. | `references/rea/README.md` | Going deeper than teardown.mjs with REA's tools |
  131. | `references/resources.md` | Component registries, effect tools, inspiration, companion skills |
  132. | `references/pitch-and-sell.md` | Spec site for a prospect, pricing, outreach, handover |
  133. | Script | Does |
  134. |---|---|
  135. | `scripts/teardown.mjs <url>` | Measure a reference site (stack, fonts, palette, media, shaders, screenshots) |
  136. | `scripts/rea-teardown.sh <url>` | Deep teardown with REA's engine: page capture, bundle fingerprints, exported scripts |
  137. | `scripts/frames.sh <video> <out>` | Video → WebP frame sequences (desktop + mobile) + manifest |
  138. | `scripts/shoot.mjs <url> [out]` | Screenshots at 3 widths along the scroll + errors/LCP/overflow |
  139. | `scripts/slop_check.py <dir>` | AI-slop + ship-readiness linter (0 FAIL to ship) |
  140. Playwright for the `.mjs` scripts: `npm i -D playwright && npx playwright install chromium`.
README.md · README · 87 lines
  1. # webbuild — a Claude Code skill for websites that don't look AI-made
  2. **webbuild** turns Claude Code into a careful web studio. It builds professional, pitch-ready
  3. business websites, including scroll-driven "3D" heroes, real-time Three.js scenes, GSAP + Lenis
  4. motion and treated-video shaders. It then checks its own work so the result doesn't read as
  5. generic AI output.
  6. It came out of studying the most-watched 2026 "build $10K websites with Claude Code" tutorials,
  7. 40 professionally built 3D demo sites, the REA reverse-engineering method, and the current
  8. anti-slop design guidance (Anthropic's frontend-design skill, Impeccable, Taste Skill). That
  9. research is condensed into one workflow, four scripts and a starter.
  10. ## What it does
  11. 1. **Brief.** Gets the real business: its one primary action and real proof. It never invents reviews or stats.
  12. 2. **Reference.** `teardown.mjs` measures any site you admire: stack, fonts, palette, media,
  13. shader uniforms and scroll screenshots. For a deeper look, `rea-teardown.sh` runs
  14. [REA](https://github.com/morluto/rea)'s browser engine to fingerprint the bundle and export
  15. every script. You learn the technique without cloning the site.
  16. 3. **Direction.** Plans named colour tokens, a type pairing, wireframes and one signature
  17. moment, then reviews that plan against a list of classic and 2026 AI tells.
  18. 4. **Hero.** Picks one of four modes: still, treated video (WebGL grading shader), scroll-scrubbed frame sequence (the
  19. "$10K 3D website"), or live Three.js.
  20. 5. **Build.** A zero-build starter with pinned CDN imports, Lenis, ScrollTrigger, DPR caps and
  21. reduced-motion and low-power fallbacks.
  22. 6. **Look.** `shoot.mjs` screenshots phone, laptop and desktop along the scroll and reports
  23. errors, LCP and overflow. `slop_check.py` lints for AI slop and ship-readiness. It must show 0 FAIL.
  24. 7. **Ship and pitch.** Deploy notes, outreach scripts, pricing anchors and a pitch-ready checklist.
  25. ## Install
  26. ```bash
  27. git clone https://github.com/Harishisonline/webbuild-skill ~/.claude/skills/webbuild
  28. ```
  29. Restart Claude Code, then ask for a website ("build a premium homepage for the barbershop on my
  30. street", "make a 3D landing page for my coffee brand", "this site looks like AI slop, fix it").
  31. The skill triggers on its own. You can also say "use webbuild".
  32. The browser scripts need Playwright once per project:
  33. ```bash
  34. npm i -D playwright && npx playwright install chromium
  35. ```
  36. `frames.sh` needs ffmpeg (`brew install ffmpeg`). `rea-teardown.sh` needs Google Chrome (or
  37. Playwright's Chromium); it fetches REA and a compatible Node through npx on first run.
  38. ## What's inside
  39. ```
  40. SKILL.md the workflow Claude follows
  41. references/
  42. design-system.md anti-slop rules, type pairings, colour, layout, copy
  43. 3d-playbook.md hero-mode decision table, Three.js/R3F recipes, perf + a11y budget
  44. scroll-video-playbook.md keyframes → AI video → frames → scroll scrub, with prompts
  45. reverse-engineer.md evidence-first teardown of reference sites
  46. rea/ REA's web reverse-engineering guides (MIT, vendored)
  47. resources.md 21st.dev, React Bits, Aceternity, GSAP, Spline, inspiration…
  48. pitch-and-sell.md finding clients, outreach scripts, pricing, handover
  49. scripts/
  50. teardown.mjs measure a reference site
  51. rea-teardown.sh deep teardown with REA's engine (runs via npx)
  52. frames.sh video → WebP frame sequences + manifest
  53. shoot.mjs multi-viewport screenshots + errors/LCP/overflow
  54. slop_check.py AI-slop + ship-readiness linter
  55. assets/starter/ index.html, styles.css, main.js, scene.js, grade.js
  56. evals/ test cases (runnable with `claude plugin eval`)
  57. ```
  58. ## Credits
  59. - [REA](https://github.com/morluto/rea) by morluto (MIT): its web guides are vendored in
  60. `references/rea/` with its license, and `rea-teardown.sh` runs its engine from npm.
  61. - Design guidance draws on Anthropic's [frontend-design skill](https://github.com/anthropics/skills),
  62. [Impeccable](https://impeccable.style) and [Taste Skill](https://github.com/Leonxlnx/taste-skill).
  63. - Technique notes from tutorials by Metics Media, Nate Herk, Jack Roberts, Nick Saraev,
  64. Chase AI, AI Chris Lee, AyzZ, Komputer Mechanic, MiladiCode and DesignCourse (links in
  65. `references/scroll-video-playbook.md`).
  66. - Apart from REA's guides (MIT), no third-party code or assets are copied. `grade.js` is an
  67. original implementation of the treated-video idea.
  68. ## Author
  69. Built by Harish: [LinkedIn](https://www.linkedin.com/in/harishpradhan0131/) · [GitHub](https://github.com/Harishisonline)
  70. MIT licensed.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.