Claude Code Workflow Guide: Setup, MCP, and Real Daily Use in 2026

Claude Code is Anthropic’s CLI tool for AI-assisted coding. It’s grown from “Claude with a terminal” to a serious daily-driver coding agent in 2025-2026. This guide walks through real setup, the CLAUDE.md pattern, MCP integration, and the workflow shape that holds up over months of use.

For background on what makes Claude Code different from editor-based tools, see Claude Code vs Codex CLI vs Cursor Agent. For the protocol that powers most of its tool access, see What is MCP.

TL;DR

Claude Code works best when:

1. You have a CLAUDE.md at your project root describing what the codebase is + the conventions you follow
2. You have MCP servers installed (filesystem at minimum) for real tool access
3. You use it for multi-step tasks rather than line-by-line completions (Cursor is better for those)
4. You iterate: send it a high-level goal, let it propose, review, refine

Claude Code vs alternatives — quick decision

If you want…	Use this	Why
In-editor completion + multi-file refactor	Cursor	Best IDE integration
Agent-style CLI for big refactors + MCP-heavy workflows	Claude Code	Strongest CLI agent + mature MCP ecosystem
OpenAI ecosystem CLI equivalent	Codex CLI	Same shape as Claude Code, OpenAI models
Flat-fee budget option, basic completion	GitHub Copilot	$10/month, no usage surprises
Free / open-source / BYO model	Aider, Cline, Continue.dev	Lower friction, run against any API

Most professional teams use Cursor + Claude Code together — Cursor for the editor, Claude Code for agentic terminal work. See the Claude Code vs Codex CLI vs Cursor Agent comparison.

Initial setup

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

# Authenticate (uses Claude API or Pro subscription)
claude auth

# Start a session in your project
cd ~/projects/my-app
claude

That’s the full install. Authentication uses either an API key or your Claude Pro/Max subscription depending on how you’re set up.

The CLAUDE.md file (the single biggest productivity unlock)

Claude Code reads a file named CLAUDE.md at the root of your project (and merges with any in subdirectories). This is where you tell Claude:

• What the project is
• What conventions you follow
• What tools/frameworks are in use
• What you’ve already tried that didn’t work
• What patterns to prefer/avoid

A real CLAUDE.md fragment from a Next.js + Supabase project:

# My App

A SaaS app for X. Production at app.example.com.

## Stack
- Next.js 16 (App Router, no Pages Router)
- Supabase (auth + postgres)
- Tailwind v4
- Server Components by default; client components only when interactivity needed

## Conventions
- Async actions in src/actions/ (Server Actions)
- Database queries in src/db/ via the Supabase client
- Components in src/components/ with kebab-case filenames
- Never use the Pages Router pattern

## Common tasks
- Add a new page: create src/app/[name]/page.tsx as a Server Component
- Database migration: edit supabase/migrations/, run `supabase db push`
- Run tests: `npm test`; mocks live in __mocks__/

## What's tricky here
- Auth uses cookies, not bearer tokens
- Image upload uses Supabase Storage, not S3
- We hit Stripe via Server Actions, never client-side

This is the file Claude Code reads on every session. The compound benefit: it stops asking you “what framework are you using?” every conversation. It writes code in your style. It avoids the patterns you’ve explicitly listed as wrong.

Keep it under 200 lines. Too long becomes its own problem — Claude reads more than it needs and works slower. Update it as your project evolves.

Adding MCP servers

Once Claude Code is installed, MCP setup is in the config. The minimum useful setup:

# Add filesystem access to current project
claude mcp add filesystem npx @modelcontextprotocol/server-filesystem $(pwd)

# Add GitHub access
claude mcp add github --env GITHUB_PERSONAL_ACCESS_TOKEN=ghp_... npx @modelcontextprotocol/server-github

Or edit ~/.claude/config.json directly with the MCP server JSON.

Servers worth adding to most setups (see best MCP servers in 2026 for the full list):

• filesystem (your project directory)
• github (your repos)
• brave-search (web context)
• memory (persistent context across sessions)

After adding servers, restart the Claude Code session. The tools are now available to Claude during the session.

The daily workflow

What actually works after a few months of daily use:

1. Start with intent, not implementation

Bad prompt: “Update line 47 of users.ts to add an email field.” Good prompt: “Add email as an optional field to the user model. Update the schema, migration, and the existing places we display user info.”

