Claude Code in India: My Daily Setup

Claude Code is Anthropic's command-line coding agent, the official way to drive Claude Opus from a terminal. It is my daily driver, running across a dozen-plus projects on one Linux box in India: a jobs site, a finance newsroom, govt-form automation, trading bots, and the content pipeline behind this site.

Most setup guides stop at install and pricing. That part takes five minutes. The part that decides whether Claude Code is a toy or a force multiplier is the operator layer underneath: how the session meter behaved on my own account, the fork-mode flag for headless fanouts, and the MCP tools that replace whole categories of one-off scripts.

Why terminal, not IDE

Cursor is a VS Code fork. Claude Code is terminal-native, file-aware, git-aware, with a 1M-token context window. If you work over SSH, live in tmux or neovim, run a commit-heavy workflow, or navigate large codebases, the terminal agent fits the hand better. I keep both: Claude Code for planning and large multi-file work, Cursor for quick autocomplete.

Install in five minutes

The native installer is the recommended path:

curl -fsSL https://claude.ai/install.sh | bash

claude --version

npm works too, without sudo. As of v2.1.198, the npm package requires Node.js 22 or later; on an older Node version, npm prints a warning but the install still completes, since the package pulls down a native binary that does not run on your Node install at runtime.

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

Do not run that with sudo: Anthropic's own docs warn it can cause permission issues. Full walkthrough: Install Claude Code on Linux.

Pricing in INR, and which plan a solo operator wants

Two auth paths.

Subscription (what I run)

• Pro: $20/mo, or $17/mo billed annually ($200 up front). Covers light, occasional Claude Code use.
• Max 5x: $100/mo. Higher limits, priority access. This is my current plan.
• Max 20x: $200/mo, per Anthropic's own Max plan help article (claude.com/pricing itself only shows "From $100" for Max, without splitting the two tiers).

Rupee reference: ₹95.88 per US dollar (open.er-api.com, rate last updated Sun, 27 Sep 2026). On that rate, $17 is about ₹1,630, $20 about ₹1,918, $100 about ₹9,588, and $200 about ₹19,176.

For the full plan-by-plan and API breakdown, see Claude Code pricing: Pro vs Max vs API.

I ran Max 20x until 10 July 2026, when I moved to Max 5x. Moving down roughly halved my weekly hours on the top model, so today I push bulk, repetitive work off Claude by default and keep Claude for the work that needs judgment.

claude
# first run prompts login, browser opens, auth flow completes

API key (overflow and pipelines)

export ANTHROPIC_API_KEY="sk-ant-..."
# set it only in the shell or script that should bill the API

The API rail bills per token, separate from your Max window. Keep the key out of .bashrc: Anthropic's help center says that when ANTHROPIC_API_KEY is set, Claude Code uses it instead of your subscription and you get API usage charges. The smart move is not "Max or API", it is knowing which work belongs on which rail, and I will come back to it.

One thing the Max OAuth path does not get: beta headers. claude --help lists the --betas flag as "API key users only", so if a tutorial tells you to enable a beta on a Max plan, it will not apply.

Your first project

Point it at a real repo and give it a concrete task.

cd ~/my-project && claude

Read src/app/page.tsx and refactor it into smaller components.
Create src/components/ with logical splits.
Update imports. Run tsc --noEmit to verify no errors.

It reads the file, proposes a plan, creates the components, then runs the type check. On Claude Code 2.1.283, the version I run today, auto mode is the default starting permission mode for interactive sessions: a classifier reviews actions and most edits go through without a prompt. When the work touches something live, press Shift+Tab to cycle to a stricter mode that asks before it edits.

The 5-hour meter nobody warns you about

This is the single most expensive misunderstanding on the Max plan, and it cost me a postmortem to learn.

On Max, token spend is not the whole story. What I saw on my own account is that the 5-hour session window moves with how many sessions and headless runs I fire, not just with tokens burned. Anthropic has not published that formula; this is what my own postmortem showed. The two budgets move independently. You can have a healthy cache hit rate, a low token-dollar figure for the day, and still watch the Max percentage bar burn down fast.

