How to Use the /status Line in Claude Code to Monitor Context and Model in Real Time

What the Status Line Actually Shows You

If you’ve spent time in a long Claude Code session, you’ve probably hit that moment where things start feeling off — responses get shorter, earlier context seems forgotten, or a task that should be simple takes longer than expected. More often than not, context pressure is the culprit.

The Claude Code status line (surfaced through the /status command or the persistent footer in the terminal UI) gives you a real-time window into your session’s health. It shows which model is active, how much context you’ve consumed, and what effort level is currently configured. That’s not a lot of information on the surface, but it tells you almost everything you need to know to make good decisions mid-session.

This guide covers exactly what each field means, how to read it correctly, and how to use it to keep long coding sessions productive.

---

Understanding the Status Line Fields

When you run /status in Claude Code, or glance at the bottom status bar, you’ll see a compact display with a few key values. Here’s what each one means.

Model

This is the model currently handling your session. Claude Code supports multiple Claude models — including Sonnet and Opus variants — and the one you’re using has direct implications for speed, cost, and reasoning depth.

• Sonnet models are faster and cheaper. They handle the majority of coding tasks well.
• Opus models are slower and more expensive but significantly better at complex reasoning, multi-step planning, and understanding large codebases.

You might assume you’re on the model you configured at the start of a session, but if you’ve changed settings mid-session, switched profiles, or if a default updated, the active model might not be what you expect. The status line confirms what’s actually running.

Context Usage

This is arguably the most important field. It shows how much of the available context window your session has consumed, typically expressed as a token count or a percentage.

Claude models have fixed context windows. Once you approach the limit:

• Claude may begin dropping or compressing earlier conversation turns
• Instructions and code provided early in the session become less reliable
• The model may appear to “forget” things you’ve already established

Watching context usage in real time lets you intervene before degradation happens — by clearing context, summarizing progress, or starting a fresh session with targeted context loaded.

Effort Level

Effort (sometimes referred to as “thinking” or reasoning intensity) controls how much extended thinking Claude applies to a given response. Higher effort means more thorough reasoning, but it also consumes more tokens and takes longer.

Claude Code exposes different effort tiers:

• Low/Default: Faster, lighter responses. Good for quick edits, lookups, or generation tasks with clear specs.
• High/Extended thinking: Better for architectural decisions, debugging complex failures, or tasks where reasoning quality matters more than speed.

The status line shows which tier is active so you’re not burning tokens on heavy thinking for tasks that don’t need it, or getting shallow responses when you need depth.

---

How to Use the /status Command

Using /status is straightforward. In any active Claude Code session, type:

/status

Claude Code will return a summary of the current session state. The output is intentionally compact — it’s designed for quick reference, not lengthy explanation.

You don’t need to memorize the command. The persistent status bar at the bottom of the Claude Code terminal UI updates in real time and reflects the same information. But /status is useful when:

• You’re in a scrolled-up terminal and want current state without scrolling back down
• You want to check status before starting a significant task
• You’re troubleshooting unexpected behavior (slow responses, apparent context loss)

Checking Status Before Heavy Tasks

Get in the habit of running /status before asking Claude to tackle something significant — refactoring a module, reviewing a full file, or writing a complex algorithm. If your context is already at 70% or more, you may want to clear it or start fresh before loading in the relevant code files.

Starting a heavy task when context is nearly full often leads to partial results, as Claude has to work within a compressed view of your session history.

Monitoring During Long Sessions

For sessions that run longer than 30–45 minutes, context accumulates quickly — especially when you’re pasting in code snippets, error messages, and iterating on solutions. Periodic /status checks let you catch context pressure before it starts affecting output quality.

A reasonable habit: check status every time you start a new sub-task within a session. It takes two seconds and can prevent 20 minutes of confusing, degraded responses.

---

Configuring Model and Effort from the Command Line

The status line is a read-out, but you can also control what it shows through configuration.

Switching Models

You can set the model Claude Code uses at session start with the --model flag:

claude --model claude-opus-4-5

