Skip to content
Skills Library
Design & UX · Building & coding

awwwards-section-loop

/awwwards-section-loop

Use when recreating or rebuilding a multi-section page from a reference site — build section by section instead of all at once. Teaches the loop map (analyze_page_structure bands → capture_component per section → build → section gate from captured geometry and screenshots → lock → next), selector fallback rules learned from real captures, when a page must be treated as one unit (shared WebGL canvas), and the lock-before-next discipline that stops compounding drift. Pairs with awwwards-motion-study (motion recipe per section) and verify_build (aggregate evidence, not a per-section score).

Licence
MIT
Last repository change
11.11.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
3
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 11.11.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Use when recreating or rebuilding a multi-section page from a reference site — build section by section instead of all at once. Teaches the loop map (analyze_page_structure bands → capture_component per section → build → section gate from captured geometry and screenshots → lock → next), selector fallback rules learned from real captures, when a page must be treated as one unit (shared WebGL canvas), and the lock-before-next discipline that stops compounding drift. Pairs with awwwards-motion-study (motion recipe per section) and verify_build (aggregate evidence, not a per-section score).

Original author description

Use when recreating or rebuilding a multi-section page from a reference site — build section by section instead of all at once. Teaches the loop map (analyze_page_structure bands → capture_component per section → build → section gate from captured geometry and screenshots → lock → next), selector fallback rules learned from real captures, when a page must be treated as one unit (shared WebGL canvas), and the lock-before-next discipline that stops compounding drift. Pairs with awwwards-motion-study (motion recipe per section) and verify_build (aggregate evidence, not a per-section score).

How it works

  1. The loop
  2. Failure modes this skill prevents
  3. Companion tools
Original SKILL.md headings · 241 lines, 1,973 words
SKILL.md preview
---
name: awwwards-section-loop
description: Use when recreating or rebuilding a multi-section page from a reference site — build section by section instead of all at once. Teaches the loop map (analyze_page_structure bands → capture_component per section → build → section gate from captured geometry and screenshots → lock → next), selector fallback rules learned from real captures, when a page must be treated as one unit (shared WebGL canvas), and the lock-before-next discipline that stops compounding drift. Pairs with awwwards-motion-study (motion recipe per section) and verify_build (aggregate evidence, not a per-section score).
---

# Awwwards Section Loop — build section by section, verify each, lock it

Building a whole page in one pass loses: attention splits across eight
sections, an early mistake silently propagates into every later one, and
feedback arrives only when everything is finished — too late to trace the
drift to the decision that caused it. The section loop fixes all three:
**one section gets full attention; each section is verified and locked
before the next starts; drift is caught where it began.**

The tools to run this loop already exist. This skill is the order to run
them in, and the judgment calls the tool outputs don't make for you.

> **Profile note:** this skill's tools are `analyze_page_structure`,
> `capture_component`, `analyze_stack`, `capture_pose_3d`,
> `analyze_scroll_map`, `analyze_hover_census`, `audit_url`, `analyze_bundle`,
> `build_gsap_stub` and retained `build_project` / `verify_build`. Examples
> below use 1.x names (default `full`). On `AWWWARDS_MCP_PROFILE=v2`, use
> `inspect_page {request:{kind:"structure", url}}`,
> `capture_page {request:{kind:"component", url}}`,
> `inspect_page {request:{kind:"stack", url}}`,
> `capture_page {request:{kind:"pose", url}}`,
> `analyze_motion {request:{kind:"scroll", url}}`,
> `analyze_motion {request:{kind:"hover", url}}`,
> `audit_page {request:{kind:"performance", url, compact:true}}`,
> `audit_page {request:{kind:"bundle", url}}` and
> `build_motion {request:{kind:"gsap_stub", scrollCensus}}`; `build_project`
> and `verify_build` stay flat. Feed `build_motion` a `compact:false` scroll
> census. Full mapping: [v2-routing.md](v2-routing.md).

## The loop

```
PLAN          analyze_page_structure(reference)   → band map = section plan
FOR EACH      capture_component(section selector) → section pack (recipe)
              build that section                  → in your output, fully
              gate that section                   → geometry + screenshots + checks
              iterate until every check passes    → then LOCK it
NEXT SECTION  (do not touch locked sections again)
FINALLY       whole-page verify_build             → aggregate + coherence pass
```

