How to Use Claude Code Ultra Plan: Requirements, Token Costs, and When to Use It

What Claude Code Ultra Actually Is

Claude Code is Anthropic’s terminal-based agentic coding tool. Unlike the browser version of Claude, it runs directly in your terminal — reading and writing files, executing shell commands, and working through multi-step development tasks on its own.

The “Ultra” tier refers to the highest usage level within Anthropic’s subscription structure. Anthropic offers Pro at $20/month, and Max at two tiers: $100/month for 5x Pro limits, and $200/month for 20x Pro limits. For Claude Code specifically, “Ultra” refers to running the tool at the Max plan’s highest tier — giving you the most token throughput and the longest uninterrupted agentic sessions available without switching to direct API billing.

This distinction matters more for Claude Code than for standard Claude.ai use. A single complex coding task can burn through hundreds of thousands of tokens as the agent reads files, plans changes, executes commands, reviews outputs, and iterates. Lower-tier plans hit usage ceilings quickly, cutting sessions off mid-task.

Requirements Before You Start

There are four core requirements for running Claude Code at the Ultra level. Meeting all four before you start saves significant frustration.

A Supported Subscription

Claude Code requires either a Pro or Max subscription on Claude.ai. Free accounts don’t have access. For extended development sessions — anything involving large codebases or multi-hour work — the $200/month Max tier is the practical choice. Pro limits are hit fast once Claude Code starts doing real agentic work.

You can also use Claude Code with a direct Anthropic API key and pay per token. Whether that ends up cheaper than a flat subscription depends on your usage volume, covered more in the token cost section below.

A Git Repository

Claude Code is built to operate inside a Git repository. This isn’t just a recommendation — it’s a functional dependency for most of what makes the tool useful.

When you launch Claude Code in a project, it reads the repository structure to understand the codebase. It uses Git status, diffs, and history to reason about what’s changed and what still needs doing. Without Git, the agent loses critical context and produces noticeably weaker results on complex tasks.

Starting a new project? Run git init before launching Claude Code.

Node.js and CLI Access

Claude Code ships as an npm package. You need Node.js installed (v18 or later) and terminal access. Install it globally with:

npm install -g @anthropic-ai/claude-code

That installs the claude command. On first run, it opens a browser window for OAuth authentication against your Claude.ai account — linking the CLI to your subscription.

A Reasonably Organized Project

This isn’t a hard technical gate, but it matters practically. Claude Code performs significantly better in projects with clear directory structures, descriptive file names, and at least minimal documentation.

A messy, undocumented codebase forces the agent to spend extra steps (and tokens) trying to understand what things do before it can do anything useful. Cleaning up structure before a session pays off in both speed and cost.

How Token Consumption Works

Token costs are the central concern when using Claude Code at any tier. Understanding the mechanics helps you plan usage and avoid surprises.

Why Claude Code Is Token-Intensive

Claude Code operates as an agentic loop. On each step of a task, it:

Reads context — your files, previous outputs, terminal history
Reasons about what to do next
Executes an action — writes a file, runs a command, searches the codebase
Observes the result
Repeats until the task is done

Every one of those steps involves sending and receiving tokens. A single “add authentication to this app” request might involve 20–40 separate tool calls, each with its own token overhead.

Input Tokens Are the Bigger Cost

Most people think about tokens in terms of what Claude writes. In agentic use, input tokens — what Claude reads — often dwarf output tokens. When Claude Code works through a complex refactor, it may read your entire codebase multiple times across a long session.

On Anthropic’s API, input tokens are priced lower than output tokens. On subscription plans, both count toward your usage ceiling in aggregate.

What Typical Tasks Cost

Rough estimates for common sessions:

Small bug fix in an isolated file: 5,000–20,000 tokens
Adding a feature to an existing module: 30,000–100,000 tokens
Full refactor of a medium codebase: 200,000–500,000+ tokens
Building a new feature end-to-end: 100,000–300,000 tokens

These are approximate. Actual usage depends on codebase size, task complexity, and how many clarification loops the agent needs. Large files are disproportionately expensive — a 1,500-line Python file can consume 5,000–7,000 input tokens just to load.

At the Pro tier, heavy Claude Code use exhausts limits within a few hours of real development work. Max-tier throughput is what makes sustained sessions viable.

Setting Up Claude Code Step by Step

Step 1: Set Up Your Subscription

Go to claude.ai and upgrade to Pro or Max. For serious development work, Max is the practical starting point. You can start with Pro and upgrade once you’ve confirmed your workflow.

Step 2: Install Node.js

If you don’t have it, install Node.js (v18 or later). Verify with:

node --version

Step 3: Install Claude Code

npm install -g @anthropic-ai/claude-code

Verify:

claude --version

Step 4: Authenticate

Run claude in your terminal. The first time, it prompts you to log in via browser, linking the CLI to your Claude.ai account.

Step 5: Navigate to Your Project

cd /path/to/your/project

Confirm it’s a Git repo. If not, run git init.

Step 6: Start a Session

Run claude from within the project directory. Describe what you want in plain language — Claude Code handles reading files, writing code, running tests, and iterating from there.

When Ultra Is Worth the Cost

Not every use case justifies the Max plan. Here’s a realistic breakdown.

When It Makes Sense

Large codebases with complex interdependencies. When changes in one file ripple through ten others, you need an agent that can hold substantial context across a long session. Max-tier limits support this; Pro often doesn’t.

Greenfield development with real scope. Building a full backend API or a complete frontend feature from scratch can easily hit 200,000+ tokens in a single session. Pro limits make this impractical without multiple interruptions.

Time-sensitive development work. If a developer’s time is worth more than the subscription cost — which it nearly always is — uninterrupted sessions have a clear ROI.