Or switch mid-session using the model picker in the settings UI or by restarting with the appropriate flag. The /status output will confirm which model Claude Code is actually using.

To check what models are available and what your current defaults are:

claude config list

This shows your current configuration including the default model setting.

Setting Effort Level

Effort level can be set globally in your configuration or adjusted for the current session. The --thinking flag controls this in some Claude Code versions, while others expose it through the settings menu or a direct configuration key.

For most day-to-day coding:

• Leave effort at the default unless you’re working on something genuinely complex.
• Enable extended thinking explicitly when you need it (architectural design, debugging subtle issues, understanding legacy code).

This keeps your token usage predictable and your sessions faster.

Auto-Compact Settings

Claude Code includes an auto-compact feature that summarizes earlier context when you’re approaching the window limit. This is a tradeoff: it preserves session continuity, but the summary may drop details that turn out to matter.

You can configure auto-compact behavior in Claude Code settings. If you prefer to manage context manually (which gives you more control), you can disable it and rely on /status to know when to intervene yourself.

---

Reading Context Usage: What the Numbers Mean

The context usage display shows token counts because that’s the unit Claude’s context window operates in. Here’s a rough orientation:

Usage Range	What It Means
0–40%	Plenty of headroom. Work freely.
40–65%	Normal working range for longer sessions.
65–80%	Start being intentional about what you add to context.
80–90%	High pressure. Consider clearing or compacting.
90%+	Degradation likely. Context management is urgent.

These aren’t hard rules — different models have different context windows, and the impact of context pressure depends on what’s in that context. But they’re a useful mental model.

What Consumes Context Fastest

Understanding what burns through context helps you work more efficiently:

• Pasting large files or code blocks — Every character you paste consumes tokens. Paste only the relevant sections.
• Long error messages or stack traces — Trim these to the relevant frames.
• Back-and-forth iteration — Each turn in the conversation adds to context. Long iterative loops accumulate quickly.
• Extended thinking responses — When effort is high, Claude’s reasoning steps also consume context tokens.

When you see context ticking up fast, the /status check tells you exactly where you stand.

---

Managing Context: Practical Strategies

Monitoring context is only useful if you act on what you see. Here are the most effective approaches.

Clear Context When Shifting Focus

When you finish one distinct task and move to another — say, from fixing a bug to building a new feature — clear the context and start fresh. Don’t carry forward a full session’s worth of history that’s no longer relevant.

Use /clear to reset context while keeping your session running:

/clear

Then reload only what the new task actually needs.

Use Targeted Context Loading

Instead of pasting full files, use Claude Code’s ability to reference specific files from your project. Load only the files directly relevant to the current task. Claude Code’s file context tools (like @file.py references) let you bring in what’s needed without bloating the context with everything else.

Summarize Before Clearing

If you’re mid-task and need to clear context but want to preserve key decisions or progress, ask Claude to summarize the current state before you clear:

Before we clear context, give me a summary of what we've built, the decisions we made, and any open issues.

Save that summary somewhere. When you restart, load the summary instead of the full conversation history.

Restart Fresh for Multi-Hour Sessions

For sessions that stretch across hours, a full restart is often more efficient than trying to manage a bloated context. Start a new Claude Code session, load the relevant files, paste in your summary, and continue. You’ll often find Claude responds better with a clean context than in a heavily used one.

---

Common Issues the Status Line Helps Diagnose

The status line isn’t just a monitoring tool — it’s a diagnostic starting point when something feels wrong.

Responses Feel Shallow or Incomplete

Check effort level. If it’s set to low or default and you’re asking for complex reasoning, the effort level may not match the task. Increase it and retry.

Check context usage. At high context pressure, Claude may produce truncated responses because it’s working with a compressed view of your session. Clear context and retry with a targeted input.

Claude Seems to Forget Earlier Instructions

This is almost always a context issue. When context fills up and auto-compact kicks in, summaries may drop specific instructions you gave early in the session.

Fix: Clear context, re-provide your key constraints and instructions, and continue from there.

Responses Are Slower Than Expected

