Skills for building AEM Edge Delivery Services sites — site creation, block development, content modeling, code review, testing, and page import.
91%
Does it follow best practices?
Run evals on this skill
Adds up to 20 points to the overall score
Low
Low-risk findings worth noting
Reference for the Analyze phase. After segmenting the source page into sections, evaluate whether each section can be converted to a standalone EDS block (block-level) or must stay in the page template (page-level).
Block-level conversion means: each content section becomes an
independent EDS block with its own decorate() function, its own CSS
file, and its content authored in a DA block table. The block JS reads
authored rows and builds the source DOM structure (the "block-level
template"). Header and footer remain static fragments.
Page-level conversion means: the standard snowflake overlay — one
template with [data-slot] markers, one CSS file, DA doc with
slot-keyed rows, overlay engine merges at runtime.
Block-level is the right choice when the source page has all of:
If any section fails, that section uses page-level. If most sections fail, the whole page uses page-level.
Run these during the Analyze phase, after identifying the header/footer boundaries and the main content sections.
Look at the source DOM. For each content section between header and footer:
Pass — the section is:
<section> or <div> with a unique, descriptive class name<main> (or of <body> when <main> is absent)Fail — the section is:
<div> with no clear boundary<div class="flex flex-col gap-8">)
with no semantic identity<body> and the section content)How to check:
# Count direct children of <main> (or <body>)
# Each should be a clear section
document.querySelectorAll('main > *').length
# vs total section-like elements
document.querySelectorAll('section, [data-section]').lengthFor each section, check whether its CSS rules are self-contained.
Pass — all of:
.hero .xxx, .shop-categories .xxx)section.hero + section.cards { ... }):root custom properties) are cleanly global —
not section-specific variable names reused with different valuesFail — any of:
body { display: grid; grid-template-rows: ... }).card means different things in different sections):nth-child(3) > div > p)How to check:
# For each section class, count CSS rules that use it as a prefix
grep -c '\.sectionClass' styles.css
# Check for cross-section selectors
grep -E '\.[a-z-]+\s*\+\s*\.' styles.css # sibling combinators
grep -E 'body\s*>' styles.css # body-level layoutFor each section, check whether its authorable content (text, images, links) maps cleanly to DA block table rows.
Pass — the section contains:
<img>, <picture>) → image rows<a>, <button> with labels) → link rowsFail — the section contains:
Judgment call — these can go either way:
Check whether any JavaScript in the source creates dependencies between sections.
Pass — any of:
Fail — any of:
document.querySelector('.hero').nextElementSibling)How to check:
# Look for cross-section DOM queries
grep -n 'querySelector.*section\|closest.*section' script.js
# Look for global state patterns
grep -n 'window\.\|document\.body\.' script.jsCheck whether each section can render correctly without its siblings.
Pass — the section:
clip-path or overflow: hidden on a parent that
clips across section boundariesFail — the section:
background: transparent and relies on a page-level
background gradient that spans multiple sections::before/::after) that visually
extend into adjacent sectionsposition: absolute relative to a container that wraps
multiple sectionsHow to check (visual test): Render each section in isolation (wrap in a minimal HTML page with only global styles). If it looks correct alone, it passes. If it looks broken or incomplete, it fails.
After running all five checks on each content section:
| Result | Recommendation |
|---|---|
| All sections pass all 5 checks | Block-level conversion — each section becomes an EDS block |
| Most sections pass; 1-2 fail | Hybrid — passing sections become blocks; failing sections become static fragments (like header/footer) |
| Most sections fail | Page-level conversion — standard snowflake overlay |
| Utility-class CSS throughout (Tailwind, Bootstrap utilities) | Page-level — CSS extraction per-block is impractical |
| Complex JS coupling across sections | Page-level — block independence is impossible |
When a few sections fail, they can stay as static fragments or become "passthrough" sections in the template. The passing sections still become blocks. This is the most common real-world outcome — most pages have some sections that are block-friendly and some that aren't.
Example: a page with a clean hero, clean cards grid, clean CTA band, but a complex interactive product configurator in the middle. The configurator becomes a static fragment or a custom block with no DA authoring. Everything else is block-level.
Quick heuristics to assess feasibility before running the full five checks:
Strong signals for block-level:
.hero__title,
.hero .title)<section> elements with semantic class names:root with a clear naming systemStrong signals for page-level:
<section> elements — content is a flat list of divsAmbiguous — need the full five checks:
This analysis happens in Phase 2 (Analyze), after capturing the
source and identifying header/footer boundaries. The output is a
decisions.json field:
{
"conversionLevel": "block-level" | "page-level" | "hybrid",
"sections": [
{
"name": "hero",
"level": "block",
"checks": {
"structure": "pass",
"cssScope": "pass",
"contentModel": "pass",
"jsIndependence": "pass",
"visualIndependence": "pass"
}
},
{
"name": "configurator",
"level": "fragment",
"checks": {
"structure": "pass",
"cssScope": "pass",
"contentModel": "fail — complex multi-step form",
"jsIndependence": "fail — reads global filter state",
"visualIndependence": "pass"
},
"failReason": "Interactive widget with cross-section state"
}
]
}Phase 3 (Generate) reads conversionLevel and follows the
corresponding path:
block-level: generate block JS/CSS per section + DA block tablespage-level: generate template + slots + DA slot-keyed rows
(standard snowflake)hybrid: mix of both — blocks for passing sections, template
sections for failing onesSource: AI-generated (Stardust), single-page, 9 sections.
| Section | Structure | CSS scope | Content model | JS | Visual | Level |
|---|---|---|---|---|---|---|
| promo-strip | ✅ <header class="promo-strip"> | ✅ .promo-strip .xxx | ✅ text + link | ✅ none | ✅ own bg | fragment (header) |
| site-header | ✅ <header class="site-header"> | ✅ .site-header .xxx | ✅ logo + nav links | ✅ none | ✅ own bg | fragment (header) |
| hero | ✅ <section class="hero"> | ✅ .hero .xxx | ✅ image, text, links | ✅ none | ✅ own bg + photo | block |
| shop-categories | ✅ <section class="shop-categories"> | ✅ .shop-categories .xxx | ✅ heading + 5 card rows | ✅ none | ✅ own bg | block |
| subscription | ✅ <section class="subscription-card-on-bay"> | ✅ scoped | ✅ text + image + link | ✅ none | ✅ own bg | block |
| locations-finder | ✅ <section class="locations-finder"> | ✅ scoped | ✅ text + form (structural) | ✅ none | ✅ own bg | block |
| featured-coffee | ✅ <section class="featured-coffee"> | ✅ scoped | ✅ image + text + link | ✅ none | ✅ own bg (porcelain) | block |
| rewards-cta-band | ✅ <section class="rewards-cta-band"> | ✅ scoped | ✅ text + link | ✅ none | ✅ own bg | block |
| site-footer | ✅ <footer class="site-footer"> | ✅ .site-footer .xxx | ✅ columns + links | ✅ none | ✅ own bg | fragment (footer) |
Result: all sections pass → block-level conversion.
.tessl-plugin
skills
aem-block-library
aem-cli
aem-layout-view
block-collection-and-party
brand-setup
references
building-blocks
code-review
content-driven-development
references
content-modeling
create-site
da-auth
figma-to-content
find-test-content
generate-import-html
identify-page-structure
migrate-header
page-decomposition
page-import
preview-import
scrape-webpage
slicc-handoff
snowflake
assets
substrate
substrate-milo
examples
knowledge
scripts
testing-blocks
ue-component-model