Regular, repeated use. Running three or four Claude Code sessions a week on real tasks? Max pays for itself compared to hitting rate limits and waiting for resets.

When Lower Tiers Are Fine

Small, isolated tasks. Fixing a specific bug, writing one function, or updating docs rarely exhausts Pro limits.

Occasional use. One or two sessions a week on focused tasks is manageable on Pro.

Small codebases. When total project size is under 50KB and files are short, token consumption stays modest.

Learning and exploration. If you’re testing what Claude Code can do, start with Pro before committing to Max.

Tips for Managing Token Usage Efficiently

Even with Max limits, long complex sessions can still run into ceilings. These habits help.

Scope Your Requests

Don’t ask Claude Code to “refactor the entire codebase.” Break work into targeted requests. “Refactor the auth module to use JWT instead of sessions” is far cheaper than an open-ended overhaul — and produces better results.

Use `.claudeignore`

Claude Code respects a .claudeignore file similar to .gitignore. Use it to exclude large directories that aren’t relevant to your work: node_modules, build artifacts, vendor directories, test fixtures, documentation. This prevents the agent from accidentally reading thousands of irrelevant files.

Keep Files Focused

Large monolithic files are expensive. If you can reasonably split a 2,000-line file into four focused modules before a session, do it. You’ll use fewer tokens and the agent will reason more accurately.

Reset Context Between Tasks

Claude Code maintains a running context window within a session. If you’ve finished one task and are starting an unrelated one, use /clear to reset. This prevents irrelevant context from carrying over and consuming tokens.

Review Before Committing

Claude Code can commit changes automatically if you permit it. Consider reviewing diffs before commits on complex tasks — catching mistakes early is cheaper than spending tokens fixing them downstream.

Extending Claude Code Beyond Code

Claude Code handles writing and reasoning about code well. But it can’t natively send emails, query external APIs, generate images, trigger workflow automations, or interact with most business tools.

This is where the MindStudio Agent Skills Plugin is worth knowing about. It’s an npm SDK (@mindstudio-ai/agent) that gives Claude Code agents access to 120+ typed capabilities as simple method calls — without building integrations from scratch.

Instead of Claude Code having to reason through how to set up an email integration or write a custom Slack notifier, you drop the SDK in and call methods like agent.sendEmail(), agent.searchGoogle(), or agent.runWorkflow(). The SDK handles the infrastructure layer — rate limiting, retries, authentication, error handling — so the agent focuses on logic, not plumbing.

For developers using Claude Code at the Max/Ultra tier, where sessions are long and tasks are complex, this kind of extension reduces total session length and token cost. You’re not paying for Claude Code to reason through integration setup from scratch.

MindStudio itself is a no-code platform for building AI agents and automated workflows — but for Claude Code users specifically, the Agent Skills Plugin is the most relevant piece. It’s available as an npm package and works with any agentic system, not just MindStudio-built agents.

You can try MindStudio free at mindstudio.ai.

Frequently Asked Questions

Does Claude Code require a Git repository to work?

Technically you can run it in a non-Git directory, but the tool is significantly less effective without Git. It uses repository structure, diffs, and commit history to understand context. Without that, the agent has less to work with and will produce lower-quality results on anything beyond the simplest tasks. Initialize Git first.

What’s the practical difference between Pro and Max for Claude Code?

Pro ($20/month) gives you standard Claude.ai usage limits. Max comes in two tiers: $100/month for 5x Pro limits, $200/month for 20x Pro limits. For Claude Code, the difference is how long you can run sessions before hitting rate limits. Pro works for light or occasional use. Max is what you need for real development workflows involving large codebases or extended agentic sessions.

Can I use Claude Code with API keys instead of a subscription?

Yes. You can authenticate with an Anthropic API key and pay per token instead of a flat monthly rate. Whether this is cheaper depends on usage volume. If you run multiple long sessions per week, a Max subscription is likely more cost-effective. If you’re using it a few times a month, pay-per-token may be better. The Anthropic pricing page has current rates.

Is Claude Code safe to run on a production codebase?

Use caution. Claude Code can read, write, and delete files, and execute shell commands. Running it with broad permissions on a production codebase carries real risk. Best practice: work on a feature branch, review all changes before merging, and use .claudeignore to limit file access to directories relevant to your current task.

What models does Claude Code use?

Claude Code defaults to Claude 3.5 Sonnet or Claude 3.7 Sonnet depending on the task. These are Anthropic’s most capable models for coding work. You can specify a model explicitly in your configuration, but the defaults are appropriate for most development use cases.

How do I reduce token usage without downgrading my plan?

Scope requests tightly, use .claudeignore to exclude irrelevant files, keep individual files focused and reasonably short, and use /clear to reset context between unrelated tasks. These four habits reduce token consumption meaningfully without sacrificing the quality of results.

Key Takeaways

Claude Code Ultra/Max requires a Pro or Max subscription, a Git repository, Node.js, and the Claude Code CLI installed via npm.
Token consumption is high by design — simple tasks use 5,000–50,000 tokens; complex sessions regularly hit 200,000–500,000+.
Max-tier plans are necessary for serious development workflows; Pro limits are exhausted quickly on extended agentic sessions.
Scoping requests and using .claudeignore are the two highest-leverage habits for managing token usage efficiently.
External capabilities — email, APIs, workflows, and integrations — can be added to Claude Code agents via MindStudio’s Agent Skills Plugin without building infrastructure from scratch.

If you keep hitting rate limits mid-session, the upgrade to Max is the straightforward fix. For extending what your Claude Code agents can actually do beyond writing code, MindStudio is worth a look.