HelpBlogCommunity🍌 PromptsNEWRulesWorkflowsAgent SkillsMCPsAdvertise
ENEnglishESEspaΓ±olZHδΈ­ζ–‡JAζ—₯本θͺžDEDeutschPTPortuguΓͺsRUРусский
Back to Seo

Core Web Vitals Optimization

performanceseoweb-vitalsfrontendoptimization
β˜… 4.7 (203)⭐ 28.1kπŸ“„ MITπŸ•’ 2026-06-16Source β†—

Install this skill

npx skills add davila7/claude-code-templates

Works across Claude Code, Cursor, Codex, Copilot & Antigravity

What this skill does

  • β€’Identifies LCP elements and suggests preloading optimizations
  • β€’Detects main-thread blocking tasks that contribute to high INP
  • β€’Provides refactoring strategies for chunking long synchronous tasks
  • β€’Suggests techniques to defer non-essential third-party script execution
  • β€’Analyzes CSS and font rendering paths to minimize layout shifts

When to use it

  • βœ“When your site fails the Google Search Console 'Core Web Vitals' report
  • βœ“When users report input delay or sluggish page responsiveness
  • βœ“During pre-deployment performance audits
  • βœ“When investigating unexplained layout jumps after page loads

When not to use it

  • βœ•For debugging purely functional application logic errors
  • βœ•When performance issues are clearly caused by backend database queries rather than frontend rendering
  • βœ•On static sites without complex client-side interactivity

How to invoke it

Example prompts that trigger this skill:

  • β€œOptimize Core Web Vitals”
  • β€œWhy is my LCP score so high and how can I fix it?”
  • β€œReduce interaction delay to improve my INP”
  • β€œIdentify and fix layout shifts on my landing page”
  • β€œPerform a page experience audit and provide optimization steps”

Example workflow

  1. Run performance diagnostic to log current LCP and INP metrics
  2. Use the PerformanceObserver API to isolate the largest render element
  3. Review identified render-blocking CSS and apply inline critical style fixes
  4. Refactor heavy JavaScript event handlers by implementing task yielding
  5. Verify improvements by re-measuring interaction and paint times

Pitfalls & limitations

  • !Inlining too much CSS can exceed the 14KB threshold and slow initial packet transmission
  • !Aggressive lazy loading can trigger new layout shifts if dimensions aren't reserved
  • !Metrics vary significantly based on user device hardware and network conditions

FAQ

What is the most important metric?
All three contribute to your score, but LCP is typically the easiest to improve via image and CSS optimization, while INP often requires deeper JavaScript refactoring.
Does this fix backend performance?
No, it focuses on frontend rendering and browser-side execution. If your server response time (TTFB) is high, it will flag that as an issue but you will need to optimize your backend separately.
How does it handle third-party scripts?
It helps identify which scripts are blocking the main thread and suggests strategies like deferring, async loading, or moving execution to a worker thread.

How it compares

Unlike a generic prompt that might return vague performance tips, this skill leverages specific diagnostic patterns and code-splitting templates to target measurable metric thresholds.

Source & trust

⭐ 28k starsπŸ“„ MITπŸ•’ Updated 2026-06-16πŸ›‘ network

From the source: β€œ# Core Web Vitals optimization Targeted optimization for the three Core Web Vitals metrics that affect Google Search ranking and user experience. ## The three metrics | Metric | Measures | Good | Needs work | Poor | |--------|----------|------|------------|------| | **LCP** | Loading | ≀ 2.5s | 2.5s…”

View the full SKILL.md source

# Core Web Vitals optimization

Targeted optimization for the three Core Web Vitals metrics that affect Google Search ranking and user experience.

## The three metrics

| Metric | Measures | Good | Needs work | Poor |
|--------|----------|------|------------|------|
| **LCP** | Loading | ≀ 2.5s | 2.5s – 4s | > 4s |
| **INP** | Interactivity | ≀ 200ms | 200ms – 500ms | > 500ms |
| **CLS** | Visual Stability | ≀ 0.1 | 0.1 – 0.25 | > 0.25 |

