Does it pay off?

faster, cheaper, lighter on context. measured on real production code.

The promise is simple: an AI that writes less boilerplate writes faster, costs less, and keeps more of its context window free. To see how much of that survives real code, we ran Smoower over a slice of a live .NET app: a handful of production API controllers and one sprawling EF Core DbContext of nearly 2,000 lines. Then measured before and after with the model’s own tokenizer.

What the real code showed

The compact form came out smaller everywhere it touched framework ceremony. Typical controllers dropped around 30%. The most boilerplate-heavy lost up to 50%. Even the giant DbContext, almost all schema config, came down around 25% once the EF Core helpers were applied. Across the whole sample, on untouched real-world code, the saving landed near 25%.

up to 50%
on the most boilerplate-heavy controllers
around 25%
across a whole real-world slice, schema config included

Faster: the strongest claim

Models emit output one token at a time, so the wall-clock time to produce a file tracks its length almost linearly. Cut the ceremony in half and you roughly halve the time spent streaming it out. The rules prompt is read once, in parallel, and cached, so it barely touches latency. This is the benefit that holds up most cleanly.

Cheaper: after a small, one-time cost

Output tokens are billed, and they cost several times more than input (around 5x on current Claude models). The compact code emits fewer of them on every file. Against that sits one cost: a short rules prompt the assistant keeps in context. That's input, not output, paid once per session, and cached. On any project that generates more than a file or two it pays for itself fast, and everything after is saving.

Lighter on context: compounds over a session

In a long session, everything already written gets re-read on every later turn. Code that's 25% to 50% smaller leaves more headroom before the window fills, makes each later turn a little cheaper, and pushes summarization further out. On subscription tools (Claude Pro/Max, Copilot, Cursor) this is where the value lands: more of your codebase fits at once, agents spend less of their budget regenerating ceremony, and you hit usage limits later in the day.

The bottom line. For an assistant writing ASP.NET Core and EF Core across a session, all three show up on real code: faster (the cleanest win), cheaper (after a sub-one-file break-even), and lighter on context (it compounds over turns). The runtime behavior is identical, since the compiled IL doesn't change. The full arithmetic and the per-file numbers are in bench/FINDINGS.md.

Where to next