Skip to content
Back to search

"promptory-web-builder"

"Promptory Web Build: stack for professional, accessible websites with GSAP + ScrollTrigger, Lenis smooth scroll, React Bits components, 13 design directions, distinctive typography that avoids templated defaults, Vercel React/Next.js performance rules, Supabase/Postgres practices, and Playwright testing of local web apps."

Safety scan

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

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/moramadan91--promptory-web-builder/badge.svg)](/listings/moramadan91--promptory-web-builder)

HTML

<a href="/listings/moramadan91--promptory-web-builder"><img src="/api/listings/moramadan91--promptory-web-builder/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

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 · 323 lines
  1. ---
  2. name: "promptory-web-builder"
  3. description: "Promptory Web Build: stack for professional, accessible websites with GSAP + ScrollTrigger, Lenis smooth scroll, React Bits components, 13 design directions, distinctive typography that avoids templated defaults, Vercel React/Next.js performance rules, Supabase/Postgres practices, and Playwright testing of local web apps."
  4. ---
  5. # Promptory Web Build
  6. Three tools, one stack, each with one job:
  7. | Tool | Role | Rule of thumb |
  8. |---|---|---|
  9. | **Lenis** | Scroll engine — smooth, inertial scrolling on top of native scroll | Installed once, globally. Never per-section. |
  10. | **GSAP** (+ ScrollTrigger) | Animation engine — custom timelines, scroll-driven animation, pinning | Anything bespoke to this site's design. |
  11. | **React Bits** | Ready-made animated components (text, backgrounds, cursors, cards, buttons) | Reach for it first when a catalog component already does the effect. |
  12. They share **one** animation loop: GSAP's ticker drives Lenis, and ScrollTrigger reads Lenis's scroll. Getting that wiring right is the single most important thing in this skill (§3).
  13. Scope: real-time web/DOM only. For video rendering (Remotion, reels), this skill does not apply.
  14. ## 0. Golden rule — don't redesign
  15. Implement the design and the effects the user asked for. Do **not** change layout, colors, fonts, spacing or copy on your own, and do not add extra sections or "bonus" effects nobody requested. If an effect or fix would clearly improve something, *suggest* it in one line and wait for a yes. Motion and quality checks should serve the existing design, not replace it.
  16. ## 0.5 Intake questionnaire — FIRST step on every new website request
  17. Before writing any code for a new site, run the intake questionnaire in `references/intake-questionnaire.md`:
  18. 1. Read the request and skip anything already answered.
  19. 2. Ask the remaining questions in up to 3 short rounds (project → motion → delivery). Use Claude Code's `AskUserQuestion` tool when available (clickable options + automatic "Other" free-text box); otherwise print each round as one code block with lettered options and an empty "✎ أخرى" line on every question.
  20. 3. Show the Project Brief in one code block and wait for the go-ahead.
  21. 4. Then build, following the answers exactly.
  22. If the user says "ابدأ على طول" / "skip", use the ⭐ defaults and state them in the Brief. For small edits to an existing site, skip the questionnaire unless the request is ambiguous.
  23. The brief must record: language and direction (Arabic/RTL, English/LTR, or both), the accessibility target (default WCAG 2.2 AA), the forms and their backend, and the analytics tool if any.
  24. ## 0.6 Visual references — Prompt Motion
  25. https://prompt-motion.com/ is the visual library for motion direction (kinetic type, product UI, particles, shapes, charts…, each with the prompt behind it). Use it only when the user asks for inspiration, picks "needs a proposal" / "bold motion" in the questionnaire, or shares a link from it. Borrow the motion idea, rebuild it with GSAP / Lenis / React Bits, keep the client's design. Workflow, category→component map and the motion-spec template: `references/visual-references.md`.
  26. ## 0.7 Quality bar — check before showing anything
  27. Scan the build for the generic-output tells (default indigo accent, emoji icons, invented metrics, lorem ipsum, stock template sections). Fix what is in your own code; suggest a one-line fix for anything in the client's design. Full list: `references/quality-bar.md`.
  28. ## 0.8 Design direction — every site looks different
  29. When the client has no design of their own, choose a direction before writing code. Read `references/design-styles.md` and:
  30. 1. Shortlist three directions from the Fit guide for the brief's industry and audience.
  31. 2. Skip any direction used in the last three sites in this chat or project (Style Log).
  32. 3. Write one line in the Project Brief: `Direction: <name> — <why>`, with one alternative.
  33. 4. Build with that direction's signature choices, then run the Variety check: at least four of six axes must differ from the previous site.
  34. The directions are references for structure and feel. Never copy a reference's brand, photos, copy or exact layout. If the client supplies a design, follow it and skip this step (§0 golden rule).
  35. ## 0.9 Distinctive visual design (when the brief leaves it open)
  36. Source: `anthropics/skills`, skill `frontend-design` (Apache-2.0, see its LICENSE.txt). Applies only where the brief leaves the visual direction open. §0 wins: follow the client's design and the brief's own words, including when the brief asks for one of the looks listed below.
  37. - Identify the subject first: product, audience, primary job. If the brief does not say, propose one and confirm. Industry and materials are where distinctive choices come from.
  38. - Hero opens with the most characteristic thing in the subject's world (headline, image, live demo, or interaction). Avoid the default of a big number, a small label, and a gradient accent unless it is clearly the best option.
  39. - Type: one family, or two that are clearly distinct. Set a clear type scale. In headlines, the type treatment is part of the design.
  40. - Line length under 80 characters. Serif body text needs slightly more line-height than sans.
  41. - Avoid typographic tells: one italic or colored word in a headline, all-caps labels, and labels above headings that add nothing.
  42. - Numbered markers (01 / 02 / 03) only when the content is really a sequence.
  43. - Motion: one orchestrated moment (page load or one reveal). No fade-and-slide on every section, no hover transition on every card. Motion that answers a user action (opening, expanding, confirming) is fine.
  44. - Plan before code: 4–6 named hex colors, type roles, a layout concept (ASCII wireframe allowed), and principles. Review the plan against the brief. If a part reads like the generic default for any similar page, revise it and say what changed.
  45. - Default looks to avoid unless the brief asks for them: cream background with terracotta accent; near-black with acid-green or vermilion accent; broadsheet with hairline rules and zero radius; identical rounded SaaS cards with one radius and one grey shadow; ALL-CAPS eyebrow above every heading; middle-dot meta strings ('A · B · C'); 'WORD — fragment' labels; #0B0B0B or #111 standing in for black; monospace for small labels; '→' on every link.
  46. - Spend boldness in one place. Keep everything around it quiet. Cut decoration that does not serve the brief.
  47. - Quality floor: responsive to mobile, visible focus, reduced motion respected, accessible contrast.
  48. - Watch CSS selector specificity, especially padding and margin between sections, where rules cancel each other.
  49. - Copy: plain words for the end user, active voice, sentence case. Keep one verb through a flow ("Publish" leads to "Published"). Errors say what happened and how to fix it, without apology. Empty states invite the next action.
  50. ## 1. Decision flow — which tool for which request
  51. 0. **Arabic, bilingual or RTL site** → read `references/rtl-arabic.md` before writing any layout. Direction is structural; retrofitting it is expensive.
  52. 1. Smooth scroll anywhere on the site → **Lenis** (global provider, §3). Do it once at project setup when any scroll animation exists.
  53. 2. Is there a React Bits component that already does the effect? → check `references/react-bits-catalog.md` → install it (§4). Typical hits: split/blur/scramble text, scroll-reveal text, animated backgrounds (aurora, particles, grids, shaders), custom cursors, magnet/tilt cards, marquees, galleries, dock/menus, animated buttons/counters.
  54. 3. Effect is specific to this design (hero intro sequence, pinned storytelling section, horizontal scroll section, synced multi-element reveals) → **GSAP** timeline / ScrollTrigger (§5, full detail in `references/gsap.md`).
  55. 4. Project is NOT React (plain HTML/vanilla) → React Bits is not available; use Lenis + GSAP only (`assets/vanilla-setup.js`).
  56. 5. Any form, list, booking or data-driven section → `references/forms-and-states.md` (labels, errors, five states).
  57. 6. Choosing a third-party service (fonts, form backend, analytics, hosting, images) → `references/free-services.md`, then verify current limits.
  58. 7. New site with no client design → pick a direction first (§0.8, `references/design-styles.md`).
  59. ## 2. Installation
  60. ```bash
  61. npm install gsap @gsap/react lenis
  62. ```
  63. - `@gsap/react` → only for React projects (provides `useGSAP`).
  64. - `lenis/react` and `lenis/snap` ship inside `lenis` — no extra packages.
  65. - All GSAP plugins (ScrollTrigger, SplitText, Flip, ScrollSmoother, Draggable…) ship inside `gsap`.
  66. - React Bits components are added individually via CLI (§4); some pull in their own deps (`motion`, `three`, `ogl`, `matter-js`…) — the CLI installs them, but check the Deps column in the catalog before choosing, to avoid bloating the bundle.
  67. **Never** use GSAP's ScrollSmoother together with Lenis — they are two competing smooth-scroll engines. Lenis is the scroll engine in this stack.
  68. ## 3. Wiring Lenis + GSAP + ScrollTrigger (do this exactly)
  69. ### React / Next.js
  70. Copy `assets/SmoothScroll.jsx` into the project (e.g. `components/SmoothScroll.jsx`) and wrap the app once:
  71. ```jsx
  72. // app/layout.jsx (Next.js App Router)
  73. import SmoothScroll from '@/components/SmoothScroll';
  74. import ScrollToTopOnRoute from '@/components/ScrollToTopOnRoute';
  75. export default function RootLayout({ children }) {
  76. return (
  77. <html lang="en">
  78. <body>
  79. <SmoothScroll>
  80. <ScrollToTopOnRoute />
  81. {children}
  82. </SmoothScroll>
  83. </body>
  84. </html>
  85. );
  86. }
  87. ```
  88. For Arabic, set `lang` and `dir` from the locale on `<html>` (see `references/rtl-arabic.md` §1).
  89. For Vite/React, wrap `<App />` in `main.jsx` the same way and skip `ScrollToTopOnRoute` (it uses `next/navigation`).
  90. What the provider does — and why each line matters:
  91. - `<ReactLenis root options={{ autoRaf: false }}>` → one global instance on `<html>`; `autoRaf: false` because GSAP will drive it.
  92. - `lenis.on('scroll', ScrollTrigger.update)` → ScrollTrigger recalculates on every smooth-scroll frame. Missing this = animations fire late/at wrong positions.
  93. - `gsap.ticker.add(t => lenis.raf(t * 1000))` → one shared loop (GSAP time is seconds, Lenis wants ms).
  94. - `gsap.ticker.lagSmoothing(0)` → no stutter catching up after a tab switch.
  95. - `ScrollTrigger.refresh()` after fonts and load → trigger positions match final layout.
  96. ### Vanilla HTML/JS
  97. Use `assets/vanilla-setup.js` as the entry module, import `lenis` from it where needed.
  98. ## 4. React Bits — picking and installing components
  99. 1. Find the component in `references/react-bits-catalog.md` (grouped: Text Animations, Animations, Components, Micro, Backgrounds — name, what it does, deps).
  100. 2. Pick the flavor matching the project: `JS` or `TS`, then `CSS` or `TW` (Tailwind).
  101. 3. Install:
  102. ```bash
  103. npx shadcn@latest add @react-bits/SplitText-TS-TW
  104. ```
  105. For the `@react-bits/` shorthand, the project's `components.json` must contain:
  106. ```json
  107. { "registries": { "@react-bits": "https://reactbits.dev/r/{name}.json" } }
  108. ```
  109. No `components.json` / not a shadcn project? Use the direct URL instead:
  110. ```bash
  111. npx shadcn@latest add https://reactbits.dev/r/SplitText-TS-TW.json
  112. # or
  113. npx jsrepo@latest add https://reactbits.dev/r/SplitText-TS-TW
  114. ```
  115. 4. Open the installed file and read its props before using it — every component is configurable (colors, speed, delay, easing, triggers). Set props to match the site's existing design tokens (colors, fonts) rather than leaving demo defaults.
  116. 5. If the user wants the agent workflow: `npx shadcn@latest mcp init --client claude` connects Claude Code to the registry via MCP.
  117. Integration notes:
  118. - React Bits components that animate on scroll (ScrollReveal, ScrollFloat, AnimatedContent, SplitText…) use GSAP ScrollTrigger or IntersectionObserver internally → they work with Lenis automatically **as long as §3 is in place**.
  119. - Components are client components (`'use client'`). In Next.js, render them inside client components or pages that allow it.
  120. - WebGL/shader backgrounds (deps `three`, `ogl`, `vgpu`) are heavy: max one or two per page, lazy-load below-the-fold ones (`next/dynamic` with `ssr: false` or `React.lazy`), and give them a fixed-size container. Pause them when off-screen or when the tab is hidden.
  121. - Don't stack two cursor effects or two backgrounds in the same viewport.
  122. - Check each component for a pause control if it loops for more than 5 seconds (see `references/accessibility-motion.md` §5).
  123. - License: React Bits is MIT + Commons Clause — free to use inside any client website (including paid client work), but the components themselves must not be resold or redistributed as a pack/template. Never paste React Bits source into this skill or a shared library; always install from the registry.
  124. ## 5. GSAP essentials (custom animation)
  125. Always in React via `useGSAP` with a `scope` — never raw `useEffect`:
  126. ```jsx
  127. 'use client';
  128. import { useRef } from 'react';
  129. import gsap from 'gsap';
  130. import { ScrollTrigger } from 'gsap/ScrollTrigger';
  131. import { useGSAP } from '@gsap/react';
  132. gsap.registerPlugin(ScrollTrigger, useGSAP);
  133. export default function Story() {
  134. const root = useRef(null);
  135. useGSAP(() => {
  136. const tl = gsap.timeline({
  137. scrollTrigger: { trigger: root.current, start: 'top top', end: '+=150%', scrub: 1, pin: true },
  138. });
  139. tl.from('.line', { yPercent: 100, autoAlpha: 0, stagger: 0.15 })
  140. .to('.image', { scale: 1.15 }, '<');
  141. }, { scope: root });
  142. return <section ref={root}>…</section>;
  143. }
  144. ```
  145. Core patterns (details + responsive `matchMedia`, batching, FOUC, checklist in `references/gsap.md`):
  146. - Timelines for anything with >1 element; `ScrollTrigger.batch()` for repeated cards.
  147. - `scrub` for scroll-linked motion (with Lenis, `scrub: true` is already smooth; `scrub: 1` adds extra lag).
  148. - `pin: true` works with Lenis on native scroll — no `pinType` hacks needed when Lenis uses `root`.
  149. - Horizontal scroll section: pin the wrapper, tween the track's `x` to `-(track.scrollWidth - innerWidth)`, `scrub: true`, `invalidateOnRefresh: true`. In RTL, reverse the direction (see `references/rtl-arabic.md` §6).
  150. - Wrap decorative blocks in `gsap.matchMedia()` so reduced-motion users get the substitute (`references/accessibility-motion.md` §4).
  151. ## 6. Lenis essentials (detail in `references/lenis.md`)
  152. - Modal / mobile menu open → `lenis.stop()`; close → `lenis.start()` (get instance with `useLenis()`).
  153. - Any inner scrollable element (dropdown list, modal body, chat, code block) → add `data-lenis-prevent`.
  154. - Nav links → `anchors: true` (already in the provider) or `lenis.scrollTo('#id', { offset: -headerHeight })`. The offset keeps the target out from under a sticky header.
  155. - Feel: `lerp` 0.08 = luxurious/heavy, 0.1 = default, 0.12–0.15 = snappy. Pick one per site and keep it.
  156. - Section snapping → `lenis/snap` (CSS `scroll-snap` does NOT work with Lenis).
  157. - Leave `syncTouch` off — native touch scrolling already feels right on phones.
  158. - Keep `respectReducedMotion: true` (the default) and do not override it.
  159. ## 7. Performance & accessibility (non-negotiable)
  160. Full rules, durations, contrast and touch-target tables: `references/accessibility-motion.md`. The short version:
  161. - Target **WCAG 2.2 AA**. Contrast 4.5:1 for body text, 3:1 for UI and focus rings. Touch targets at least 24×24 px.
  162. - Animate only `transform` / `opacity` (`x`, `y`, `scale`, `rotation`, `autoAlpha`).
  163. - One Lenis instance, one loop. No `autoRaf` + ticker double-driving.
  164. - Lazy-load heavy WebGL React Bits backgrounds; cap at one or two per page; pause when off-screen.
  165. - Motion durations: 50–150 ms for feedback, 200–300 ms for entering UI, under 500 ms for any non-navigation microinteraction. Shorter on mobile.
  166. - No flashing above 3 times per second. Any loop longer than 5 seconds that moves, blinks or scrolls needs a pause control.
  167. - Reduced motion: keep Lenis's default; wrap decorative GSAP in `gsap.matchMedia().add('(prefers-reduced-motion: no-preference)', …)` and give reduced-motion users a substitute. Content stays visible in both modes.
  168. - Focus: never remove the outline without a visible replacement; use `:focus-visible`. Modals trap focus and return it on close.
  169. - Call `ScrollTrigger.refresh()` after layout changes (images, accordions, tabs, injected content).
  170. - Test on a real phone and in Safari (Lenis is capped at 60fps there).
  171. ## 7.5 Forms and states
  172. Every form, booking flow, and data-driven list needs labels wired to errors and all five states (default, loading, empty, error, success). Details, the ARIA pattern, and backend notes: `references/forms-and-states.md`.
  173. ## 7.6 React and Next.js performance (Vercel rules)
  174. Source: `vercel-labs/agent-skills`, skill `react-best-practices` (author vercel, v1.0.0, MIT). 72 rules in 8 categories, ordered by impact. Apply when writing, reviewing, or refactoring React/Next.js code. Work from the top category down.
  175. | Priority | Category | Impact | Prefix |
  176. |---|---|---|---|
  177. | 1 | Eliminating Waterfalls | CRITICAL | `async-` |
  178. | 2 | Bundle Size Optimization | CRITICAL | `bundle-` |
  179. | 3 | Server-Side Performance | HIGH | `server-` |
  180. | 4 | Client-Side Data Fetching | MEDIUM-HIGH | `client-` |
  181. | 5 | Re-render Optimization | MEDIUM | `rerender-` |
  182. | 6 | Rendering Performance | MEDIUM | `rendering-` |
  183. | 7 | JavaScript Performance | LOW-MEDIUM | `js-` |
  184. | 8 | Advanced Patterns | LOW | `advanced-` |
  185. Default rules to apply:
  186. - Waterfalls: `async-parallel` (Promise.all for independent work), `async-defer-await` (await only in the branch that uses the value), `async-suspense-boundaries` (stream with Suspense).
  187. - Bundle: `bundle-barrel-imports` (import directly, no barrel files), `bundle-dynamic-imports` (next/dynamic for heavy components), `bundle-defer-third-party` (load analytics after hydration).
  188. - Server: `server-cache-react` (React.cache for per-request dedup), `server-serialization` (pass only needed fields to client components), `server-parallel-fetching`, `server-after-nonblocking` (after() for non-blocking work).
  189. - Client: `client-swr-dedup`, `client-passive-event-listeners` for scroll.
  190. - Re-render: `rerender-derived-state-no-effect` (derive during render, not in effects), `rerender-functional-setstate`, `rerender-no-inline-components`, `rerender-transitions`, `rerender-lazy-state-init`.
  191. - Rendering: `rendering-content-visibility` (long lists), `rendering-conditional-render` (ternary, not && for conditionals), `rendering-hoist-jsx` (static JSX outside components).
  192. - JavaScript: `js-index-maps` and `js-set-map-lookups` for repeated lookups, `js-tosorted-immutable`.
  193. Full before/after code lives in the upstream `rules/<name>.md` files; fetch the one you need before applying it. These rules never override §0 (golden rule) or the accessibility and motion rules: if a performance rule would change the design or break reduced motion, suggest it in one line and wait.
  194. ## 7.7 Postgres and Supabase (database work)
  195. Source: `supabase/agent-skills`, skill `supabase-postgres-best-practices` (author supabase, v1.1.1, MIT). Load before any change to a Postgres database: tables, column types, migrations, RLS policies, indexes, functions, triggers, queues, or slow queries. The rules apply to any Postgres, not only Supabase.
  196. Categories, in priority order: Query Performance (`query-`, CRITICAL), Connection Management (`conn-`, CRITICAL), Security & RLS (`security-`, CRITICAL), Schema Design (`schema-`, HIGH), Concurrency & Locking (`lock-`, MEDIUM-HIGH), Data Access Patterns (`data-`, MEDIUM), Monitoring (`monitor-`, LOW-MEDIUM), Advanced Features (`advanced-`, LOW).
  197. Default rules to apply:
  198. - Schema: `schema-data-types` (choose proper types), `schema-primary-keys` (pick a PK strategy), `schema-foreign-key-indexes` (index every FK column), `schema-lowercase-identifiers`, `schema-constraints`.
  199. - Security: `security-rls-basics` (enable RLS on every multi-tenant table), `security-rls-performance` (write policies that use indexes), `security-privileges`.
  200. - Queries: `query-missing-indexes`, `query-composite-indexes`, `query-partial-indexes`, `query-covering-indexes`.
  201. - Connections: `conn-pooling` (pool for all apps), `conn-limits`, `conn-prepared-statements`.
  202. - Data access: `data-pagination` (cursor pagination, not OFFSET), `data-n-plus-one`, `data-batch-inserts`, `data-upsert`.
  203. - Locking: `lock-short-transactions`, `lock-skip-locked`, `lock-deadlock-prevention`.
  204. - Diagnosis: `monitor-explain-analyze`, `monitor-pg-stat-statements`.
  205. Full SQL before/after examples live in the upstream `references/<rule>.md` files; fetch the one you need before applying it.
  206. Safety: destructive or irreversible SQL (DROP, TRUNCATE, type change on live data, mass UPDATE or DELETE) waits for an explicit yes. Show the statement and its effect first.
  207. ## 7.8 Testing local web apps (Playwright)
  208. Source: `anthropics/skills`, skill `webapp-testing` (license in its LICENSE.txt). Use to verify frontend behavior, debug UI, capture screenshots, or read browser console logs of a local web app.
  209. - Write native Python Playwright scripts with `sync_playwright()` and headless chromium.
  210. - Static HTML: read the file for selectors, then script. Dynamic app: check whether the server is running. If not, run `python scripts/with_server.py --help` and let it manage server lifecycle (one or several servers).
  211. - Always `page.wait_for_load_state('networkidle')` before inspecting the DOM. Inspecting earlier gives wrong selectors on dynamic apps.
  212. - Reconnaissance first: screenshot or `page.content()`, pick selectors (`text=`, `role=`, IDs), then act.
  213. - Run helper scripts as black boxes. Read their source only if `--help` and a plain run fail.
  214. - Close the browser when done. Patterns: `examples/element_discovery.py`, `examples/static_html_automation.py`, `examples/console_logging.py`.
  215. The upstream `scripts/` and `examples/` files are not bundled here; fetch them from the source repo when needed. Test runs use the user's local app only; never run them against a production URL.
  216. ## 8. Pre-ship checklist
  217. - [ ] Intake questionnaire done and Project Brief approved before coding (language, direction, accessibility target, forms backend, analytics)
  218. - [ ] Arabic/RTL handled if selected: `lang` + `dir` on `<html>`, logical CSS properties, `dirSign` for horizontal GSAP moves, word-level text splitting, real Arabic copy (`references/rtl-arabic.md`)
  219. - [ ] `SmoothScroll` provider mounted once at root; CSS `lenis/dist/lenis.css` imported
  220. - [ ] `autoRaf: false` + GSAP ticker driving Lenis + `lenis.on('scroll', ScrollTrigger.update)`
  221. - [ ] No ScrollSmoother, no second smooth-scroll lib, no CSS `scroll-behavior: smooth` on `html`
  222. - [ ] Every GSAP block in React uses `useGSAP` with `scope`; `'use client'` where needed
  223. - [ ] Inner scrollable areas have `data-lenis-prevent`; modals call `lenis.stop()/start()` and trap focus
  224. - [ ] React Bits props tuned to the site's colors/fonts; heavy backgrounds lazy-loaded and paused off-screen
  225. - [ ] WCAG 2.2 AA: contrast, focus ring, touch targets, alt text, heading order, keyboard-only pass
  226. - [ ] Reduced motion handled for all transform-based motion; no flashing above 3/s; loops over 5s have pause
  227. - [ ] Forms labeled, errors linked with `aria-describedby`, five states built (`references/forms-and-states.md`)
  228. - [ ] Quality bar passed: no default indigo, no emoji icons, no invented numbers, no lorem ipsum (`references/quality-bar.md`)
  229. - [ ] Third-party services chosen from `references/free-services.md` with current limits verified and noted in the brief
  230. - [ ] Design direction chosen from `references/design-styles.md` (if no client design) and differs from the last three sites on at least four axes; direction named in the Brief
  231. - [ ] Nothing redesigned or added beyond what was requested (§0)
  232. - [ ] Visual choices follow the brief, not the defaults listed in §0.9; design plan reviewed before code
  233. - [ ] React/Next.js code checked against §7.6: no request waterfalls, no barrel imports, no state derived in effects
  234. - [ ] Database changes checked against §7.7: RLS on multi-tenant tables, FK indexes, cursor pagination, no unconfirmed destructive SQL
  235. - [ ] Local web app tested with §7.8 (Playwright, networkidle wait, screenshot of result)
  236. - [ ] Route changes reset scroll (Next.js `ScrollToTopOnRoute`)
  237. - [ ] Tested on mobile + Safari; reduced-motion and keyboard-only paths checked
  238. ## Files in this skill
  239. - `references/intake-questionnaire.md` — the pre-build questionnaire: rules, interactive + code-block formats, question bank, Project Brief template
  240. - `references/visual-references.md` — Prompt Motion as a motion reference library: when to use it, browsing, video→web implementation map, motion-spec template
  241. - `references/rtl-arabic.md` — Arabic and RTL build guide: document setup, logical properties, Tailwind utilities, bidi, mirroring rules, GSAP in RTL, Arabic typography, forms
  242. - `references/accessibility-motion.md` — WCAG 2.2 AA target, motion durations and easing, reduced motion, flashing and looping rules, contrast, touch targets, focus
  243. - `references/forms-and-states.md` — form wiring (labels, errors, focus), validation rules, backends, and the five required states
  244. - `references/quality-bar.md` — checks against generic output (default accent, emoji icons, invented metrics, filler copy) and where character should come from
  245. - `references/free-services.md` — free and low-cost fonts, form backends, analytics, hosting/CDN, image services, with a verify-before-recommending rule
  246. - `references/gsap.md` — full GSAP guide (React integration, timelines, ScrollTrigger, matchMedia, FOUC, performance, defaults)
  247. - `references/lenis.md` — full Lenis guide (settings table, methods, nested scroll, snap, troubleshooting)
  248. - `references/react-bits-catalog.md` — all 218 React Bits components by category with description and deps
  249. - `assets/SmoothScroll.jsx` — React/Next.js global Lenis + GSAP provider
  250. - `assets/ScrollToTopOnRoute.jsx` — Next.js route-change scroll reset
  251. - `references/design-styles.md` — 13 distinct design directions with fit guide, variety axes, style log and variety check
  252. - `assets/vanilla-setup.js` — non-React setup
README.md · README · 5 lines
  1. # promptory-web-builder
  2. Claude skill: professional, accessible web builds (GSAP, Lenis, React Bits, 13 design directions, distinctive typography, React/Next.js performance rules, Supabase/Postgres practices, Playwright testing).
  3. See SKILL.md.

Ratings and comments

Sign in to rate this skill.

Sign in

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