Google measures at the **75th percentile** β€” 75% of page visits must meet "Good" thresholds.

---

## LCP: Largest Contentful Paint

LCP measures when the largest visible content element renders. Usually this is:
- Hero image or video
- Large text block
- Background image
- `<svg>` element

### Common LCP issues

**1. Slow server response (TTFB > 800ms)**
```
Fix: CDN, caching, optimized backend, edge rendering
```

**2. Render-blocking resources**
```html
<!-- ❌ Blocks rendering -->
<link rel="stylesheet" href="/all-styles.css">

<!-- βœ… Critical CSS inlined, rest deferred -->
<style>/* Critical above-fold CSS */</style>
<link rel="preload" href="/styles.css" as="style" 
      onload="this.onload=null;this.rel='stylesheet'">
```

**3. Slow resource load times**
```html
<!-- ❌ No hints, discovered late -->
<img src="/hero.jpg" alt="Hero">

<!-- βœ… Preloaded with high priority -->
<link rel="preload" href="/hero.webp" as="image" fetchpriority="high">
<img src="/hero.webp" alt="Hero" fetchpriority="high">
```

**4. Client-side rendering delays**
```javascript
// ❌ Content loads after JavaScript
useEffect(() => {
  fetch('/api/hero-text').then(r => r.json()).then(setHeroText);
}, []);

// βœ… Server-side or static rendering
// Use SSR, SSG, or streaming to send HTML with content
export async function getServerSideProps() {
  const heroText = await fetchHeroText();
  return { props: { heroText } };
}
```

### LCP optimization checklist

```markdown
- [ ] TTFB < 800ms (use CDN, edge caching)
- [ ] LCP image preloaded with fetchpriority="high"
- [ ] LCP image optimized (WebP/AVIF, correct size)
- [ ] Critical CSS inlined (< 14KB)
- [ ] No render-blocking JavaScript in <head>
- [ ] Fonts don't block text rendering (font-display: swap)
- [ ] LCP element in initial HTML (not JS-rendered)
```

### LCP element identification
```javascript
// Find your LCP element
new PerformanceObserver((list) => {
  const entries = list.getEntries();
  const lastEntry = entries[entries.length - 1];
  console.log('LCP element:', lastEntry.element);
  console.log('LCP time:', lastEntry.startTime);
}).observe({ type: 'largest-contentful-paint', buffered: true });
```

---

## INP: Interaction to Next Paint

INP measures responsiveness across ALL interactions (clicks, taps, key presses) during a page visit. It reports the worst interaction (at 98th percentile for high-traffic pages).

### INP breakdown

Total INP = **Input Delay** + **Processing Time** + **Presentation Delay**

| Phase | Target | Optimization |
|-------|--------|--------------|
| Input Delay | < 50ms | Reduce main thread blocking |
| Processing | < 100ms | Optimize event handlers |
| Presentation | < 50ms | Minimize rendering work |

### Common INP issues

**1. Long tasks blocking main thread**
```javascript
// ❌ Long synchronous task
function processLargeArray(items) {
  items.forEach(item => expensiveOperation(item));
}

// βœ… Break into chunks with yielding
async function processLargeArray(items) {
  const CHUNK_SIZE = 100;
  for (let i = 0; i < items.length; i += CHUNK_SIZE) {
    const chunk = items.slice(i, i + CHUNK_SIZE);
    chunk.forEach(item => expensiveOperation(item));
    
    // Yield to main thread
    await new Promise(r => setTimeout(r, 0));
    // Or use scheduler.yield() when available
  }
}
```

**2. Heavy event handlers**
```javascript
// ❌ All work in handler
button.addEventListener('click', () => {
  // Heavy computation
  const result = calculateComplexThing();
  // DOM updates
  updateUI(result);
  // Analytics
  trackEvent('click');
});

// βœ… Prioritize visual feedback
button.addEventListener('click', () => {
  // Immediate visual feedback
  button.classList.add('loading');
  
  // Defer non-critical work
  requestAnimationFrame(() => {
    const result = calculateComplexThing();
    updateUI(result);
  });
  
  // Use requestIdleCallback for analytics
  requestIdleCallback(() => trackEvent('click'));
});
```

