IBM Bob Cost Control Starts With Context Hygiene

Reduce Bobcoin burn and session drift by narrowing MCP scope, keeping chats task-sized, and treating context as an operating budget.

Use .bobignore, narrower MCP toolsets, smaller @ mentions, and fresh chats to keep Bob useful and Bobcoins boring.

Open Bob and watch the token counter in the top-right corner before you ask it to do anything clever. That little number tells a more honest story than most AI coding demos.

The current IBM Bob context window docs say the IDE works inside a 200,000-token context window and starts condensing older context at 140,000. The current Bobcoins docs also make the billing model clear: Bob charges in Bobcoins, not raw tokens, but the token counter is still the best early warning system.

So the expensive part is usually not one bad prompt. It is the quiet pileup: old chat history, broad folder mentions, @terminal dumps, full diffs, and MCP tool catalogs you connected because they seemed harmless at the time.

What you need

You need a real repository, Bob, and five minutes of honesty about how you actually work. A toy demo does not make context mistakes visible.

• IBM Bob IDE or Bob Shell

• One repository with enough real files to make scoping matter

• Optional MCP servers, if you already use them

• Optional GitHub CLI or plain git for narrower local-change reads

• About ☕️☕️

Where the budget actually goes

Long chats get more expensive even when the next prompt is simple

Bob’s context window management docs are direct about this. Each interaction processes the active context again, which means the same old history keeps getting paid for. When a conversation gets large enough, Bob condenses older material to stay within the window. That helps performance. It does not make bloated sessions cheap.

A feature chat, a bug chat, and a review chat should not be the same chat.

Tool output is usually fatter than the prompt

Bob counts command output, file reads, and other tool results in the same context window. That means one broad diff or terminal dump can outweigh ten careful user messages.

This is why @terminal and @git-changes are useful and a little dangerous. They are convenient because they pull in real state. They are expensive for exactly the same reason.

IBM Bob Needs a Context Budget Before It Needs More Tools

Broad @ mentions are quiet context bombs

Bob’s context mentions docs are great when you use them with intent. They are expensive when you treat them like a repo-wide searchlight.

The current docs support narrow references like @/src/service/UserService.java:40-88. They also support folder mentions, @terminal, @problems, @git-changes, and even URLs. Do not feed Bob three screens of context for a two-line change.

MCP tools cost tokens before the task really starts

This is the tax people miss first.

Bob’s context docs say MCP tool definitions live inside the context window. If you connect a large server with a broad tool surface, Bob carries those definitions before it reads a single file for the task. In a separate measurement in this repo, the default GitHub MCP Server surface was already around 17,000 tokens before the first real question.

One-time setup that lowers the baseline

Add a .bobignore

The current ignoring files docs recommend .bobignore for exactly the cases that also waste context: build artifacts, large assets, secrets, and files Bob should not touch in normal work. The syntax matches .gitignore, and Bob reloads the file automatically when you change it.

Start with something small and boring:

node_modules/
dist/
build/
target/
coverage/
*.log
*.lock
.env*
__pycache__/
*.pyc

The goal is to keep useless noise out of the workspace in the first place.

The docs also call out limits: .bobignore is not a full sandbox, and some edit paths still have gaps. I still use it. It is the right first layer for both safety and context hygiene.

Keep MCP project-specific and disable tools you do not need

Bob’s context docs and the large-project guidance make the same point in different words: every connected tool has a footprint.

If a repository only needs pull request review, do not drag in issue mutation, repository admin, or unrelated cloud tooling just because it is available globally. Put the narrower setup in project config. Disable unused tools. Prefer read-only surfaces for review-oriented work.

Default to Code mode and use Advanced on purpose

Bob’s mode docs say Code mode is the day-to-day coding default and is optimized for cost efficiency. Advanced exposes all tool groups, including MCP, and is where skills work.

That gives you a clean rule:

• Use /code for ordinary edits, refactors, and tests

• Use /ask when you want explanation or analysis

• Use /plan to shape the work before you start editing

• Use /advanced only when you actually need MCP, full tool access, or skills

A lot of Bob sessions do not need the kitchen sink.

If your team repeats the same workflow often, custom modes are worth a look too. A narrow mode is often a better habit than living in Advanced all day.

Keep skills small, focused, and reusable

Bob skills are powerful, but the useful version is not a giant kitchen-sink SKILL.md. The skills docs recommend a concise main file plus supporting files. That matches what I have found in practice too.

Use skills for repeated workflows. Keep SKILL.md short. Move checklists, templates, and reference details into supporting files beside it. Let Bob load the workflow when it fits instead of retyping a long prompt every time.

