Content operations skills for AEM Edge Delivery Services: page auditing, SEO optimization, AI search (GEO), WCAG accessibility, bulk metadata, structured data, sitemap validation, and content diffing. Complements the EDS development skills with operational tooling for content teams.
90%
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
Diagnose and fix Core Web Vitals issues on AEM Edge Delivery Services pages using EDS-specific domain knowledge: the 100KB LCP budget, the Eager-Lazy-Delayed loading phases, block architecture, the createOptimizedPicture() function, and where the project's delayed phase lives (consented.js or delayed.js). Produces specific, implementable fixes with estimated impact projections, not generic performance advice.
This skill fetches external web pages for analysis. When fetching:
optel-interpreter first), non-EDS sites, or server-side TTFB/CDN issues.Before starting, create a checklist of all steps to track progress:
Fetch the page and collect baseline scores. On every curl, use --compressed: .aem.live sends scripts gzipped even when the request doesn't ask for it, so a grep on them without the flag finds nothing.
Record baseline CWV values, total page weight, request count, and TTFB. A large FCP-to-LCP gap suggests render-blocking resources between first paint and largest paint.
Identify the LCP element from measured data, not from page structure. Use Chrome DevTools (Performance panel → the LCP marker, or the Lighthouse "Largest Contentful Paint element" audit) or RUM field data. In EDS the LCP element is commonly the first image or a large <h1> in the first section, but confirm it rather than assuming. Once confirmed, fetch the HTML and examine that element in the first section (before the first --- divider).
Inventory every eager-phase resource and measure its compressed transfer size (from a Lighthouse report, or curl --compressed). Build the budget table: HTML document, /styles/styles.css, /scripts/aem.js, /scripts/scripts.js, first-section block CSS/JS, and LCP image. Anything else before LCP, a font included, is a finding. Grade the total against the 100KB budget (see references/cwv-eds-reference.md for grading scale). For a per-request byte table from Lighthouse and a CI check of the budget, use the performance-budget skill.
Use RUM field data to see real-user LCP for the page, and process it with Adobe's official @adobe/rum-distiller library (the same one the OpTel Explorer uses) rather than hand-parsing checkpoint events:
import { DataChunks, series, utils } from '@adobe/rum-distiller';
// The bundle API is path-based: https://bundles.aem.page/bundles/{domain}/{year}/{month}/{day}.
// The domain key is the ?domainkey= query parameter, not an Authorization header.
const resp = await fetch(
`https://bundles.aem.page/bundles/example.com/2026/06/28?domainkey=${RUM_DOMAIN_KEY}`,
);
const { rumBundles } = await resp.json();
// addCalculatedProps derives the cwvLCP/cwvCLS/cwvINP props that the series read.
rumBundles.forEach((b) => utils.addCalculatedProps(b));
const dc = new DataChunks();
dc.load([{ date: '2026-06-28', rumBundles }]);
dc.addSeries('lcp', series.lcp);
console.log(`p75 LCP: ${dc.totals.lcp.percentile(75)}ms`);Verify resources load in the correct phase:
Eager: Only first-section block CSS/JS. Check that below-fold blocks are not loading eagerly. Every <img> in the delivered HTML has loading="lazy", and that is not a defect: waitForFirstImage() in aem.js sets the first image of the first section to eager at runtime, unless it has already loaded (from cache). Report it only if the LCP image's request starts late in the waterfall, for example because a block replaced it.
Delayed: Read loadDelayed() in /scripts/scripts.js to see which file the project has. Since July 2026 the boilerplate imports scripts/consent-check.js, which imports scripts/consented.js once the visitor has consented, with no timer. Older projects import scripts/delayed.js after a 3-second timer. Verify all third-party scripts load from that file. Common violations: Google Tag Manager in <head> (~70KB, blocks render), analytics loaded synchronously, chat widgets loaded eagerly, consent banners in the eager phase.
Fonts: The boilerplate loads styles/fonts.css only after the first section is shown, and paints first with size-adjusted fallback fonts. A font requested before LCP (an @font-face in styles.css, or a preload in head.html) is a finding: move it to fonts.css. Never recommend preloading a font; aem.live calls that counterproductive.
Check whether images have explicit width and height:
curl -s "https://<domain>/<path>" | grep -oP '<img[^>]*>' | head -10Images without dimensions cause CLS. The createOptimizedPicture() function in aem.js does not set width/height attributes on the images it generates. Fix by adding the attributes in the block's decorate() function.
EDS automatically serves content images as responsive WebP through its <picture> pipeline (the ?width=…&format=webply&optimize=medium transform), regardless of the source format, so do not tell the agent to convert content images to WebP/AVIF or resize them by hand. The lever you actually control is the source image: an oversized original (e.g. 4000px wide) inflates the delivered derivatives. Check the delivered LCP image's transfer size in the network waterfall; if it is heavy, reduce the source image's intrinsic dimensions or crop it, not its format. Only images bundled in code (block icons/SVG) are optimized by you directly, so keep those small and prefer inline SVG. (EDS delivers WebP, not AVIF.)
EDS CLS comes from a predictable set of sources:
width/height from createOptimizedPicture().font-display: swap without size-adjust and ascent-override on the fallback @font-face.decorate(). Reserve space with CSS or make initial HTML match final layout.Look for long tasks (> 50ms), forced reflows, and slow event handlers (> 100ms). Common EDS offenders: carousel blocks recalculating all slide layouts, accordion/tab blocks triggering full reflows instead of CSS transitions, mega-menus injecting large DOM subtrees synchronously, and search blocks filtering on every keystroke without debouncing.
Measure LCP element render timing in a block's decorate() function:
// Measure LCP contribution from a block
export default async function decorate(block) {
const start = performance.now();
// ... block decoration logic ...
const elapsed = performance.now() - start;
if (elapsed > 50) {
console.warn(`[perf] ${block.dataset.blockName} decorate took ${elapsed.toFixed(1)}ms (budget: 50ms)`);
}
}Key fixes: debounce expensive handlers (150ms), batch DOM reads before writes to avoid forced reflows, use requestAnimationFrame for visual updates.
Inventory all external scripts from the HTML head and the delayed-phase file found in Step 3:
curl -s --compressed "https://<domain>/<path>" | grep -oP '<script[^>]*src="[^"]*"' | head -20
curl -s --compressed "https://<domain>/scripts/scripts.js" | grep -A4 'function loadDelayed'
curl -s --compressed "https://<domain>/scripts/consented.js" # or /scripts/delayed.js on older projectsClassify each script by current phase vs. correct phase. All third-party scripts belong in that delayed-phase file. aem.live's guideline is that the delayed phase starts at least three seconds after the LCP event; consented.js enforces no delay, so if the project needs one, add it in consent-check.js or consented.js, and start it from the LCP (a PerformanceObserver for largest-contentful-paint): a setTimeout at module load counts from when the module ran, not from LCP. Scripts in the eager phase add directly to the 100KB budget. If GTM re-injects scripts dynamically, configure GTM triggers to fire only after a 3-second delay.
For each issue, produce a specific fix with estimated impact:
| Issue | Metric | Current | Fix | Projected After |
|---|---|---|---|---|
| Hero image 180KB | LCP | 3.2s | Reduce source image dimensions / crop (EDS already serves WebP) | 2.1s |
| GTM in head | LCP | 3.2s | Move to consented.js (delayed.js on older projects) | 2.4s |
| Images missing dimensions | CLS | 0.18 | Add width/height to createOptimizedPicture | 0.03 |
| Font swap without size-adjust | CLS | 0.18 | Add size-adjust to fallback | 0.08 |
| Carousel forced reflow | INP | 310ms | Batch DOM reads/writes | 150ms |
See references/cwv-eds-reference.md for projection benchmarks (image format savings, reflow reduction estimates).
| Metric | Before | Target | Projected After | Status |
|---|---|---|---|---|
| LCP | X.Xs | < 2.5s | X.Xs | Fix/Monitor/Pass |
| CLS | X.XX | < 0.1 | X.XX | Fix/Monitor/Pass |
| INP | Xms | < 200ms | Xms | Fix/Monitor/Pass |
Ranked list: highest-impact fix first, with metric affected, estimated improvement, and effort.
width and height (the delivered HTML says lazy)loading="lazy"consented.js (or delayed.js on older projects)font-display: swap with size-adjust fallbacks.tessl-plugin
skills
accessibility-fix
bulk-metadata
content-audit
content-diff
cwv-optimizer
geo-rewrite
heading-optimizer
image-seo
internal-linking
link-rot-scanner
optel-interpreter
performance-budget
product-page-seo
query-index-optimizer
sitemap-audit
structured-data