**3. Third-party scripts**
```javascript
// ❌ Eagerly loaded, blocks interactions
<script src="https://heavy-widget.com/widget.js"></script>

// βœ… Lazy loaded on interaction or visibility
const loadWidget = () => {
  import('https://heavy-widget.com/widget.js')
    .then(widget => widget.init());
};
button.addEventListener('click', loadWidget, { once: true });
```

**4. Excessive re-renders (React/Vue)**
```javascript
// ❌ Re-renders entire tree
function App() {
  const [count, setCount] = useState(0);
  return (
    <div>
      <Counter count={count} />
      <ExpensiveComponent /> {/* Re-renders on every count change */}
    </div>
  );
}

// βœ… Memoized expensive components
const MemoizedExpensive = React.memo(ExpensiveComponent);

function App() {
  const [count, setCount] = useState(0);
  return (
    <div>
      <Counter count={count} />
      <MemoizedExpensive />
    </div>
  );
}
```

### INP optimization checklist

```markdown
- [ ] No tasks > 50ms on main thread
- [ ] Event handlers complete quickly (< 100ms)
- [ ] Visual feedback provided immediately
- [ ] Heavy work deferred with requestIdleCallback
- [ ] Third-party scripts don't block interactions
- [ ] Debounced input handlers where appropriate
- [ ] Web Workers for CPU-intensive operations
```

### INP debugging
```javascript
// Identify slow interactions
new PerformanceObserver((list) => {
  for (const entry of list.getEntries()) {
    if (entry.duration > 200) {
      console.warn('Slow interaction:', {
        type: entry.name,
        duration: entry.duration,
        processingStart: entry.processingStart,
        processingEnd: entry.processingEnd,
        target: entry.target
      });
    }
  }
}).observe({ type: 'event', buffered: true, durationThreshold: 16 });
```

---

## CLS: Cumulative Layout Shift

CLS measures unexpected layout shifts. A shift occurs when a visible element changes position between frames without user interaction.

**CLS Formula:** `impact fraction Γ— distance fraction`

### Common CLS causes

**1. Images without dimensions**
```html
<!-- ❌ Causes layout shift when loaded -->
<img src="photo.jpg" alt="Photo">

<!-- βœ… Space reserved -->
<img src="photo.jpg" alt="Photo" width="800" height="600">

<!-- βœ… Or use aspect-ratio -->
<img src="photo.jpg" alt="Photo" style="aspect-ratio: 4/3; width: 100%;">
```

**2. Ads, embeds, and iframes**
```html
<!-- ❌ Unknown size until loaded -->
<iframe src="https://ad-network.com/ad"></iframe>

<!-- βœ… Reserve space with min-height -->
<div style="min-height: 250px;">
  <iframe src="https://ad-network.com/ad" height="250"></iframe>
</div>

<!-- βœ… Or use aspect-ratio container -->
<div style="aspect-ratio: 16/9;">
  <iframe src="https://youtube.com/embed/..." 
          style="width: 100%; height: 100%;"></iframe>
</div>
```

**3. Dynamically injected content**
```javascript
// ❌ Inserts content above viewport
notifications.prepend(newNotification);

// βœ… Insert below viewport or use transform
const insertBelow = viewport.bottom < newNotification.top;
if (insertBelow) {
  notifications.prepend(newNotification);
} else {
  // Animate in without shifting
  newNotification.style.transform = 'translateY(-100%)';
  notifications.prepend(newNotification);
  requestAnimationFrame(() => {
    newNotification.style.transform = '';
  });
}
```

**4. Web fonts causing FOUT**
```css
/* ❌ Font swap shifts text */
@font-face {
  font-family: 'Custom';
  src: url('custom.woff2') format('woff2');
}

/* βœ… Optional font (no shift if slow) */
@font-face {
  font-family: 'Custom';
  src: url('custom.woff2') format('woff2');
  font-display: optional;
}

/* βœ… Or match fallback metrics */
@font-face {
  font-family: 'Custom';
  src: url('custom.woff2') format('woff2');
  font-display: swap;
  size-adjust: 105%; /* Match fallback size */
  ascent-override: 95%;
  descent-override: 20%;
}
```

