flow-lean

Florian BRUNIAUX · AI Founding Engineer @ Méthode Aristote
13 years from developer to CTO / VP Eng · Blog ↗ · Projects ↗

Lean output mode for Claude Code: minimal solution, action-first structure, zero-fat density.

Examples ·
Install ·
What it does ·
Why ·
Eval ·
Changelog

Examples

By task type. Compression scales with what's being asked, not blindly with
the level:

Situation	Without flow-lean	With flow-lean
Implement a feature	Great question! There are a few different ways you could approach this. Let me walk you through the options before we decide together.	Run `pnpm add zod`, then wrap the input at `src/schema.ts:12`. Proof: `pnpm test schema`. One risk: the existing `parse()` throws on null, handle it or the API 500s. Rest is mechanical.
Tradeoff: SSR or SSG for a high-traffic blog	Both have tradeoffs worth considering. SSR gives fresher content on every request but costs more server load. SSG is faster and cheaper to host but content can go stale between builds. It depends on your specific needs and traffic patterns.	Use SSR, not SSG. A high-traffic blog changes often enough that stale SSG pages cost more in lost engagement than the extra server load costs in infrastructure. Cache the SSR output at the edge to close most of the performance gap.
Factual lookup, `/flow-lean ultra`	To find the last commit that changed a file, you can use the git log command with a path filter, which will show you the commit history for that specific file.	`git log -1 --format=%H -- src/auth.ts`

By level. The task-type gate above always wins, but at the same task type
the level still sets the default density. Same prompt ("what's the difference
between debounce and throttle") at each level:

Level	Response
`lite`	Debounce waits until input stops for a set delay, then fires once, useful for a search box you don't want to query on every keystroke. Throttle fires at a fixed interval no matter how often the event repeats, useful for a scroll handler you want running steadily.
`full`	Debounce delays until input stops for N ms, then fires once. Throttle fires at a fixed interval regardless of event frequency. Debounce for a search box, wait for typing to stop. Throttle for a scroll handler, run steadily.
`ultra`	Not shown here. Explanation tasks cap at `full`/`lite` under the task-type gate, `ultra` is reserved for factual and debug lookups, see the git example above.

Install

claude plugin marketplace add FlorianBruniaux/flow-lean
claude plugin install flow-lean@flow-lean

What it does

Three fused disciplines, one rule underneath: every token earns its place.

ponytail: minimal solution, ladder from "skip it" down to "the minimum code that works"
adhd: action-first, command or verdict in line one, numbered steps
caveman: zero-fat density, cut every sentence that carries no decision

Compression scales with task type (factual and debug compress hard, tradeoffs
barely move) and intensity level (lite / full / ultra, switch with
/flow-lean lite|full|ultra). Suspends automatically on destructive actions,
security, and high-stakes tradeoffs.

Full mechanics: skills/flow-lean/SKILL.md.

Why

Three existing skills already push toward less verbose output, each covering a
third of the problem. Caveman, the most widely used of the three, compresses
prose (zero preamble, symbols over words, code and commands kept byte-exact)
but does not touch what gets built or how it is structured. Ponytail decides
what to code (YAGNI, stdlib before a library, one line before ten) but not the
form. i-have-adhd decides the form (action-first, numbered steps, proof by
command) but not the density. Stacked together they step on each other, and two
of adhd's own rules are actively harmful: estimating in minutes, and stripping
tangents in a way that can hide a real risk.

flow-lean fuses the three under one rule instead of three overlapping ones:

ponytail            adhd             caveman
(what to code)    (the form)      (the density)
      \                |                /
       \_______________|_______________/
                        |
                        v
               +------------------+
               |     flow-lean    |   one rule:
               +------------------+   every token earns its place
                        |
          ______________|______________
         /               |              \
        v                v                v
   never ultra      compression      size in effort,
   a decision        OFF on risk       not minutes

Where it goes further than any of the source skills:

It never compresses a decision. A tradeoff or recommendation gets its verdict
in sentence one, then stays close to full prose. Compress a tradeoff too hard
and only the reasoning for the rejected option survives, so the reader infers
the opposite of the recommendation. Anthropic tested a uniform 100-word cap on
its own models, measured a 3% accuracy drop, and reverted it after a week.
"Just be terse" is a measured mistake, not a style choice.
It drops compression entirely on destructive actions, security and secrets,
or a tradeoff with real money on the line, full clear prose there instead.
It sizes work in effort or steps, never in minutes, a confident "15 min" from
a model is a guess dressed up as a fact.

Measured net compression on mixed work lands around 20-30%, not the 50-75%
Caveman's own README cites, those bigger figures hold for verbose prose or
explanation, not general use.

Eval

EVAL.md is a 13-case regression battery, form (density, gate,
auto-suspend) and fact (no invented specifics) graded apart. Run it in a fresh
session after any change to SKILL.md to catch regressions before they ship.

evals/ is a separate, real API-backed harness (forked from
i-have-adhd's own eval script) that
blind-judges flow-lean against a plain baseline and against each of the three
source skills, same 13 cases, weighted rubric in
evals/rubric.md:

vs	baseline	flow-lean	comparator
plain baseline	4.32	4.52	n/a
caveman	4.24	4.62	3.98
ponytail	4.28	4.80	4.57
i-have-adhd	4.12	4.85	4.21

flow-lean wins the weighted score in every run, driven mostly by
decision-fidelity and concision, the two dimensions none of the three source
skills individually target. This is a single trial per case (n=1, Claude
Sonnet 5), not a proof: re-running the same comparison during development
moved the weighted score by 0.2-0.3 points on an unchanged skill, and one run
surfaced a real regression (compression dropping a safety detail) that got
fixed and re-verified, see commit history in evals/results/ for the full,
uncherry-picked trail including the runs that failed. Raw responses and judged
scores: evals/results/.

Credits

flow-lean fuses three disciplines from three existing Claude Code skills:

caveman: zero-fat density
ponytail: minimal solution ladder
i-have-adhd: action-first structure

License

MIT, see LICENSE.