A Fat System Prompt Beats Fighting a Generic Mode

Three corrections in, you're still explaining.

"No, not like that. Use recursive merge. Check the lock file first."

Each correction burns tokens. Each correction bloats context. And the model still doesn't know what you meant.

The correction tax

You open code mode to resolve a merge conflict. The model suggests a fix. It's wrong. You explain why. It tries again. Still wrong, but differently. You add another correction.

Now your context includes: the original request, the first wrong attempt, your correction, the second wrong attempt, and your second correction. The model is working with all of that noise, trying to infer what you actually want.

By the third loop, you've spent more tokens on back-and-forth than you would have spent on a detailed upfront prompt. And the model is now reasoning through a messy conversation history instead of clear instructions.

This is the correction tax. Every time you fix a generic mode's assumptions, you pay it.

The alternative: instructions that already exist

A specialized mode with a 1,000-line system prompt doesn't need your corrections. The instructions are already there.

The tradeoff looks counterintuitive. That fat system prompt costs tokens upfront. But it changes the math: one-shot completions replace multi-turn loops.

"You can go and use the code mode to try and resolve some conflicts on a PR and you're going to be stuck in there for an hour. You know, with that mode, it, you know, the instructions are quite detailed, but it just one shots the conflicts."

Guest, Roo Cast S01E02

The specialized mode doesn't guess your workflow. It already has the workflow encoded: which files to check first, how to handle lock files, when to abort and ask for human input.

Where the generic mode breaks

Generic modes optimize for breadth. They handle many tasks adequately. But "adequately" means you become the gap-filler.

Every domain-specific assumption you haven't taught it becomes a potential failure. And teaching it happens through corrections, one at a time, in conversation history that disappears when the task ends.

"If you're for example running code mode and you need to give instructions for example to solve a merge conflict and then it fails and then you need to say oh you need to do it like this, that adds up eventually to the point where it's just simpler to send detailed instructions rather than having to go back and forth getting it to do what you want for a more generic mode."

Guest, Roo Cast S01E02

The correction loop isn't just inefficient. It's fragile. Next week, you'll have the same conversation again, because the model didn't learn from last time.

The real cost comparison

Token cost is the obvious metric. But the hidden cost is time spent re-explaining.

Generic mode on a merge conflict: 4-5 turns of correction, an hour of elapsed time, context bloated with failed attempts.

Specialized mode on the same conflict: one prompt, one completion, done.

The 1,000-line system prompt isn't overhead. It's amortized knowledge. You pay for it once in the mode definition. You recoup it on every task that would have needed correction.

Generic mode vs. specialized mode

Why this matters for your workflow

If you're running the same type of task repeatedly, and each time requires teaching the model your preferences, you're paying the correction tax on loop.

Specialized modes front-load the teaching. The system prompt encodes what you would have corrected, before the model makes the mistake.

For engineers running 5-10 similar tasks per week, the compounding is real. Five corrections per task, five tasks per week, that's 25 correction turns replaced by zero. The token math favors the fat prompt. The time math favors it more.

How Roo Code eliminates the correction tax

Roo Code's custom modes let you encode your domain knowledge once and reuse it indefinitely. Instead of correcting a generic AI assistant through multi-turn conversations that bloat context and burn tokens, you create a specialized mode with detailed instructions that closes the loop on the first attempt.

With BYOK (bring your own key) pricing, you pay directly for tokens used - which means the efficiency gains from specialized modes translate directly to cost savings. A mode that one-shots merge conflicts instead of requiring five correction turns saves real money on every task.

The pattern is simple: if you've corrected the same behavior three times, write it into a mode and stop paying the correction tax.

When to invest in a specialized mode

If you've corrected the same behavior three times across different tasks, write it into a mode.

The threshold is simple: if the correction is predictable, it should be in the system prompt. If it's not in the prompt, you'll keep paying for it.

Build the mode once. Stop explaining twice.