If you use Bob Shell, the same reuse pattern applies to custom slash commands under .bob/commands/. A good command is a small reusable handle, not a place to hide a novel.

Session habits that actually reduce Bobcoin burn

Keep one task per chat

This is the highest leverage habit in the whole article.

Bob’s docs explicitly recommend starting a new chat when you switch tasks. Do that. A bug hunt, a refactor, and a docs rewrite do not help each other just because they happened on the same afternoon.

If the topic changed, the chat should change too.

Mention files and line ranges, not folders and vibes

The docs support exact file and line-range mentions for a reason. Use them.

Good:

@/src/main/java/com/example/OrderService.java:84-145
Fix the retry logic in this method without changing the public API.

Bad:

@/src
Review everything related to retries.

Folder mentions are real context. So are full-file mentions. Spend them where they buy you something.

Treat @terminal and @git-changes like expensive inputs

@terminal brings in the last command and its full visible output. @git-changes brings in git status plus the diff of uncommitted changes. That can be perfect for a small failure or a tiny patch. It is awful as a reflex on a noisy branch.

For local-change work, start with the cheap questions:

git status --short
git diff --stat
git diff --name-only

Then narrow only where it matters:

git diff -- src/main/java/com/example/OrderService.java
git diff -- src/test/java/com/example/OrderServiceTest.java

This is the same rule I use for GitHub work in Bob: narrow the catalog first, then narrow the payload.

Use Plan or Ask before you open the full tool surface

The original expensive mistake is usually not “Bob wrote the wrong line.” It is “I invited Bob into a broad task before I knew what the task actually was.”

For bigger work, spend one short turn in /plan or /ask first. Define the slice. Decide which files matter. Then switch into /code or /advanced when you know where the edits should land.

A cheap planning turn is better than an expensive wandering session.

Keep your own session notes instead of trusting a huge chat

When a session reaches a useful stopping point, write a small note file like session-notes.md:

• What we changed

• What is still open

• Which files matter next

• Which command or test failed last

Start the next chat by mentioning only that file or the specific lines that matter. That is much cheaper than dragging a swollen conversation forward and hoping Bob’s condensed memory kept the one detail you cared about.

Reuse skills and commands instead of rebuilding the same prompt

If you already taught Bob how your repo does review, refactoring, or test scaffolding, use that. Do not pay again for a long freehand setup prompt every time.

Skills exist so you can encode stable workflows once. Commands exist so you can invoke them quickly. Repeated workflows should become repository context, not recurring prose.

How to track whether any of this helped

Watch the token counter live

Bob shows current token usage in the top-right corner of the chat panel. That is your first dashboard. Use it.

If the number is already uncomfortable before the first real task, the session setup is probably too broad.

Track Bobcoin usage separately from token pressure

Bob bills in Bobcoins, not raw tokens. The current Bobcoins docs say you can monitor usage with the gauge in the Bob panel and in Settings under the General tab. If you are on Enterprise, Bobalytics adds longer-range usage views and spending patterns in the Bob web portal.

Use both views for different jobs:

• The token counter tells you when a conversation is getting heavy

• The Bobcoin views tell you whether your habits are actually cheaper over time

Set a baseline before you optimize

Pick one representative task and run it the same way twice:

1. Record the starting token counter and the ending usage view

2. Apply one change from this article

3. Run the same kind of task again

4. Compare

Good baseline tasks are boring:

• Review my local changes

• Fix this failing test

• Explain this class and update one method

• Summarize the risk in this pull request

If you change five variables at once, you learn nothing.

Treat 140,000 tokens as a warning, not a target

Bob’s current docs say automatic condensation starts at 140,000 tokens. That is useful safety behavior. It is not a good session goal.

If you hit condensation often, you are probably mixing too many tasks, carrying too much output, or leaving too many tools connected for the job in front of you.

Red flags I would pay attention to

• The token counter jumps after you connect an MCP server and before you ask a meaningful question

• @git-changes or @terminal becomes your default first move

• You keep mentioning folders when a file or line range would do

• Every task seems to require Advanced mode even when it obviously does not

• Old conversations feel “helpful” only because you are postponing the cost of starting fresh

The system I would actually keep

The useful Bob optimization system is smaller than most people want.

Use .bobignore. Keep MCP surfaces narrow and project-specific. Stay in Code mode unless you need more. Start new chats when the task changes. Mention exact files and line ranges. Treat @terminal, @git-changes, and full diffs as expensive. Reuse skills and commands for repeated workflows. Measure before and after.

That is enough to change the shape of the spend.

Bob is at its best when you decide what deserves attention inside the same 200,000-token window. The model is not bad at context management. It is just honest about the inputs you gave it.