agentleFS
eric-cieloeric-cielo/moflo/.claude/skills/quicken/SKILL.md

quicken

Skill19 starsChanged 3 months agoMITView on GitHub

Quicken the codebase — an ad-hoc performance audit that reveals what drags (N+1 queries, needless re-renders, missing caching, memory leaks, redundant computation, hot-path complexity) and prescribes the fix, surfaced inline in the session. Scoped to your current diff by default, or to a path/area you name. Use before a perf-sensitive merge, when something feels slow, or when you want a targeted optimization pass. Replaces the old always-on `optimize` daemon worker (alias: /perf-audit).

The file

We split this skill into the rules it gives an agent

3 rules. About 0 are common, 1 is distinctive, and 2 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈1

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 2

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Very specific:

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

    line 32
  2. Distinctive:

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

    line 36
  3. Very specific:

    Only flag things you can point at with file:line.

    line 45

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

/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.

ArgumentScope
(none)The current diff: git diff HEAD + git diff main...HEAD. Audit the changed hot paths only.
a path or globThat subtree (e.g. /quicken src/api).
an area in proseResolve to files via code-map search, then audit those.
--allWhole 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.

Only flag things you can point at with file:line. Skip micro-optimizations with no measurable payoff — altitude matters, don't drown a real finding in nitpicks.

Phase 4: Surface findings inline

Report in-thread, ranked most-impactful first. For each:

  • What & where — one line + file:line.
  • Why it drags — the concrete cost (e.g. "runs a query per row, ~N round-trips").
  • The fix — a short code sketch (fenced block). Keep it minimal and idiomatic to the surrounding code.

End with a one-line summary (e.g. "3 findings: 1 high (N+1 in loadOrders), 2 medium"). If nothing meaningful turns up, say so plainly — a clean audit is a valid result.

Phase 5: Offer to act

Ask whether to apply the fixes. Only edit when the user confirms (or if they invoked with a clear "fix it" intent). If the audit was large and the user wants a record, offer to write it to .moflo/reports/quicken-<scope>.md — but the in-thread report is the primary deliverable, not a file.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.