The trap is headless one-shot runs. Every fresh claude -p starts from scratch: a new connection, full session priming (system prompt, CLAUDE.md, skills, MCP handshake), and a cache write a one-turn session never reads back. On my 4 May 2026 peak day, 114 sessions with 74 one-shot runs burned the window faster than a 20-session day that spent more money.

My rules of thumb for one-shot claude -p:

• Under 10 a day: fine.
• 10 to 30 a day: noticeable.
• Over 30 a day: problematic.
• Over 70 a day: fatal to the window.

So before wiring claude -p per item into a pipeline, count the calls per day. If it clears 10, redesign it as one long-running session that reuses cache, or move it onto the direct-API rail, which bills rupees and never touches the Max window. A loop firing a fresh agent per draft is the classic way to nuke your own afternoon.

The env flag for headless fanouts

Fork mode lets a subagent start from the parent session's context instead of a blank one. Claude Code's subagent docs, checked on 28 Sep 2026, say fork mode is on by default in interactive sessions from v2.1.232, and off by default for non-interactive -p runs and the Agent SDK. This line turns it on there too, and on older builds:

# ~/.bashrc: forces fork mode on for headless -p runs and older builds
export CLAUDE_CODE_FORK_SUBAGENT=1

A forked subagent reuses the conversation's own prompt, and Anthropic bills cache reads at a fraction of the normal input price, so a large fanout costs far less per agent when the cache is warm. For the version history and a way to measure the gain on your own runs, see Claude Code subagents in practice.

Two caveats from running it for real:

• Cron does not load ~/.bashrc. If a scheduled job does fanout, set the flag inside the crontab line or wrapper script, or it silently runs cold.
• Warm the cache first. Fire one subagent, wait for its first streamed token (that hydrates the shared cache), then fan out the rest. Confirm it works via cache_read_input_tokens in a subagent response: after warmup it should be most of the input.

Design for the cache first

Treat cache hit rate like uptime. On a Max plan that hit rate maps straight to how much cap headroom you have left, so cache design is the budget, not a micro-optimisation. What actually moves the number:

• Keep the system prompt slim. Every byte of your global CLAUDE.md is re-sent as a cache read on every message. A bloated context file can quietly dominate your whole month's token volume even at the discounted rate. Push detail into on-demand files.
• Put dynamic content at the end. Timestamps, request IDs, per-run context go after the stable prefix. The auto cache breakpoint lands after the last cacheable block, so volatile data up front changes the prefix hash every request and you never get a hit.
• Lock tool order. Tool definitions cache as one prefix. Reorder them between subagent calls and you invalidate the whole tool cache.
• Never swap models mid-session. Switching Opus to a smaller model partway through costs more than letting Opus finish, because the cache invalidates. Route by session boundary.

/fast mode on Opus

When I need quicker turnarounds without dropping to a weaker model, /fast toggles a faster output path on Opus. Same model, lower response latency, at a premium: Anthropic's pricing page lists fast mode for Opus 5.5 at 2x standard pricing. The right lever when wall-clock time is the bottleneck, not when you need a cheaper model.

The MCP toolbox I actually use

Out of the box Claude Code is useful. The next half hour of setup is where it becomes the daily driver. MCP servers add new tools to the agent. Add them with claude mcp add and run /mcp to confirm they connected. Mind the scope: Anthropic's MCP docs list local (the default, this project only, stored in ~/.claude.json), project (.mcp.json in the project root, shared through git) and user (every project, also ~/.claude.json). I learned that the hard way: servers I had listed in ~/.claude/.mcp.json were loading in zero sessions until I re-added them with --scope user. The three I lean on as an Indian operator:

• adobe-pdf: Adobe PDF Services over REST for govt forms, invoices, OCR, and table extraction with proper layout. It replaced pdftk and PyPDF in my workflow entirely.
• gemma-vision: a local vision model on my own GPU for screenshot debugging and document data extraction. Running locally, it does the image work without spending Anthropic context tokens.
• claude-context: semantic search across my indexed repos. I reach for it before grep -r on any cross-repo refactor.