### Step 0 — Plan from the band map

`analyze_stack` first (one call): the site's framework, CSS framework, and
marker libs. A Webflow or WordPress source means conventions you re-skin;
a Next source means you can mirror component shapes. Then
`analyze_page_structure` returns ordered bands with `top`, `height`,
`bg`, and a text sniff. Treat the band list as the build order:

- **Small count, sane heights** (≤ ~3,000 px each) → bands map 1:1 to
  build sections.
- **One giant band** (5,000 px+) → the band collapsed multiple real
  sections (repeated `<section class="…">` siblings do this). Do not
  build it as one giant component. Drop to the raw page HTML and pick
  **explicit selectors** for the real sections (`.section`, `[role=…]`,
  `header`, `footer`, or `#id`s), one per logical section. Real-capture
  finding: a 20,631 px band held an entire main content area; the four
  real sections inside it captured fine by class.
- **Shared canvas / WebGL hero** spanning many bands → **the page does
  not slice.** Treat that canvas region as ONE unit: `capture_pose_3d`
  for canvas frames + synthesized camera guidance, rebuild as a single
  component, then loop normally for everything after it. For a Three.js
  scene, `capture_scene_3d` with `adapters:["three"]` adds only reachable
  nodes/cameras/lights; `build_scene_stub` recreates the supported primitive
  subset and exact captured camera matrix, while parent transforms are lost and
  controls are never recreated. For shader evidence, `adapters:["spector"]`
  captures one drawing frame with command counts and capped shader source — not
  arguments, state or raw capture. Slicing a shared-canvas page into
  per-section captures produces sections that each reference a canvas
  none of them own.

### Step 1 — Capture per section

`capture_component(selector)` per section, in band order. Selector
discipline (learned from real captures, in priority order):

1. Section class or id from the band/HTML (`.process`, `.pricing`,
   `.footer`) — most reliable.
2. `role` attributes (`[role="banner"]`, `[role="contentinfo"]`).
3. Tag names (`header`, `footer`, `nav`) — **last resort**: real sites
   frequently have no `<header>` element at all (a real capture of a
   Webflow site returned `selector not found: header` while `nav` and
   `.footer` worked).

If a selector misses, try the alternatives before shrinking the plan.
A failed capture with `selector not found` is a selector problem, not
a missing section.

### Step 2 — Build one section, completely

Build the section against its pack: layout from the pack's geometry,
tokens (fonts/colors/spacing) from its captured computed styles, motion
from the census (`analyze_scroll_map` + `analyze_hover_census` scoped to
the section, per awwwards-motion-study). Content is yours — structure,
motion, and tokens are what you're matching.

**Finish it.** A half-built section pollutes the next verify. No
placeholder blocks left "for later" inside a section you're about to
lock.

### Step 3 — Gate the section against its capture

Do not wait on `verify_build` for a per-section verdict. It compares the two
**whole pages** and returns one aggregate band score —
`bands: { score, matched, refOnly, buildOnly }` — not a score per band. It
cannot isolate section N, and running it after every section mostly measures
the sections you have not built yet.

Gate section N with evidence that is local to section N:

- **Geometry:** the band map (`analyze_page_structure`) gives the section's
  `offsetTop`, `height` and `background`; the section pack
  (`capture_component`) gives the root and child `rect` (`x`, `y`, `w`, `h`)
  plus computed styles. Measure the same nodes in your build (Playwright
  `getBoundingClientRect` / `evaluate`) and assert them within tolerance —
  e.g. section height ±2 %, child positions and column counts exact. This
  catches the 3×-height and collapsed-band bugs a whole-page average hides.
- **Screenshots:** capture the reference section and your build at the same
  viewport, pinned to the section center, and compare them side by side. A
  uniform page-fraction shot lands mid-transition and proves nothing.
- **Tokens and motion:** check the captured computed styles (fonts, colors,
  spacing) and the section-scoped census values (trigger, duration, easing,
  stagger) you built from.
- **Explicit checks:** write the pass conditions for this section before
  building it (height tolerance, columns, visible children, motion beats),
  then mark each pass/fail. "Looks close" is not a gate.

