When unerr is NOT the right tool

Most tools tell you who they're for. Fewer tell you who they're not for — which is the more useful information, because it's the difference between a tool solving your problem and a tool adding itself to it. So, plainly: the cases where unerr is not the right tool, and what to do instead.

Your repo is small enough to fit in context

If your whole codebase is a few thousand lines, the agent can hold it — a structural map of something the model can simply read adds a layer without adding leverage. The 76% read-token problem is real, but on a small repo the absolute numbers are small too.

Do instead: a lean rules file for conventions, fresh sessions per task, and you're most of the way there. Revisit when navigation visibly dominates your sessions — it scales with the repo, and the threshold arrives earlier than most people expect (roughly: when the agent starts grepping instead of knowing).

You're solo and your bill doesn't hurt

unerr's pricing is flat-rate per seat, and a meaningful slice of its value is team-shaped: shared conventions enforced across developers, team-level spend attribution, visibility into what agents did across a codebase. Solo, on a subscription plan you don't max out, with a repo you know cold — the savings are real but may not clear the subscription bar.

Do instead: the free levers in our Claude Code and Cursor guides — session hygiene, scoped context, right-sized rules files — cover the solo case well. Estimate your actual waste first; if the number is small, believe it.

Your agent use is chat, not agents

If developers mostly ask questions and accept completions — few long agentic loops, no multi-file autonomous tasks — the quadratic loop costs that unerr attacks barely apply to you. Completions are cheap (on Copilot, still unmetered); short chats don't accumulate context.

Do instead: nothing. Genuinely. Your bill scales linearly and your conventions ship through review. The calculus changes when agent mode becomes the default way work happens — that's the point where bills jump 10–50× and consistency starts drifting per developer.

Your bottleneck is prose, not code

unerr's graph is built from code structure — definitions, callers, imports. If your agents mainly work over documents, tickets and knowledge bases, similarity retrieval is the right primitive and RAG is the right architecture. A code graph has nothing to offer a corpus with no call edges.

Do instead: a retrieval pipeline over your documents, and revisit if code work grows.

You need your agents to run fully air-gapped from any vendor

unerr runs local-first — your code stays on your machine — which satisfies most security postures. But if your environment can't run any third-party software against source code at all, that's a policy gate no architecture passes; self-hosting conversations belong with enterprise, and honesty requires saying the default product isn't that.

And when it is the right tool

The mirror image, for symmetry: a team (not a solo dev) running agents (not just completions) on a codebase too large to hold in context, where the bill or the inconsistency has someone's attention. That's the case the product is built for — here's how it works, here's the measured evidence, and here's the calculator to check whether your numbers justify it. If they don't, the guides above are free and they work.