
Performance Profiling
- 952 installs
- 44k repo stars
- Updated July 27, 2026
- sickn33/antigravity-awesome-skills
performance-profiling is a debugging skill that systematically measures, locates, and eliminates performance bottlenecks across web applications and agent workflows using Lighthouse audits and Core Web Vitals targets for
About
performance-profiling is a community skill from sickn33/antigravity-awesome-skills that teaches measure-analyze-optimize discipline for web and agent workflow performance. The skill bundles a runnable lighthouse_audit.py script invoked as python scripts/lighthouse_audit.py https://example.com for automated Lighthouse performance audits. It documents Core Web Vitals targets including LCP under 2.5 seconds as good and over 4.0 seconds as poor, plus INP under 200 milliseconds as good and over 500 milliseconds as poor. Developers reach for performance-profiling when production or staging pages feel slow, agent pipelines stall, or Core Web Vitals fail thresholds and guesswork must be replaced with profiling data. The workflow prioritizes measurement before code changes so optimizations target real bottlenecks rather than assumed hotspots.
- 4-step profiling process: Baseline → Identify → Fix → Validate
- Core Web Vitals targets with LCP < 2.5s, INP < 200ms, CLS < 0.1
- Tool selection matrix for page load, bundle size, runtime, memory, and network
- Automated Lighthouse audit script included for CI/CD and local use
- Measurement-first workflow that prevents premature optimization
Performance Profiling by the numbers
- 952 all-time installs (skills.sh)
- +21 installs in the week ending Jul 28, 2026 (Skillselion tracking)
- Ranked #538 of 2,184 Testing & QA skills by installs in the Skillselion catalog
- Security screen: MEDIUM risk (skills.sh audit)
- Data as of Jul 28, 2026 (Skillselion catalog sync)
npx skills add https://github.com/sickn33/antigravity-awesome-skills --skill performance-profilingAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 952 |
|---|---|
| repo stars | ★ 44k |
| Security audit | 2 / 3 scanners passed |
| Last updated | July 27, 2026 |
| Repository | sickn33/antigravity-awesome-skills ↗ |
How do you profile and fix web app performance bottlenecks?
Systematically measure, locate, and eliminate performance bottlenecks across web apps and agent workflows.
Who is it for?
Developers shipping web applications or agent workflows who need Lighthouse audits and Core Web Vitals guidance before release.
Skip if: Teams with no runnable web URL or workflow to measure who only need architectural design reviews without runtime profiling.
When should I use this skill?
A page or agent workflow is slow, Core Web Vitals fail thresholds, or the developer asks for Lighthouse-based performance profiling.
What you get
Lighthouse audit results, Core Web Vitals measurements, identified bottleneck locations, and a prioritized optimization plan.
- Lighthouse audit report
- Core Web Vitals analysis
By the numbers
- Includes lighthouse_audit.py runtime script
- LCP good threshold under 2.5s, poor over 4.0s
- INP good threshold under 200ms, poor over 500ms
Files
Performance Profiling
Measure, analyze, optimize - in that order.
🔧 Runtime Scripts
Execute these for automated profiling:
| Script | Purpose | Usage |
|---|---|---|
scripts/lighthouse_audit.py | Lighthouse performance audit | python scripts/lighthouse_audit.py https://example.com |
---
1. Core Web Vitals
Targets
| Metric | Good | Poor | Measures |
|---|---|---|---|
| LCP | < 2.5s | > 4.0s | Loading |
| INP | < 200ms | > 500ms | Interactivity |
| CLS | < 0.1 | > 0.25 | Stability |
When to Measure
| Stage | Tool |
|---|---|
| Development | Local Lighthouse |
| CI/CD | Lighthouse CI |
| Production | RUM (Real User Monitoring) |
---
2. Profiling Workflow
The 4-Step Process
1. BASELINE → Measure current state
2. IDENTIFY → Find the bottleneck
3. FIX → Make targeted change
4. VALIDATE → Confirm improvementProfiling Tool Selection
| Problem | Tool |
|---|---|
| Page load | Lighthouse |
| Bundle size | Bundle analyzer |
| Runtime | DevTools Performance |
| Memory | DevTools Memory |
| Network | DevTools Network |
---
3. Bundle Analysis
What to Look For
| Issue | Indicator |
|---|---|
| Large dependencies | Top of bundle |
| Duplicate code | Multiple chunks |
| Unused code | Low coverage |
| Missing splits | Single large chunk |
Optimization Actions
| Finding | Action |
|---|---|
| Big library | Import specific modules |
| Duplicate deps | Dedupe, update versions |
| Route in main | Code split |
| Unused exports | Tree shake |
---
4. Runtime Profiling
Performance Tab Analysis
| Pattern | Meaning |
|---|---|
| Long tasks (>50ms) | UI blocking |
| Many small tasks | Possible batching opportunity |
| Layout/paint | Rendering bottleneck |
| Script | JavaScript execution |
Memory Tab Analysis
| Pattern | Meaning |
|---|---|
| Growing heap | Possible leak |
| Large retained | Check references |
| Detached DOM | Not cleaned up |
---
5. Common Bottlenecks
By Symptom
| Symptom | Likely Cause |
|---|---|
| Slow initial load | Large JS, render blocking |
| Slow interactions | Heavy event handlers |
| Jank during scroll | Layout thrashing |
| Growing memory | Leaks, retained refs |
---
6. Quick Win Priorities
| Priority | Action | Impact |
|---|---|---|
| 1 | Enable compression | High |
| 2 | Lazy load images | High |
| 3 | Code split routes | High |
| 4 | Cache static assets | Medium |
| 5 | Optimize images | Medium |
---
7. Anti-Patterns
| ❌ Don't | ✅ Do |
|---|---|
| Guess at problems | Profile first |
| Micro-optimize | Fix biggest issue |
| Optimize early | Optimize when needed |
| Ignore real users | Use RUM data |
---
Remember: The fastest code is code that doesn't run. Remove before optimizing.
When to Use
This skill is applicable to execute the workflow or actions described in the overview.
Limitations
- Use this skill only when the task clearly matches the scope described above.
- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.
#!/usr/bin/env python3
"""
Skill: performance-profiling
Script: lighthouse_audit.py
Purpose: Run Lighthouse performance audit on a URL
Usage: python lighthouse_audit.py https://example.com
Output: JSON with performance scores
Note: Requires lighthouse CLI (npm install -g lighthouse)
"""
import subprocess
import json
import sys
import os
import tempfile
def run_lighthouse(url: str) -> dict:
"""Run Lighthouse audit on URL."""
try:
with tempfile.NamedTemporaryFile(suffix='.json', delete=False) as f:
output_path = f.name
result = subprocess.run(
[
"lighthouse",
url,
"--output=json",
f"--output-path={output_path}",
"--chrome-flags=--headless",
"--only-categories=performance,accessibility,best-practices,seo"
],
capture_output=True,
text=True,
timeout=120
)
if os.path.exists(output_path):
with open(output_path, 'r') as f:
report = json.load(f)
os.unlink(output_path)
categories = report.get("categories", {})
return {
"url": url,
"scores": {
"performance": int(categories.get("performance", {}).get("score", 0) * 100),
"accessibility": int(categories.get("accessibility", {}).get("score", 0) * 100),
"best_practices": int(categories.get("best-practices", {}).get("score", 0) * 100),
"seo": int(categories.get("seo", {}).get("score", 0) * 100)
},
"summary": get_summary(categories)
}
else:
return {"error": "Lighthouse failed to generate report", "stderr": result.stderr[:500]}
except subprocess.TimeoutExpired:
return {"error": "Lighthouse audit timed out"}
except FileNotFoundError:
return {"error": "Lighthouse CLI not found. Install with: npm install -g lighthouse"}
def get_summary(categories: dict) -> str:
"""Generate summary based on scores."""
perf = categories.get("performance", {}).get("score", 0) * 100
if perf >= 90:
return "[OK] Excellent performance"
elif perf >= 50:
return "[!] Needs improvement"
else:
return "[X] Poor performance"
if __name__ == "__main__":
if len(sys.argv) < 2:
print(json.dumps({"error": "Usage: python lighthouse_audit.py <url>"}))
sys.exit(1)
result = run_lighthouse(sys.argv[1])
print(json.dumps(result, indent=2))
Related skills
How it compares
Use performance-profiling for measurement-first web and workflow optimization with Lighthouse and Core Web Vitals, not for load-testing infrastructure at cluster scale.
FAQ
How do you run the performance-profiling Lighthouse script?
performance-profiling includes lighthouse_audit.py run as python scripts/lighthouse_audit.py https://example.com. The script automates a Lighthouse performance audit against the supplied URL and returns measurable scores for optimization.
What Core Web Vitals thresholds does performance-profiling use?
performance-profiling marks LCP good below 2.5 seconds and poor above 4.0 seconds. INP is good below 200 milliseconds and poor above 500 milliseconds, guiding which metrics to fix first.
Is Performance Profiling safe to install?
skills.sh reports 2 of 3 security scanners passed. Review the Security Audits panel on this page before installing in production.