quicken

/quicken — Performance Audit

Cast over the code to reveal what drags and how to hasten it. This is the ad-hoc, in-session successor to the removed optimize background worker: instead of a billed daemon loop re-auditing the whole tree every 15 minutes and writing to a report nobody reads, /quicken runs when you ask, scopes to what actually changed, and surfaces findings in the conversation where you can act on them.

Arguments: $ARGUMENTS

Phase 1: Memory first (gate requirement)

mcp__moflo__memory_search { query: "<the hot symbols/files in scope> performance", namespace: "patterns" }

Also check code-map for where the audited symbols live and learnings for prior perf decisions on this codebase (don't re-litigate a deliberate tradeoff).

Phase 2: Decide scope

Pick the smallest scope that answers the ask — a whole-codebase re-audit is exactly the waste this skill was built to end.

Argument	Scope
(none)	The current diff: git diff HEAD + git diff main...HEAD. Audit the changed hot paths only.
a path or glob	That subtree (e.g. /quicken src/api).
an area in prose	Resolve to files via code-map search, then audit those.
--all	Whole codebase. Only on explicit request — say so and expect it to be slower.

If the diff is empty and no target was given, ask what to audit rather than defaulting to --all.

Phase 3: Audit

Read the in-scope code and look for, in rough order of typical impact:

1. N+1 / repeated I/O — queries or fetches inside a loop that could be batched or hoisted; missing IN (...) / Promise.all.
2. Redundant computation — work repeated per-iteration that is loop-invariant; recomputing a derived value that could be memoized; re-parsing/re-serializing.
3. Algorithmic complexity — accidental O(n²) (nested .find/.includes over the same list, building a Set/Map would make it O(n)); unbounded growth on a hot path.
4. Caching opportunities — pure, expensive, frequently-called functions with no memoization; missing HTTP/DB result caching where staleness is acceptable.
5. Framework-specific — React: re-renders from unstable props/callbacks (missing useMemo/useCallback/memo), context that re-renders the tree; server: sync work on the request path that could be deferred.
6. Memory leaks — listeners/timers/subscriptions never torn down; growing module-level collections; closures pinning large objects.