Only when every local check passes is section N locked. Use `verify_build` as
**aggregate evidence** after a few sections and at the end: its `bands.score`
shows whole-page similarity, `matched` / `refOnly` / `buildOnly` name which
band labels matched or are missing, and its motion score, `perf:` line
(`fps=… dropped=… longTasks=…`) and `anti-patterns:` count are page-level
evidence. If perf shows dropped frames, animation weight is the usual cause —
transitioning `filter: blur`, infinite loops, or animating layout properties.
Fix the prop, not the score. A good aggregate score never proves section N
locally; a local pass never proves the page is coherent.

**Why the section gate matters:** section-by-section without a gate is just
chunked guessing. Per-section geometry and screenshots turn "looks close" into
named numbers and a yes/no per section; `verify_build` then supplies a
page-level number without pretending to localize it.

### Step 4 — Lock before next

Locking = this section's markup/styles/motion are frozen. If a later
section reveals a problem that truly requires changing a locked section,
make the change **as an explicit re-open**: fix, re-run that section's
gate, re-lock. Never silently fudge a locked section while building another.

### Step 5 — Final coherence pass

After the last section locks: run whole-page `verify_build` as the
aggregate evidence pass — `bands.score` plus `matched` / `refOnly` /
`buildOnly`, the motion score, perf and anti-pattern lines. It does not
report per-band scores; use your per-section geometry and screenshots to
locate any section the aggregate comparison flags. Also run
`analyze_page_structure` once with `compare: "mobile"`: `mobileBands` +
`diff` (`bandsAdded`, `bandsRemoved`, `reordered`, `heightDelta`) name the
sections that only exist at 390×844 or changed order — a desktop-only
rebuild shows up here before the mobile smoke. You're now checking
cross-section things the per-section loop can't see: shared spacing
rhythm, consistent header behavior, scroll continuity, one easing family
across sections (or an intentional break). Fix coherence issues at the
page level (tokens, shared CSS), not by re-opening sections unless the
aggregate band comparison shows a regression — then use its
`refOnly`/`buildOnly` labels plus your own geometry to find the section.

### Step 6 — Convert only if the user asks

The single-file rebuild is a valid handoff. When the user asks for a project (or
picks a framework), convert: locked sections are exactly what `build_project
--target vite|astro|next` needs — the band split becomes components. If they also
want authored motion, add `--authored --motion census.json` and author per section
(see `motion-authoring`), keeping the same lock discipline: author section N,
re-run its section gate, lock, next. Whole-page desktop + 390 mobile parity last.

## Failure modes this skill prevents

| Failure | What you'd see | The rule that prevents it |
|---|---|---|
| Giant collapsed band built as one component | One "section" with 6 sub-layouts, all mediocre | Step 0 explicit-selector split |
| Selector miss treated as missing section | Whole region skipped in the rebuild | Step 1 alternatives ladder |
| Sliced shared-canvas page | Sections that each expect a canvas nobody renders | Step 0 one-unit rule |
| Placeholder left inside a "finished" section | Section gate never passes | Step 2 finish-it rule |
| Drift compounding through the page | Every section slightly worse than the last | Steps 3–4 gate+lock |
| Lock-fudging | Locked section regresses unnoticed | Step 4 explicit re-open |
| Per-section sections that don't rhyme | Page reads as stitched screenshots | Step 5 coherence pass |

## Companion tools

- `awwwards-motion-study` — the per-section motion recipe (record →
  inventory → build → re-record).
- `verify_build` — aggregate evidence (steps 3 and 5), **not** a per-section
  gate: one whole-page band score (`bands.score` + `matched`/`refOnly`/
  `buildOnly` labels) and a motion score, plus measured perf (fps, dropped
  frames, long tasks) and anti-pattern counts from instrumented live probes.
  Runs a real browser — expect ~2 min per call. For a shared WebGL canvas,
  opt-in `scene3d` replays a
  `capture_scene_3d` pack on the build canvas as a separate gate with its own
  status/verdict; it never upgrades the legacy band pass, unstable capture
  frames are rejected, and its build URL must resolve publicly (loopback is
  refused). It preflights both URLs before the legacy scans and makes zero
  requests when either is private; the deadline is the replayed checkpoint
  waits + 10 s headroom (floor 15 s, cap 45 s), and the canvas gets a per-run
  marker so duplicate or pre-marked decoys are refused.
