/btw vs Forking Context: Which Claude Code Feature to Use?

Mar 12, 2026

Purpose

I want to understand when to use /btw versus forking context in Claude Code. Both help manage side questions, but they work differently and have different use cases.

Quick Comparison

Feature	/btw	Forking Context
Persistence	Ephemeral - lost after dismiss	Persistent - creates new session
Tool Access	None	Full tool access
Context Pollution	None - doesn’t add to history	Forked copy of current context
Token Usage	Minimal - no agent interaction	Full session tokens in fork
Conversation Continuity	One-shot Q&A	Can continue conversation
Setup Required	Built-in command	Requires keyboard shortcut or manual setup
Best For	Quick lookups, one-off questions	Exploring tangents, parallel workstreams

What is /btw?

/btw is Claude Code’s quick-lookup feature for ephemeral questions:

/btw what's the difference between useMemo and useCallback?

Characteristics:

Ephemeral - answer lost after dismiss
Lightweight - no full agent interaction
No tool overhead - cannot read files or run commands
Minimal token burn

When to use /btw:

Quick syntax checks: “What’s the flag for verbose output in npm?”
Concept clarifications: “What does ‘as const’ do in TypeScript?”
Mid-task orientation: “What’s the pattern for error handling here?”
Pre-task sanity checks: “Is this the right approach for X?”

Limitations:

One response only - no back-and-forth
No tool access - can’t read files or run commands
Lost after dismiss - no history preservation

What is Forking Context?

Forking creates a separate terminal session that branches from your current conversation state:

Characteristics:

Full session copy - current context state is duplicated
Conversation continuity - ask follow-up questions, explore tangents
Full tool access - can read files, run commands, execute tools
Parallel workstreams - work on multiple related tasks simultaneously

When to use forking:

Exploring implementation alternatives
Debugging a separate issue discovered mid-task
Creating documentation while implementing
Parallel investigation threads

Decision Framework

Use this decision tree:

Q: Do you need tool access (read files, run commands)?
├─ YES → Use Forking
└─ NO
    └─ Q: Do you want to continue the conversation?
        ├─ YES → Use Forking
        └─ NO
            └─ Q: Do you want to preserve the exchange?
                ├─ YES → Use Normal Prompt (not /btw)
                └─ NO → Use /btw

Use /btw When:

You need a quick answer that doesn’t warrant a full exchange
The question is tangential to your main task
You don’t need tool access
You want to preserve context window space
The answer is disposable - you won’t need to reference it later

Use Forking When:

You want to explore a tangent that needs its own conversation
You need tool access for the side question
The tangent might evolve into its own task
You want to preserve the exploration in a separate session
You might need to revisit or continue the side quest later

Practical Examples

Example 1: /btw for Quick Lookup

# Main terminal session
User: Refactor this authentication module to use JWTs
Claude: [Working on refactor...]

# Side question without derailing
User: /btw what's the difference between HS256 and RS256?
Claude: [Overlay shows explanation]
User: [Press Escape, continue with main task]

# Main conversation history remains clean
# No record of HS256/RS256 question

Example 2: Forking for Tangent Exploration

# Main terminal session
User: Implement a REST API for user management
Claude: [Working on API implementation...]
Claude: I notice the database schema might need adjustment for...

# User wants to explore schema separately
User: [Keyboard shortcut to fork context]

# New terminal opens with forked context
# User can now:
# - Ask follow-up questions about schema
# - Have Claude read migration files
# - Run database commands
# - Explore schema alternatives

Example 3: Combined Workflow

# Phase 1: Pre-task orientation with /btw
/btw what's the typical pattern for rate limiting in Express?
/btw what's the difference between express-rate-limit and rate-limiter-flexible?
# Quick answers, no context pollution

# Phase 2: Start main task
User: Implement rate limiting for our API endpoints

# Phase 3: Need to explore specific implementation
User: [Fork context to new terminal]
# In forked terminal: explore different rate limiting strategies
# Run tests, read docs, discuss trade-offs

# Phase 4: Return to main task
User: Use rate-limiter-flexible with Redis backend
# Continue implementation with decision made

The “Steer” Feature Gap

Reddit users noted a comparison to Codex’s “steer” feature:

“Codex has the ability to ‘steer’ the conversation mid agent run instead of queuing the message. I wish CC had the same”

This represents a third approach not currently in Claude Code:

Approach	Description
Steer (Codex)	Modify the current agent’s direction mid-execution
/btw (Claude)	Side question without affecting agent
Fork (Claude)	Create parallel session

Context Push/Pop Pattern

A Reddit user described a custom approach that combines both benefits:

“I have a context push/pop command I built, basically the same except I get a summary of the ‘side quest’ in the main context”

This hybrid approach:

Push: Start a side exploration
Explore: Full conversation with tools
Pop: Return to main context with summary injected

Benefits:

Full exploration capability (like forking)
Context preservation with summary (like /btw)
No permanent context pollution

Summary

In this post, I compared /btw and forking context in Claude Code. The key point is the difference between ephemerality vs persistence: /btw is for quick, disposable lookups without context pollution, while forking creates a persistent parallel session with full tool access. Use /btw for quick questions, use forking when a tangent deserves its own conversation.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

👨‍💻 Reddit: Claude just released /BTW and it's clutch
👨‍💻 Claude Code Documentation

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!