**5. Animations triggering layout**
```css
/* ❌ Animates layout properties */
.animate {
  transition: height 0.3s, width 0.3s;
}

/* βœ… Use transform instead */
.animate {
  transition: transform 0.3s;
}
.animate.expanded {
  transform: scale(1.2);
}
```

### CLS optimization checklist

```markdown
- [ ] All images have width/height or aspect-ratio
- [ ] All videos/embeds have reserved space
- [ ] Ads have min-height containers
- [ ] Fonts use font-display: optional or matched metrics
- [ ] Dynamic content inserted below viewport
- [ ] Animations use transform/opacity only
- [ ] No content injected above existing content
```

### CLS debugging
```javascript
// Track layout shifts
new PerformanceObserver((list) => {
  for (const entry of list.getEntries()) {
    if (!entry.hadRecentInput) {
      console.log('Layout shift:', entry.value);
      entry.sources?.forEach(source => {
        console.log('  Shifted element:', source.node);
        console.log('  Previous rect:', source.previousRect);
        console.log('  Current rect:', source.currentRect);
      });
    }
  }
}).observe({ type: 'layout-shift', buffered: true });
```

---

## Measurement tools

### Lab testing
- **Chrome DevTools** β†’ Performance panel, Lighthouse
- **WebPageTest** β†’ Detailed waterfall, filmstrip
- **Lighthouse CLI** β†’ `npx lighthouse <url>`

### Field data (real users)
- **Chrome User Experience Report (CrUX)** β†’ BigQuery or API
- **Search Console** β†’ Core Web Vitals report
- **web-vitals library** β†’ Send to your analytics

```javascript
import {onLCP, onINP, onCLS} from 'web-vitals';

function sendToAnalytics({name, value, rating}) {
  gtag('event', name, {
    event_category: 'Web Vitals',
    value: Math.round(name === 'CLS' ? value * 1000 : value),
    event_label: rating
  });
}

onLCP(sendToAnalytics);
onINP(sendToAnalytics);
onCLS(sendToAnalytics);
```

---

## Framework quick fixes

### Next.js
```jsx
// LCP: Use next/image with priority
import Image from 'next/image';
<Image src="/hero.jpg" priority fill alt="Hero" />

// INP: Use dynamic imports
const HeavyComponent = dynamic(() => import('./Heavy'), { ssr: false });

// CLS: Image component handles dimensions automatically
```

### React
```jsx
// LCP: Preload in head
<link rel="preload" href="/hero.jpg" as="image" fetchpriority="high" />

// INP: Memoize and useTransition
const [isPending, startTransition] = useTransition();
startTransition(() => setExpensiveState(newValue));

// CLS: Always specify dimensions in img tags
```

### Vue/Nuxt
```vue
<!-- LCP: Use nuxt/image with preload -->
<NuxtImg src="/hero.jpg" preload loading="eager" />

<!-- INP: Use async components -->
<component :is="() => import('./Heavy.vue')" />

<!-- CLS: Use aspect-ratio CSS -->
<img :style="{ aspectRatio: '16/9' }" />
```

## References