- `audit_url compact:true` — quick perf and anti-pattern checks when you only
  need the summary, not the full evidence.
- `capture_pose_3d` - canvas frames + synthesized camera guidance for
  shared-canvas units (step 0); no camera transforms are recovered, and the
  generated stub dedupes same-index frame loads and discards stale decodes.
- `capture_scene_3d` + `build_scene_stub` - opt-in Three.js adapter for
  shared canvases: reachable globals only, with primitives, standard/basic
  materials and a perspective camera from its exact matrix reconstructed.
  Captured controls are never recreated and stay unresolved. Module-local
  scenes, parent transforms and unbound textures are lost, and `scene.json`
  frame references are basenames extracted from either Windows or POSIX paths.
- `capture_scene_3d` spector adapter - optional `spectorjs@0.9.33`; captures one
  WebGL frame with command counts/statuses and capped shader source. It needs a
  drawing frame, transfers no arguments/state/raw capture, and a missing package
  only degrades the adapter.
- `analyze_scroll_map` / `analyze_hover_census` - per-section motion
  census to build from. `analyze_scroll_map` rows now carry keyframe
  value-pairs and a site-level `gsapTriggers` list (numeric pixel
  start/end, live progress, tween vars) — build from measured values,
  not invented ones. Hover samples include animations captured DURING
  the hover (`activeAnims`), which is how event-driven tweens get seen.
- `build_gsap_stub` - turns the captured censuses into a runnable
  GSAP+ScrollTrigger stub (durations, easings, scrub/pin, synthesized
  camera guidance from `capture_pose_3d`, reduced-motion guard) - step 2's
  motion wiring, generated.
- `build_project` — build → convert → own the motion: `--target vite|astro|next`
  gives native structure (section components, shell, split CSS, ordered libs);
  `--authored --motion census.json` drops site logic and emits
  `motion.manifest.json` + per-section/page motion hooks to author against (pair
  with `motion-authoring`); always re-verify after conversion.
- `analyze_bundle` - mechanism recovery (step 2 escape hatch): when a
  section's effect can't be explained from the census evidence, grep the
  section site's script bundle for mechanism keywords; the censuses say
  WHAT animates, the bundle says HOW.
Files in this package (3)
  • LICENSE 1 KB
  • SKILL.md 14 KB
  • v2-routing.md 22 KB

Versions

The database has no other skills named awwwards-section-loop.

Database snapshot: 13.11.2026 · package version 83c8cfc84cd8 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100awwwards-motion-study
    Use when building a site whose reference has animation — before writing any motion code, and again when verifying a build. Teaches what to record from a live site (and what to skip), how to study the recordings frame-by-frame (video input or ffmpeg tile-per-element), how to turn…
  • 100awwwards-atlas
    Use when working with the experimental Atlas section/component evidence layer in awwwards-mcp 1.19+ - enabling AWWWARDS_MCP_ATLAS, importing or capturing Atlas evidence, searching sections/components, reading regions or status, exporting local evidence packs, or maintaining the…
  • 100jury
    Scores a site like an Awwwards jury from evidence alone (screenshots on desktop, throttled phone and reduced motion; LCP, CLS, FPS, axe, keyboard, SEO) across Design, Usability, Creativity, Content and developer areas, with a ranked fix list. Use for "jury", "score", "rate", "is…
  • 100gpt-taste
    High-motion Awwwards-style frontend direction using GSAP, editorial typography, dense bento composition, and cinematic section choreography. Use only when the user explicitly wants an experimental marketing page or portfolio; do not use for routine product UI, dashboards, or…
  • 100page-build
    Build a page end to end as HTML, push it to Figma as one frame per section, and publish an HTML preview. Use when the user asks to build or start a page or a section, "push to Figma", or "build the preview".
  • 87moodboard
    The page-level Moodboard in Web Anatomy. Build a section-by-section visual reference board for a whole page (homepage, landing page, money page): for every section, the current state captured large, the problems identified, a grid of benchmark screenshots with the practice each…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.