Standalone Mode

If invoked directly (not via the orchestrator), you must first:

Read ../codeprobe/shared-preamble.md (resolve relative to this SKILL.md's location — the sibling codeprobe skill directory — not the user's project) for the output contract, execution modes, and constraints.
Load applicable reference files from ../codeprobe/references/ (same resolution) based on the project's tech stack.
Default to full mode unless the user specifies otherwise.

Performance & Scalability Auditor

Domain Scope

This sub-skill detects performance and scalability issues across these categories:

N+1 Queries — Lazy-loading relationships inside loops
Missing Indexes — WHERE/ORDER BY on non-indexed columns
Unbounded Queries — Model::all() without pagination/limit
Memory — Loading entire files into memory, array accumulation in loops
Caching — Repeated identical queries, missing TTL, stale cache after writes
Algorithmic Efficiency — O(n^2) in hot paths, nested loops, sorting in loops
Concurrency — Race conditions, non-idempotent queue jobs, shared mutable state
Frontend Performance — Unnecessary re-renders, bundle size, missing lazy loading

What It Does NOT Flag

Premature optimization in non-hot-path code — proportional design matters. A utility function called once at startup doesn't need the same optimization as a request handler.
Development-only debug queries — queries in seeders, dev-only commands, or debug endpoints.
Batch processing scripts — scripts intentionally designed to process everything (migrations, data backfills) where unbounded queries may be appropriate.
O(n^2) on small bounded collections (<100 items) — nested loops on small known-size arrays are fine.
Frontend SSR/build-time code — server components and build scripts have different performance profiles than client-side code.

Detection Instructions

N+1 Queries

ID Prefix	What to Detect	How to Detect	Severity
`PERF`	Eloquent relationship access inside loop without eager loading	Search for `foreach`/`for` loops iterating over a collection, then accessing a relationship property (e.g., `$order->items`, `$user->profile`) inside the loop body. Check whether the query that produced the collection includes `with()` or `load()` for that relationship.	Major
`PERF`	Any ORM lazy-loading inside iteration	Look for patterns where a database query is implicitly triggered inside a loop: Django querysets accessed per-iteration, SQLAlchemy lazy loads, Prisma relation access in `.map()`.	Major
`PERF`	Template/view triggering queries	Blade templates, Jinja2 templates, or React components calling relationship properties that trigger queries during rendering.	Major

Missing Indexes

ID Prefix	What to Detect	How to Detect	Severity
`PERF`	WHERE/ORDER BY on non-indexed columns	Cross-reference query conditions (`where()`, `orderBy()`, `WHERE`, `ORDER BY`) with migration files or schema definitions to check for matching indexes.	Major
`PERF`	Foreign keys without indexes	Check migration files for `foreignId()`, `foreign()`, `references()` without corresponding index definitions. Most ORMs add these automatically, but raw migrations may miss them.	Minor
`PERF`	Composite queries needing compound indexes	Multiple `where()` conditions on different columns in the same query, or `where() + orderBy()` combinations that would benefit from a compound index.	Minor

Unbounded Queries

ID Prefix	What to Detect	How to Detect	Severity
`PERF`	`Model::all()` or `SELECT *` without limit	Search for `.all()`, `::all()`, `findAll()`, `SELECT * FROM` without `LIMIT`, `paginate()`, `take()`, or `limit()`.	Major
`PERF`	Missing cursor/chunk for large dataset processing	Operations that `get()` or load entire collections when processing large datasets. Should use `cursor()`, `chunk()`, `lazy()`, or equivalent streaming approach.	Major

Memory

ID Prefix	What to Detect	How to Detect	Severity
`PERF`	Loading entire files into memory	`filegetcontents()` on user uploads or large files, `fs.readFileSync()` on variable-size files, Python `open().read()` without size limits.	Major
`PERF`	Array accumulation in loops	Arrays that grow inside loops without bounds or cleanup — collecting results in memory that could be streamed or yielded.	Minor
`PERF`	Large collections instead of generators	Returning full arrays/lists where generators (`yield`), lazy collections, or iterators would be more memory-efficient for large datasets.	Minor

