메뉴
Performance audit: bundle size, lazy loading, data fetching, caching, N+1 queries, image optimization. Native mode checks memory, I/O, launch weight, energy.
Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.
SOC 직업 분류 기준
Periodic repository cleanup sweep (Tierward repo variant) - finds orphaned/merged git branches, orphaned worktrees and unregistered worktree directories, stale `.claude/session/*.md` files, stale `.claude/initiatives/*.md` files, and (target:full / target:reviews) orphaned documentation and stale `docs/reviews/` snapshots (archive-only moves, never deletion). Reports every finding with evidence, then executes only the branches/worktrees/session-files the user explicitly confirms via a single AskUserQuestion batch. Never deletes docs/*.md itself - those are always report-only, evidence-based, human-decided. Distinct from the Phase 8 cleanup gate (which tears down one specific block at closure) - this is the periodic sweep that catches what block-by-block cleanup misses.
Unified accessibility audit - axe-core WCAG 2.2 scan, APCA contrast measurement, static a11y checks (aria-label, tabindex, form labels, focus visibility, onClick on non-interactive). Static and live modes.
Performance audit: bundle size, lazy loading, data fetching, caching, N+1 queries, image optimization. Native mode checks memory, I/O, launch weight, energy.
Responsive audit: test pages at 375/768/1024px breakpoints via Playwright. Checks overflow, tap targets, sidebar collapse, text reflow, WCAG 1.4.4 zoom.
Security audit: auth/authz on API routes, input validation, row-level access control (RLS in Postgres, ORM scopes or app-level guards elsewhere), response shape review, secret exposure, HTTP headers. Native mode checks entitlements and Keychain. MCP-aware (v1.20+): when `mcp-nvd` server is wired, Step 3c queries live CVE data instead of static `npm audit` / `pip-audit` snapshots; falls back to local audit commands when MCP unreachable.
Database audit: schema quality, index coverage, row-level access-control completeness, FK cascades, query patterns. Runs live SQL verification (PostgreSQL instance in PATTERNS.md; other engines verify the equivalent guard). Migration file safety → /migration-audit.
| name | perf-audit |
| description | Performance audit: bundle size, lazy loading, data fetching, caching, N+1 queries, image optimization. Native mode checks memory, I/O, launch weight, energy. |
Replace these placeholders:
[FRAMEWORK]- e.g.Next.js App Router,Remix,SvelteKit,plain React[SITEMAP_OR_ROUTE_LIST]- e.g.docs/sitemap.md[API_ROUTES_PATH]- e.g.routes/,src/handlers/,api/[BUNDLE_TOOL]- e.g.@next/bundle-analyzer,vite-bundle-visualizer,webpack-bundle-analyzer- Note: if this is a public-facing app, remove the "Out of scope" restriction on Core Web Vitals
Before any other step: read CLAUDE.md and check the Framework and Language fields.
N/A - native app and NOT N/A - no web frontend): proceed to Step 1 - Web Performance Audit (Steps 1–5).N/A - native app or N/A - no web frontend): skip Steps 1–5 and proceed directly to Step 6 - Native/Backend Performance Audit.In scope: bundle composition, server/client component boundaries, dynamic rendering triggers, lazy loading, data fetching efficiency (caching, parallelism, N+1), re-render patterns, image optimization. For native stacks: algorithmic complexity, stack-specific hot-path patterns, memory management, launch weight, energy impact, binary size.
Out of scope: SEO, CWV as ranking signals, robots.txt, sitemap.xml, OG tags, Lighthouse site audit, accessibility (→ /ui-audit), DB schema (→ /skill-db).
Default mode: audit (report only, no code changes). mode:apply makes focused non-breaking fixes.
CWV reference (informational only - not primary deliverable for this internal app):
| Metric | Good | Needs work | Poor | Primary cause |
|---|---|---|---|---|
| LCP | ≤ 2.5s | 2.5–4s | > 4s | Slow server response, render-blocking resources |
| CLS | ≤ 0.1 | 0.1–0.25 | > 0.25 | Unsized images, dynamic content above fold |
| INP | ≤ 200ms | 200–500ms | > 500ms | Blocking JS on event handlers |
Source: web.dev/articles/vitals. Use these thresholds only as triage anchors - not as primary deliverables.
Parse $ARGUMENTS for target: and mode: tokens.
Operating modes:
| Mode | Behavior |
|---|---|
mode:audit (default) | Report only - no code changes |
mode:apply | Apply focused, non-breaking fixes (lazy loading wrappers, Promise.all parallelization). Describe each change before applying. |
Target resolution:
| Pattern | Meaning |
|---|---|
target:page:/dashboard | Focus on the dashboard and its component tree (example) |
| No argument | Full audit - ALL page files + layout files + lib files + API routes from sitemap.md. Maximum depth. |
STRICT PARSING - mandatory: derive target ONLY from the explicit text in $ARGUMENTS. Do NOT infer target from conversation context, recent work, active block names, or project memory. If $ARGUMENTS contains no target: token → full audit across ALL files from sitemap.md at maximum depth. When a target IS provided → act with maximum depth and completeness on that specific scope only.
Target scoping - comparative vs independent checks (mandatory): a subset of checks evaluate a project-wide property (build configuration, client bundle composition, launch entry point, release artifact); the rest evaluate one file or route in isolation.
target: filter does NOT apply to them: P1, P2, P3 (web) and NR1, NR4 (native). They MUST run against the full project even when a target is given. The client bundle, build configuration, entry point, and release artifact are global - narrowing them to the target subset hides cross-cutting exposure (a heavy package bundled by a non-targeted page still ships to every user).target: filter. Layout/shell files stay in scope regardless of target (Step 1).target: is given: apply the filter to the independent checks only; run the comparative checks across the full project and state in the report that they ran full-project by design.Announce: Running perf-audit - scope: [FULL | target: <resolved>] - mode: [audit | apply]
Apply the target filter to the file list in Step 1.
next.config.ts, vite.config.ts, nuxt.config.ts, webpack.config.js)Read docs/refactoring-backlog.md - note existing PERF- entries to avoid duplicates.
Launch a single Explore subagent (model: haiku) with all page, component, and lib files from Step 1:
"Run all 9 checks below. For each: state total match count, list every match as file:line - excerpt, and state PASS or FAIL. Adapt grep patterns to the project's framework - the concepts are universal, the specific APIs vary.
CHECK B1 - Unnecessary client-side rendering scope Find components or pages marked for client-side rendering that do not actually use browser APIs (event handlers, state, refs, browser-only hooks).
'use client', <script> with client:only, etc.) and check if the file uses any browser-specific API.CHECK B2 - Heavy libraries in client bundle Grep for imports of known-heavy libraries in client-rendered files. Flag any imports of libraries that do NOT need browser APIs and could run server-side:
CHECK B3 - Client-side data fetching that defeats server rendering
Find client-rendered components that fetch data in lifecycle hooks (e.g. useEffect, onMounted, onMount) instead of using server-side data loading.
Flag: data fetching in client lifecycle hooks - these defeat server rendering and add a loading waterfall. Use server-side data loading with streaming/suspense, or a client-side cache library with proper revalidation.
CHECK B4 - Unstable callback references defeating memoization Find inline arrow functions passed as props to memoized child components. Inline functions create new references on every parent render, defeating memoization. Flag: each case. Skip native HTML element event handlers - frameworks batch these internally.
CHECK B5 - Sequential await waterfall
Pattern: two or more consecutive await calls for independent data sources in the same async function.
Grep in server-rendered files or API routes: lines matching const .* = await that appear consecutively (within 5 lines of each other) without the first result being an input to the second call.
Flag: each pair of sequential awaits that could be parallelised with Promise.all (or equivalent).
Example of violation: const a = await getA(); const b = await getB(); where b doesn't depend on a.
CHECK B6 - Missing caching on repeated server-side queries Find data fetches that run on every request without caching in server-rendered components. Grep in server-rendered files for database query calls - check if they use any caching mechanism (framework cache, memoization, or explicit cache headers). Flag: uncached queries in layout-level or frequently-visited components (e.g. navigation data, user profile). These execute on every page visit.
CHECK B7 - Images without explicit dimensions (CLS risk)
Find image elements (framework image component or native <img>) without width/height or fill/cover constraints.
Flag: each unsized image. Without dimensions, the browser cannot reserve layout space - content shifts when the image loads, causing CLS violations.
CHECK B8 - Accidental dynamic rendering triggers Find patterns that force dynamic rendering at the layout level, opting entire route subtrees out of static generation:
CHECK B9 - Missing lazy loading for heavy client components
Find imports of heavy libraries (rich text editors, chart libraries, complex UI components) that are statically imported without lazy loading.
Flag: any file where a heavy component is eagerly imported without using the framework's dynamic/lazy import mechanism (e.g. React.lazy, next/dynamic, defineAsyncComponent, dynamic import())."
Read the framework configuration file (e.g. next.config.ts, vite.config.ts, webpack.config.js, nuxt.config.ts).
P1 - Bundle analyzer availability Check if a bundle analyzer is configured or available for the project's build tool:
webpack-bundle-analyzer or @next/bundle-analyzerrollup-plugin-visualizernpx next experimental-analyze (built-in)P2 - Server-only package exclusion Check if the framework configuration excludes heavy server-only packages from the client bundle. Identify packages in the project that should never be client-bundled (e.g. PDF processors, XLSX generators, database drivers, file system utilities). Flag: any heavy server-only package not explicitly excluded from client bundling.
P3 - Tree-shaking optimization for large libraries Check if the build configuration optimizes imports for large libraries with many exports where only a subset is used (e.g. icon libraries with hundreds of icons, utility libraries like lodash). Note: some frameworks automatically optimize certain packages (check the framework docs). If a library is already auto-optimized by the build tool, note as PASS. Flag: any package with 100+ exports where only a subset is used, not covered by the build tool's tree-shaking or import optimization.
"Run these 3 checks. Adapt grep patterns to the project's database client or ORM:
CHECK Q1 - Unbounded queries (no limit on large-growth tables) Flag: each collection query without pagination bounds. Exception: export routes that intentionally fetch all for CSV/XLSX - verify from context.
CHECK Q2 - Select * (over-fetching columns)
Grep for select-all patterns in route handlers (e.g. .select('*'), SELECT *, .findAll() without field projection, .all() without only()).
Flag: each match. Fetching all columns is a performance and security risk - columns with large values (e.g. body, content, blob URLs) are sent over the wire unnecessarily.
CHECK Q3 - N+1 patterns
Pattern A: database query calls inside .map(, for, or forEach loops.
Pattern B: sequential await with a DB client call inside a loop body.
Flag: each match. N+1 on a list endpoint means N DB queries for an N-item list - use batch queries or embedded/eager loading instead."
Generate the report using the template in ${CLAUDE_SKILL_DIR}/REPORT.md (Web Audit section). Apply the severity guide and backlog writing rules from the same file.
mode:audit (default): do NOT make any code changes - report only. After producing the report, ask: "Should I implement the High/Critical priority optimisations?"mode:apply: apply only the fixes listed in Quick wins (isolated, non-breaking). Describe each change before writing it. Do not apply Strategic refactors without explicit user confirmation. Do NOT ask the closing question - the user already expressed intent via mode:apply.This path runs for non-web projects only. Web projects use Steps 1–5 above.
Primary tool: [PERF_TOOL]
Profile command: [PROFILER_COMMAND]
Run the profiler on the main execution path. Identify the top 5 hotspots by CPU time and the top 5 by memory allocation. If profiling data is not available, proceed with static analysis and recommend running the profiler.
Launch a single Explore subagent (model: haiku) with all source files from the project:
"Run these 4 checks on the provided source files. For each: state total match count, list every match as file:line - excerpt, and state PASS or FAIL.
CHECK NP1 - Nested iteration on collections Grep for nested loops (for/while/map/forEach inside another loop body) operating on collections or arrays. Flag: O(n²) or worse complexity. Exclude small fixed-size iterations (< 10 items known at compile time).
CHECK NP2 - Memory allocation in hot paths Flag:
CHECK NP3 - I/O bottleneck patterns Flag:
CHECK NP4 - Concurrency inefficiency Flag:
Read the 10 largest source files by line count. Apply the checks relevant to the project language. Each check includes grep patterns - run them, then read flagged files for context.
Swift:
DispatchQueue.main.sync outside UI layer files - synchronous dispatch on main blocks the UI. Also grep for URLSession.shared.data without Task { } wrapper in non-async contexts.UIImage(named: or NSImage(named: in collection view / table view code - flag if no preparingThumbnail or CGImageSource downsampling nearby.NSFetchRequest - flag if fetchBatchSize is 0 or not set (default fetches all objects into memory).self - flag { self. or { [self] without [weak self] in long-lived contexts (completion handlers, observers, timers).for/while loops (e.g. = String(, = Data(, = NSMutableAttributedString().Kotlin:
Room or SQLite calls outside Dispatchers.IO or withContext(Dispatchers.IO).onBindViewHolder - flag if view inflation (inflate() happens inside bind instead of onCreateViewHolder.BitmapFactory.decode - flag if no inSampleSize option is set (loads full-resolution bitmaps).GlobalScope.launch - flag each occurrence (no lifecycle-aware cancellation).StrictMode in Application class - flag if absent in debug build (disk/network violations on main thread go undetected).Rust:
.clone() - flag if the value is only read after cloning (borrow would suffice).Vec::new(), String::new(), Box::new( inside loop bodies - flag if the allocation could be hoisted or reused.Box<dyn - flag if the trait has a single implementor (generics avoid vtable overhead).pub fn in hot-path modules with body < 5 lines - consider #[inline] for small frequently-called functions.Go:
go func or go inside for - flag if no semaphore/pool limits the concurrency.make(chan - flag unbuffered channels (make(chan T)) in producer-consumer patterns (causes blocking).defer inside for - deferred calls accumulate until the function returns, not the loop iteration.go build -gcflags='-m' 2>&1 | grep 'escapes to heap' on hot-path packages.Python:
re.compile or re.search/re.match with literal pattern inside for/while - flag if pattern is constant (compile once outside loop).[... for ... in ...] passed to sum(, max(, min(, any(, all( - generator expression avoids materializing the full list.copy.deepcopy - flag in hot paths (extremely expensive).threading.Thread doing CPU-bound work - flag (use multiprocessing or concurrent.futures.ProcessPoolExecutor instead).Ruby:
.each followed by association access (e.g. user.company) - flag if no .includes( or .eager_load( on the parent query."#{ inside loops - flag if the string could be built with StringIO or array join..map { |x| x. patterns creating intermediate arrays - flag if .lazy.map or .each_with_object would avoid allocation.Java:
Integer, Long, Double in loop variable declarations - flag (use primitive types int, long, double).+= on String variables inside loops - flag (use StringBuilder).DriverManager.getConnection - flag if no connection pool (HikariCP, c3p0) is configured..stream(). on small collections (< 10 items) - traditional loop may be faster due to stream pipeline overhead.dotnet:
.Select(, .Where(, .ToList() chains - flag if intermediate .ToList() materializes unnecessarily before final consumption.+= on string inside loops - flag (use StringBuilder or string.Join).new byte[ with size > 85000 - flag (Large Object Heap allocations are expensive to collect).async methods that contain only a single await with no branching - flag as candidates for removing async wrapper (avoids state machine overhead).CHECK NR1 - Launch / startup weight Identify the application entry point:
@main struct or AppDelegate.didFinishLaunchingWithOptionsApplication.onCreate or MainActivity.onCreatemain() function or entry moduleGrep for heavy operations in the entry point: database initialization, network calls, large file reads, complex object graph construction. Flag any operation that could be deferred (lazy initialization) or moved to a background thread/task.
CHECK NR2 - Memory management patterns
autoreleasepool in batch processing loops. Grep for NSCache or Dictionary used as cache without size limit.static or companion object holding Activity/Context references (memory leak). Check onDestroy for missing listener/observer cleanup.Vec that grows via push in a loop without with_capacity pre-allocation.sync.Map or map growth without periodic cleanup - flag unbounded maps.CHECK NR3 - Energy and background patterns (mobile stacks only)
Timer.scheduledTimer or DispatchSource.makeTimerSource - flag if no tolerance set (tight timers prevent CPU sleep). Grep for CLLocationManager with startUpdatingLocation - flag if startMonitoringSignificantLocationChanges would suffice.AlarmManager.setRepeating or Handler.postDelayed in loops - flag excessive wake-ups. Grep for LocationRequest with high frequency updates.CHECK NR4 - Binary / artifact size
DEBUG conditional code that may leak into release builds (grep for #if DEBUG blocks containing large test fixtures or mock data).debugImplementation dependencies accidentally in implementation (grep build.gradle for heavy debug-only libraries in the wrong configuration).Generate the report using the template in ${CLAUDE_SKILL_DIR}/REPORT.md (Native Audit section). Apply the severity guide and backlog writing rules from the same file.
mode:audit (default): report only. After report, ask: "Should I implement the High/Critical priority optimisations?"mode:apply: apply only Quick wins. Describe each change before writing.