Smoower.Minified
Compact, ordinary C# that cuts the tokens an AI spends on .NET boilerplate.
When an AI assistant writes ASP.NET Core or EF Core code, most of what it types is not your logic — it is framework ceremony. Task<IActionResult>, FirstOrDefaultAsync, AddScoped, attribute noise, the same controller scaffolding again and again. Every token of that is generated afresh on each write, rewrite, and refactor.
Smoower.Minified swaps that ceremony for short, stable helpers — Tr, .one(), scoped<>, [HG], .ok1() — that compile to the exact same IL. There is no source generator and no transpiler; it is plain C# extension methods, attributes, and type aliases. The behaviour never changes. Only the number of tokens it takes to write the code does.
Why it helps
How it pays off
The token saving is the mechanism; where it actually lands depends on how you pay for your AI — and it is rarely just a smaller bill. Expect roughly 10–25% fewer output tokens across a whole project, and 25–45% on the boilerplate-heavy controller files an assistant rewrites most often.
If you pay per token (API / metered)
Generated code is almost entirely output tokens — the expensive side of the meter, around 5× the price of input on current Claude models. Fewer output tokens is a directly smaller invoice, paid back on every write, rewrite, and refactor of the same file.
If you pay a subscription (Claude Pro / Max, Copilot, Cursor)
There is no per-token line item, so the value is operational rather than financial — and often the bigger deal. Shorter code means more of your codebase fits in the context window at once; agents spend less of their turn and session budget regenerating the same ceremony instead of doing new work; long sessions stay coherent longer before summarization kicks in; and you reach usage or rate limits later in a working day. You are effectively pushing the cap you are paying around further out.
What it saves on real code
Not a toy benchmark — these are untouched production files from a live .NET app, rewritten in the compact style and measured with Claude’s own tokenizer (claude-opus-4-8). On the files that are mostly framework ceremony — a typical API controller — the compact form cuts up to half the tokens. Spread across a whole application, where most of the code is business logic that does not (and should not) compress, the saving settles at up to around a quarter.
Each row below is the same file before and after; behaviour and the compiled IL are identical. This slice is deliberately boilerplate-heavy, so it sits near the top of that range. Browse the originals and their .min.cs counterparts in samples/Individual-Samples, and the full method in bench/FINDINGS.md.
| File | Original | Smoower | Saved |
|---|---|---|---|
AdminAuditController.cs | 7,326 | 5,304 | −2,022 · 28% |
EntryExpiryController.cs | 3,640 | 2,510 | −1,130 · 31% |
ExpiryDashboardController.cs | 4,023 | 2,272 | −1,751 · 44% |
RasepiDbContext.cs (~2k-line EF schema) | 31,713 | 23,993 | −7,720 · 24% |
| Total | 46,702 | 34,079 | −12,623 · 27% |
The code Claude writes is billed as output tokens — the most expensive kind. At Opus 4.8’s current rate of $25 per million output tokens, emitting this sample the verbose way costs $1.17; the compact way costs $0.85. That is ~$0.32 saved every single time these files are written — and AI-generated code is written, rewritten, and refactored over and over across a project’s life.
The honest trade-off
The compact form is terser than verbose C#, and at a first glance less familiar to a human reader. The assistant also needs a small rules prompt so it knows the helpers. Neither is free — but both are paid once and earned back quickly, and what remains is still completely ordinary, debuggable C# that any .NET developer can step through. For AI-heavy projects that is a trade most teams will gladly make. For a one-line script edited by hand, it is not.
See whether it pays off for your workload on Does it pay off?, or go straight to Getting started.