- [web.dev LCP](https://web.dev/articles/lcp)
- [web.dev INP](https://web.dev/articles/inp)
- [web.dev CLS](https://web.dev/articles/cls)
- [Performance skill](../performance/SKILL.md)

Quoted from davila7/claude-code-templates for reference β€” see the original for the authoritative, latest version.

πŸ“„ Full skill instructions β€” original source: davila7/claude-code-templates
Core Web Vitals focuses on the technical metrics Google uses to evaluate site performance: Largest Contentful Paint (LCP), Interaction to Next Paint (INP), and Cumulative Layout Shift (CLS). This agentic skill automates the identification and remediation of performance bottlenecks that drag down your search engine rankings and user retention. By analyzing resource load priorities, main thread blocking tasks, and layout stability, it provides specific code-level adjustments to meet the 75th-percentile performance thresholds. Developers use this to transition from generic performance advice to actionable fixes, such as inlining critical CSS, optimizing image delivery, or restructuring event-driven JavaScript execution. It is essential for teams aiming to maintain high-speed web environments while reducing the manual overhead typically required for complex performance auditing and refactoring.

How to Use This Skill Unit

Option A: Project-Specific (Recommended)

  1. Click "Download" above
  2. In your project, create the directory: .agent/skills/core-web-vitals/
  3. Save the file as SKILL.md
  4. The agent will automatically discover the skill based on its description.

Option B: Global Installation (All Agents)

Save the file to these locations to make it available across all projects:

  • Claude Code: ~/.claude/skills/davila7/claude-code-templates/core-web-vitals/SKILL.md
  • Cursor: ~/.cursor/skills/davila7/claude-code-templates/core-web-vitals/SKILL.md
  • Antigravity: ~/.gemini/antigravity/skills/davila7/claude-code-templates/core-web-vitals/SKILL.md

πŸš€ Install with CLI:
npx skills add davila7/claude-code-templates

Read the Master Guide: Mastering Agent Skills β†’

Recommended Rules

View more rules β†’

⚑ Performance Optimization Agent - Speed Expert

Agentic AIPerformanceOptimization
You are an expert performance optimization agent specialized in identifying and fixing performance bottlenecks. Apply systematic reasoning to measure,...

Web Performance Optimization Expert

PerformanceWeb VitalsOptimization
You are an expert in web performance optimization and Core Web Vitals. Key Principles: - Optimize for Core Web Vitals - Minimize Time to First Byte (...

Next.js Performance Optimization

Next.jsPerformanceOptimization
You are an expert in Next.js performance optimization. Key Principles: - Optimize images and fonts - Minimize client-side JavaScript - Use proper cac...

Recommended Workflows

View more workflows β†’

Analyze Bundle Size

PerformanceNext.jsOptimization
--- description: Visualize and reduce your production build size --- 1. **Install Analyzer**: - Install the Next.js bundle analyzer. // turbo ...

Optimize Images for Web

PerformanceImagesOptimization
--- description: Compress and serve images in modern formats for faster loading --- 1. **Use Next.js Image Component**: - Automatic optimization a...

Implement Request Deduplication

PerformanceAPIReact
--- description: Prevent duplicate API calls in React components --- 1. **Next.js 15 Fetch Caching**: - **Change:** `fetch` requests are no longer...

Recommended MCP Servers

View more MCP servers β†’
Cloudinary

Cloudinary

Official

Exposes Cloudinary's media upload, transformation, AI analysis, management, optimization and delivery as tools usable by AI agents

fetchSERP

fetchSERP

Official

All-in-One SEO & Web Intelligence Toolkit API [fetchSERP](https://www.fetchserp.com/)

Keywords Everywhere

Keywords Everywhere

Official

Access SEO data through the official Keywords Everywhere API MCP server.

Take It Further

Maximize your productivity with these powerful resources

πŸ“‹

Define Your Standards

Set up coding standards to ensure this workflow produces consistent, high-quality results.

Browse Rules Library
πŸ“–

Master Workflows

Learn how to create custom workflows, use Turbo Mode, and build your automation library.

Complete Guide

How to use this Skill in Claude Code & Cursor

For Claude Code (CLI)

To use this skill in Claude Code, copy the rule content into your project's custom instructions or follow our Add-Skill CLI guide. This ensures Claude follows your standards during every code generation.

For Cursor & Windsurf

For Cursor or Windsurf, individual skills are best used in the "Rules for AI" section. This specific unit helps the agent avoid seo issues, leading to cleaner, more efficient code.

Why the skill format matters: the standardized Agent Skills format lets your AI agent load detailed instructions only when they are relevant, keeping your prompt clean while improving results.

Source & attribution

This skill is categorized under Seo and is published by davila7, maintained in davila7/claude-code-templates.

← Browse All Agent Skills
Sponsored AI assistant. Recommendations may be paid.