The pattern that matters: reach for an MCP tool before writing a one-off script or installing a library. Most glue work you would hand-roll is already a tool call. When no existing server covers your stack, write a custom MCP server in Python and the agent gains a typed tool for exactly your job. When a repeatable workflow needs instructions rather than a server, a skill is the lighter tool: see the Claude Code skills guide.

Hooks and custom slash commands

Hooks are shell commands the harness runs on lifecycle events. They live in ~/.claude/settings.json under the hooks key. I use a SessionStart hook that loads a per-project RESUME.md if one exists in the working directory, so the agent wakes up knowing where I left off.

{
  "hooks": {
    "SessionStart": [
      {
        "hooks": [
          { "type": "command", "command": "test -f ./RESUME.md && cat ./RESUME.md || true" }
        ]
      }
    ]
  }
}

The output is injected into context, and because the hook lives in the global settings file it survives across every session and project.

Custom slash commands are markdown files in ~/.claude/commands/<name>.md. Each becomes a /<name> command, and the body of the file is the prompt that runs.

mkdir -p ~/.claude/commands
cat > ~/.claude/commands/lint.md <<'EOF'
Run `npm run lint` and `npm run typecheck`. Fix any errors you can without
changing public APIs. Report what you fixed and what needs a human.
EOF

The CLAUDE.md file in a project root is read automatically every session. Keep it tight, since per the cache rule above it costs you on every message.

# Project Context

## Stack
- Next.js + TypeScript + Tailwind
- PocketBase backend
- Deployed on Cloudflare Pages

## Conventions
- One component per file in src/components/
- No Docker, direct installs only

Indian network note

On some ISPs the route to Anthropic is slow. Cloudflare WARP (free) usually fixes it: warp-cli register then warp-cli connect.

When things break

Auth token expired mid-session. You see "Authentication failed" partway through. Type /login in the session to re-authenticate, or run claude auth logout and start again. Save key state to a file first in case the session does not survive.

MCP server failed to start. A bad entry fails quietly. Run claude mcp list, or claude mcp get <name> for one server, to see what actually connected. Most common cause: the server was added at a scope that does not load in this project. Second: the server's own dependency missing.

Context approaching the limit on a 1M run. Warnings arrive near the top of the window. Type /compact to summarise prior turns and reset. Save anything you do not want compressed to a file first, since compaction is lossy by design.

Tool denied without a clear reason. Check which permission mode you are in (Shift+Tab cycles through them), and whether a deny rule in your ~/.claude/settings.json matches the command. If a command is legitimate, allowlist it explicitly. Never reach for --dangerously-skip-permissions as a shortcut.

Claude Code vs Codex CLI vs Aider

Codex CLI is OpenAI's terminal agent. More autonomous loop, fewer permission prompts, longer multi-step runs before checking in. Trade-off: less surgical control, and it occasionally races into edits you did not intend.

Aider is the open-source veteran. Bring your own API key, works with any OpenAI-compatible endpoint, lightest footprint of the three. Permission model is git-based, every edit is a commit, so revert is one command. No native MCP, no 1M context.

Claude Code is the most polished, the only one with a 1M context window plus native MCP, and the interactive permission model is the feature, not the friction. For a solo operator running many small projects from India, it is my default daily driver.

Quick takeaways

• I ran Max 20x ($200/mo) until 10 July 2026, then moved to Max 5x ($100/mo); moving down roughly halved my weekly hours on the top model, so bulk work now goes elsewhere by default.
• In my experience the 5-hour window burns with the number of runs, not just tokens: over 30 headless claude -p runs a day burned it for me. Push high-frequency jobs to the API rail.
• Fork mode is on by default in interactive sessions from v2.1.232; for headless claude -p runs and cron jobs, set CLAUDE_CODE_FORK_SUBAGENT=1 explicitly.
• Design for prompt caching first: slim system prompt, dynamic content last, locked tool order, no mid-session model swaps. /fast gives faster Opus output at the same quality when wall-clock time is the bottleneck.

Also see the Cursor vs Copilot comparison for a decision framework.