The good prompt lets Claude figure out which files need touching. With filesystem MCP, it actually does this correctly.

2. Let it propose first

For non-trivial changes:

• Describe the goal
• Ask Claude to propose the approach BEFORE writing code
• Review the proposal
• Approve or refine
• Then have Claude execute

This costs an extra round-trip but catches misunderstandings early. The “implement, then realize the approach is wrong, then redo” pattern is more expensive than thinking first.

3. Use the agent mode for multi-step tasks

Claude Code has an agent mode where you give it a goal and it iterates with tool access. Worked example: “find all places we hardcode the API base URL and replace them with the env var.”

The agent:

1. Searches the codebase
2. Lists every hit
3. Proposes the replacement pattern
4. Asks you to confirm
5. Executes across files
6. Reports what changed

This is where Claude Code earns its keep over Cursor’s inline-completion model.

4. Cleanly commit

After Claude does changes, review the diff like you would any other contributor’s. Don’t auto-commit. The agent is fast; review is what keeps quality up.

5. Use CLAUDE.md as living memory

When Claude does something you wish it had done differently, add the lesson to CLAUDE.md. Next session, it remembers.

Common workflows

Refactor a sprawled feature

1. Open Claude Code in the project
2. “Look at how we handle [X]. The pattern has drifted. Propose a refactor plan.”
3. Review the proposal
4. “Execute steps 1-3, then stop for review.”
5. Review the diff
6. “Continue with steps 4-6.”

Add a new feature end-to-end

1. “Add a [feature description]. Walk me through what files this touches first.”
2. Review the file list
3. “Write the schema migration first. I’ll review before you write the API.”
4. Iterate by layer (schema → API → UI)

Investigate a bug

1. “I’m seeing [error] in production. Find where this could originate.”
2. Claude searches, reads, proposes hypotheses
3. “Walk through hypothesis 2 — show me the relevant code.”
4. Discuss, narrow down
5. “Propose a fix.”

Codebase orientation (new repo)

1. Open Claude Code in an unfamiliar repo
2. “Read the README and the package.json. Summarize what this project is.”
3. “Show me the entry point and explain the architecture in 200 words.”
4. Use that orientation to navigate

Honest limitations

After months of daily use, the limits that matter:

• Long context drift: very long sessions degrade. Restart sessions when the context feels off.
• Token cost on big workloads: heavy MCP filesystem use + many tool calls adds up. Watch your usage if cost matters.
• Test-coverage instinct: Claude Code often writes code without writing tests unless prompted. Explicitly ask for tests when you want them.
• External docs that change: even with Brave Search MCP, framework docs that changed yesterday may not be in Claude’s training. Verify recent changes externally.
• Edge case detection: agent mode catches the happy path well; edge cases need you specifying them.

When NOT to use Claude Code

• Single-line completions while typing — use Cursor or Copilot
• One-off questions with no project context — use Claude Desktop or claude.ai
• Production-deployed code generation — humans should commit; the agent shouldn’t auto-deploy
• Anything where the cost of a wrong answer is high without human review

Cost reality

Claude Code subscriptions track Claude API pricing for serious use. Pro/Max subscribers get an allocation; heavy users may need direct API access.

In practice for one developer:

• Light use (an hour a day): subscription tier covers it
• Heavy use (4+ hours a day, agent mode, large codebases): API-direct billing often makes sense

Watch your token usage in the first month to understand your shape.

Combining with Cursor

The popular setup in 2026 is both:

• Cursor for editing + inline completions
• Claude Code in a side terminal for agent-style multi-step tasks

They’re not redundant; they cover different patterns. See Claude Code vs Cursor for the detailed comparison.

Getting started today

1. Install Claude Code (npm install -g @anthropic-ai/claude-code)
2. Add a CLAUDE.md to your active project (start small, evolve it)
3. Add filesystem MCP (claude mcp add filesystem ...)
4. Run one real multi-step task as a test (refactor a small feature, add a small new endpoint)
5. Iterate the CLAUDE.md based on what you wish Claude had known

The setup is 15 minutes. The compound benefit shows up over weeks as your CLAUDE.md gets more specific and your prompts get sharper.

For specific MCP servers to add, see Best MCP Servers in 2026. For how Claude Code stacks against alternatives, see Claude Code vs Codex CLI vs Cursor Agent.