Caching

ID Prefix	What to Detect	How to Detect	Severity
`PERF`	Repeated identical queries in same request	Same query pattern executed multiple times within a single request/function call without caching the result.	Minor
`PERF`	Cache without TTL	`Cache::put()`, `cache.set()`, Redis SET without expiration. Data cached forever risks staleness.	Minor
`PERF`	Cache not invalidated after writes	Write operations (create/update/delete) that don't clear or update related cache entries. Stale cache served after mutation.	Major

Algorithmic Efficiency

ID Prefix	What to Detect	How to Detect	Severity
`PERF`	O(n^2) or worse in hot paths	Nested loops iterating over the same or related collections. `arraysearch`/`in``array`/`includes()` inside loops (linear search in a loop = O(n^2)).	Major
`PERF`	Sorting inside loops	`sort()`, `usort()`, `array_sort()`, `.sort()` called inside a loop body.	Major
`PERF`	Hashmap-replaceable linear search	`in_array()`, `.includes()`, `.indexOf()`, `list.index()` used repeatedly on the same array where building a Set/dict/hashmap first would be O(1) per lookup.	Minor

Concurrency

ID Prefix	What to Detect	How to Detect	Severity
`PERF`	Race conditions in read-modify-write	Patterns that read a value, modify it, and write back without locking: incrementing counters, updating balances, toggling flags in concurrent contexts.	Critical
`PERF`	Queue jobs without idempotency	Queue/job handlers that don't check for duplicate execution. Jobs that create resources without checking if already created. Missing unique constraints on job-created data.	Major
`PERF`	Shared mutable state in async contexts	Global/module-level mutable variables accessed in async handlers, request-scoped data stored in module scope.	Major

Frontend Performance

ID Prefix	What to Detect	How to Detect	Severity
`PERF`	Unnecessary re-renders	Missing `React.memo`, `useMemo`, `useCallback` on expensive computations or components receiving new object/array references on every render. Objects/arrays created inline in JSX props.	Minor
`PERF`	Large bundle imports	`import _ from 'lodash'` (imports entire library), `import moment from 'moment'` (large library where `date-fns` or `dayjs` suffice), `import * as icons from 'icon-library'`.	Minor
`PERF`	Missing lazy loading	No `React.lazy()` / dynamic `import()` for route-level code splitting. Heavy components loaded eagerly on initial page load.	Minor

Optional Script Integration

When scripts/complexityscorer.py output is available (run by the orchestrator during /codeprobe audit), use it to identify high-complexity functions as performance hot-spot candidates. Functions rated "high" or "veryhigh" that also appear in hot paths (request handlers, loop bodies, frequently-called utilities) are strong signals for algorithmic efficiency findings.

ID Prefix & Fix Prompt Examples

All findings use the PERF- prefix, numbered sequentially: PERF-001, PERF-002, etc.

Fix Prompt Examples

"In OrderController@index (line 22), add ->with('items', 'customer') to the Order::query() call to fix the N+1 problem — currently loading 2 relations lazily inside the Blade loop at orders/index.blade.php:15."
"Replace Product::all() at line 30 of CatalogService.php with Product::query()->paginate(25) or Product::cursor() if processing all records. The current query loads all products into memory."
"In ReportGenerator@aggregate (lines 45-60), the nested loop iterating $orders inside $customers is O(n*m). Build a lookup hashmap before the outer loop: $ordersByCustomerId = collect($orders)->groupBy('customer_id')."
"Replace import _ from 'lodash' at line 3 of src/utils/helpers.ts with specific imports: import debounce from 'lodash/debounce' to reduce bundle size."

codeprobe-performance

Installation

Similar popular skills

Also in this package

Agent compatibility

Repository health

Skill metadata

Package contents

History

SKILL.md