Check the model. If you accidentally have Opus configured when you expected Sonnet, that explains the slowdown. Switch models if speed matters more than depth for the current task.

Check effort level. Extended thinking adds meaningful latency. If you’re doing something simple, switch to default effort.

Unexpected Model Is Running

The /status command directly surfaces this. If you configured Sonnet but the status line shows Opus (or vice versa), check your claude config settings and confirm the active profile.

---

Where MindStudio Fits in Longer AI Workflows

Claude Code is excellent for in-editor coding work. But once you’re thinking about multi-step workflows — where Claude does some reasoning, hands off results to another system, triggers downstream processes, or needs to run on a schedule — a different layer becomes useful.

MindStudio is a no-code platform for building AI agents that connect to business tools, APIs, and data sources. It supports Claude models alongside 200+ others and lets you wire up complex workflows without managing infrastructure yourself.

For developers already working with Claude Code, MindStudio’s Agent Skills Plugin is particularly relevant. It’s an npm SDK (@mindstudio-ai/agent) that lets any AI agent — including agents you build on top of Claude Code sessions — call typed capabilities like agent.sendEmail(), agent.searchGoogle(), or agent.runWorkflow() as simple method calls. The SDK handles rate limiting, retries, and auth so the agent can stay focused on the reasoning layer.

If you’re building automated coding workflows or agents that need to coordinate across systems, MindStudio handles the orchestration layer while Claude handles the reasoning. You can try it free at mindstudio.ai.

---

Frequently Asked Questions

What does /status show in Claude Code?

The /status command shows the current state of your Claude Code session, including the active model (e.g., claude-sonnet-4-5 or claude-opus-4-5), how much of the context window you’ve used (in tokens or as a percentage), and the current effort or thinking level configuration. It’s a quick diagnostic snapshot you can run at any point during a session.

How do I check context usage in Claude Code?

Run /status in your active Claude Code session. The output includes a context usage field showing how many tokens you’ve consumed relative to the model’s context window limit. You can also monitor this in the persistent status bar at the bottom of the Claude Code terminal interface, which updates in real time as you interact with the model.

What happens when Claude Code runs out of context?

When context approaches the limit, Claude Code’s auto-compact feature may trigger — summarizing earlier parts of your conversation to free up space. If auto-compact is disabled or doesn’t activate in time, Claude may begin producing shorter, less accurate responses or appear to lose track of earlier instructions. The safest approach is to monitor context usage via /status and clear or restart before hitting the ceiling.

How do I change the model in Claude Code?

You can set the model at session start using the --model flag (e.g., claude --model claude-opus-4-5), or configure a default model using claude config. Run /status after starting a session to confirm the correct model is active.

What is the effort level in Claude Code and how does it affect performance?

Effort level controls how much reasoning Claude applies to each response. Higher effort enables extended thinking, which produces more thorough output for complex tasks but uses more tokens and adds latency. Default effort is appropriate for most coding tasks. Use higher effort for tasks requiring architectural reasoning, complex debugging, or nuanced decision-making. The current effort level appears in the /status output.

How often should I check /status during a coding session?

There’s no fixed rule, but a useful habit is to check before starting any significant task and periodically during long sessions (every 30–45 minutes or when shifting to a new subtask). The status line becomes most valuable at context levels above 65%, where usage decisions start to affect response quality.

---

Key Takeaways

• The Claude Code status line shows model, context usage, and effort level — three variables with direct impact on your session quality.
• Run /status before heavy tasks and periodically during long sessions to catch context pressure early.
• High context usage (above 80%) is the most common cause of degraded responses, forgotten instructions, and incomplete output.
• Use /clear to reset context when shifting tasks, and ask Claude for a summary first if you need to preserve progress.
• Model and effort level mismatches explain most speed and quality surprises — the status line confirms what’s actually running.

Claude Code works best when you treat context as a finite resource and manage it deliberately. The /status command makes that possible — check it, act on it, and your long sessions will stay reliable from start to finish. If you’re building workflows that extend beyond Claude Code itself, MindStudio offers a straightforward way to connect Claude’s reasoning to the broader systems your work depends on.