Cast your code into shape: meet /quicken and /ward

Two new MoFlo skills you cast like spells — one to quicken what drags, one to ward what isn’t tested — and both answer right in your Claude Code session.

GitHub: github.com/eric-cielo/moflo
npm: npmjs.com/package/moflo — npm install --save-dev moflo

Good review shouldn’t make you go looking for it. MoFlo 4.11.2 adds two on-demand audits that read exactly what you’re working on and report back in the same conversation — with fixes you can apply and test skeletons you can paste.

The idea: cast it, and it answers where you are

Static analyzers dump reports into a folder. Background jobs churn away out of sight. Both make you break focus to find out what they learned. /quicken and /ward do the opposite — you invoke them from inside your Claude Code session, and the findings arrive right there in the thread: ranked, specific, and ready to act on.

By default each spell scopes to your current diff — the code you actually changed, not the whole repository. Point it somewhere on purpose when you want to: /quicken src/api audits just that subtree. Name nothing, and it reviews what’s in flight.

MoFlo previously performed these activities in the background, but targeting was broad and the output wasn’t well surfaced. This also burned tokens unnecessarily, and it could be significant on a large project. Now we’ve repackaged these as on-demand skills to resolve the issues and surface them where they are most useful.

/quicken — a performance pass that shows its work

Ask it to quicken the orders path and it reads the code, finds what drags, and explains the cost in plain terms — each finding anchored to a file and line, with a minimal fix sketch that fits the surrounding style.

claude code — /quicken

/quicken src/api/orders.ts

⚡ Performance audit — 3 findings (scoped to your diff)

HIGH  N+1 query in loadOrders()          src/api/orders.ts:42
      One SELECT per order row — ~N round-trips per request.
      → Batch into a single query keyed on the id set:

        const items = await db.query(
          'SELECT * FROM line_items WHERE order_id = ANY($1)', [ids]
        )

MED   Unstable callback re-renders <OrderList>  OrderList.tsx:88
      onSelect is rebuilt each render → all rows re-render.
      → Wrap in useCallback keyed on [orderId].

MED   Redundant JSON.parse in a hot loop       orders.ts:71

Apply these fixes? (1 high, 2 medium)

Findings ranked by impact. It offers to apply them — nothing changes until you say so.

/ward — test gaps, closed with a skeleton you can paste

Ward reads the same diff, checks MoFlo’s memory for what’s already covered, then hands you the gaps that carry real risk — each with a runnable skeleton written in the project’s own test framework.

claude code — /ward

/ward src/config

🛡 Test-gap audit — 4 gaps (scoped to your diff)

HIGH  parseConfig() error paths untested   config/parse.ts:23
      Throws on malformed YAML and on a missing key — neither
      failure is exercised by a test.
      → paste-ready:

        it('throws a clear error on malformed YAML', () => {
          expect(() => parseConfig('a: : :'))
            .toThrow(/invalid yaml/i)
        })

MED   defaults() drops unknown keys silently  parse.ts:57
      No test asserts the pass-through behavior.

Write these skeletons into the test tree? (1 high, 3 medium)

Skeletons match your runner, naming, and assertion style — copy them in, fill the fixtures, done.

What each spell surfaces

Spell	Looks for	Hands you
/quicken	N+1 queries, needless re-renders, missing caching, memory leaks, redundant computation, hot-path complexity	Ranked findings with a minimal, idiomatic fix sketch per item
/ward	Untested functions, uncovered edge cases, missing error-handling and integration tests	Paste-ready test skeletons in your framework, ranked by risk

Cast it and it answers in the thread — purposeful, in-context, and only ever a suggestion until you say go.

Why it feels different

Reviews the diff, not the world. It looks at what changed — faster, more relevant, and it never re-audits code you didn’t touch.
Answers in the conversation. Ranked findings with concrete fixes, right in the thread — not filed to a report you’ll never reopen.
Runs when you cast it. No background process, no wondering what your assistant is up to. You choose when it runs and what it touches.
Remembers your calls. Each spell checks MoFlo’s memory first, so it won’t re-flag a tradeoff you already decided on.
Suggests before it touches. Both analyze and propose; applying a fix or writing a test happens only on your say-so.

Getting started

Both ship in MoFlo 4.11.2 and install into any project on flo init. Type a spell with no arguments to see its full usage, or aim it at a path:

/quicken — performance audit of your current diff (alias /perf-audit)
/ward — test-gap audit of your current diff (alias /test-gaps)
/quicken src/api — audit a specific subtree instead of the diff

Why this matters

The best review is the one you actually read. By pulling performance and coverage checks into the moment you’re already working — scoped to the change in front of you, answered in the thread, acted on with a keystroke — /quicken and /ward turn two chores you’d otherwise skip into a two-word habit. Cast them before your next merge and see what they surface.

A better Claude, one package install.

GitHub: github.com/eric-cielo/moflo
npm: npmjs.com/package/moflo — npm install --save-dev moflo