Your coding agent has already explored the repository, made some changes, and understands the task. Then you notice the five-hour allowance is at 99%.

The session doesn't necessarily have to stop.

If you already have useful context in that session, you can hand it off instead of reconstructing everything somewhere else.

Handoff the session

Inside the coding-agent session, use the lightweight handoff skill to hand the current work off to AI Badger.

Hand this session off to Badger.

The skill writes a compact summary of the useful session state: the goal, important decisions, constraints, completed work, verification, and what still needs attention.

Then open another terminal in the same project and run:

badger continue

Badger picks up that session state, collects the relevant repository context locally, and prepares a continuation prompt.

Copy it into ChatGPT, Claude, or another AI chat and continue the conversation there.

That's it.

coding agent
    ↓
  handoff
    ↓
badger continue
    ↓
browser AI chat

You don't have to explain the project again, manually collect a bunch of files, or reconstruct what was already decided.

And you don't need the remaining 1% of the coding-agent allowance just to keep discussing the task.

The skill and the CLI are separate installs. The skill carries conversation state. Badger collects current repository context itself:

brew install pvrlabs/tap/badger
badger skills install

Quota is just one reason to hand off

I didn't build handoff specifically for running out of quota.

I built it because sometimes a coding-agent session reaches a point where continuing in that same terminal session doesn't make much sense anymore.

Maybe the implementation has reached a natural checkpoint and you want to brainstorm what to do next.

Maybe you want to step away from editing and review the approach.

Maybe the session has become large enough that compaction is coming and you'd rather move the useful context into a fresh conversation.

Or maybe the five-hour allowance is at 99%.

In all of those cases, the work can continue even though the current session probably shouldn't.

The useful part is that the handoff skill doesn't try to package the repository itself. It carries the conversation state. When you run badger continue, Badger independently collects the current repository context locally.

That means you can move into a browser AI chat with both sides of the problem: what the session has been discussing and enough current project context to continue meaningfully.

The destination can also be a different model. The prompt can go into ChatGPT, Claude, Gemini, DeepSeek, Grok, or another AI chat.

The session can end before the work does

A 99% quota makes the transition very obvious.

But quota isn't really the important part.

Sometimes you've simply reached the end of what makes sense to do in the current coding-agent session. You want to brainstorm, review, get a fresh context, use another model, or continue somewhere that is better suited to the next phase.

The annoying part has always been carrying enough context with you.

That's what I use handoff for.

The session can end without starting the task over.

There is a broader workflow behind this idea: separating reasoning from execution, using web AI for deeper discussion and coding agents when you actually need repository tools and edits.

I'll cover that separately.