Claude Code Beginners Guide: Install, CLAUDE.md, Commands & MCP

Why AI Coders Need to Know This

Most vibe coders start with Cursor or Windsurf — visual IDEs with AI built in. Those are great tools. But Claude Code represents a different category: an agentic coding assistant that operates from your terminal, understands your full codebase, and can be configured to behave like a specialized engineer for your specific project.

Here is what sets Claude Code apart in 2026:

• Context-first: Claude Code reads your entire project before responding. It does not just answer your prompt — it understands what your codebase actually looks like.
• CLAUDE.md files: You write a plain-text file telling Claude about your project's conventions, tech stack, and rules. Every session starts with that context already loaded.
• Agentic capability: Claude Code can run terminal commands, read and write files, search your codebase, and with MCP servers, call external APIs and databases — without you manually copying and pasting anything.
• Permission control: You decide exactly what Claude is allowed to do — from "ask me before every file write" to "just do it."

For non-traditional builders, Claude Code is valuable because it levels the playing field. You do not need to understand every line of every file in your project. Claude does — and it can navigate that complexity on your behalf while you stay focused on what you want to build.

Real Scenario

You have a Node.js project that needs a new API endpoint. You open your terminal and type:

# Navigate to your project folder
cd ~/projects/my-api

# Start Claude Code
claude

# First prompt inside Claude Code:
> Add a POST /users/register endpoint. It should:
  - Accept email and password in the request body
  - Validate that email is a valid format
  - Hash the password using bcrypt
  - Store the user in the database using our existing db.js module
  - Return a 201 status with the new user's ID on success
  - Follow the same pattern as our existing /users/login endpoint

Claude Code reads your project. It finds db.js, reads the existing /users/login endpoint to understand your patterns, installs bcrypt if it is missing, writes the new endpoint, and updates your route registration file. All without leaving the terminal. All following your existing code style.

That is the difference. Let's build up to it step by step.

What AI Generated

Let's walk through a realistic first Claude Code session from installation to first real output.

# Step 1: Install Claude Code globally via npm
# Requires Node.js 18+
npm install -g @anthropic-ai/claude-code

# Step 2: Verify installation
claude --version
# Output: claude 1.x.x (Anthropic)

# Step 3: Set your API key (one time)
# Option A: Environment variable (recommended)
export ANTHROPIC_API_KEY="sk-ant-..."

# Option B: Claude will prompt you if the key is missing
# You can also use a Claude Pro or Max subscription

# Step 4: Navigate to your project
cd ~/projects/my-app

# Step 5: Start Claude Code
claude

# You will see a prompt like:
# ✻ Welcome to Claude Code!
# Working directory: /Users/you/projects/my-app
# >

# Step 6: Your first prompt
> Explain what this project does based on the files in this folder.

# Claude will:
# 1. Read package.json to understand dependencies
# 2. Scan the folder structure
# 3. Read key files (index.js, README.md, etc.)
# 4. Give you a plain-English summary

That first "explain this project" prompt is not a toy. It is genuinely useful when you inherit code from someone else, return to a project after months away, or pick up AI-generated code and need to understand what it actually does.

Understanding Each Part

Installation Requirements

Claude Code needs three things:

1. Node.js 18 or later — check with node --version. Install via nodejs.org or nvm (Node Version Manager) if you manage multiple Node versions.
2. npm — comes with Node.js. You use it to install Claude Code globally.
3. An Anthropic API key or Claude Pro/Max subscription — get your API key at console.anthropic.com. API usage is pay-as-you-go. Claude Pro/Max subscribers can authenticate without a separate API key.

The install command is simple: npm install -g @anthropic-ai/claude-code. The -g flag installs it globally so you can run claude from any directory.

Your First Commands

Once installed, run claude in your project folder. The most useful first commands:

Slash Commands Reference

Slash commands are special shortcuts you type during a Claude Code session. They give you meta-control over the session itself.

CLAUDE.md Files: Your Project's Instruction Manual

This is the most underused feature in Claude Code — and the one that delivers the most value per minute invested.

A CLAUDE.md file is a plain Markdown text file you place at the root of your project. Claude Code reads it automatically at the start of every session. It is how you give Claude standing instructions about your project without repeating them every time.

Here is a realistic example for a Node.js API project:

# My App — Claude Code Instructions

## Project Overview
This is a Node.js REST API for a task management application.
Stack: Node.js 22, Express 5, PostgreSQL 16, Prisma ORM.
Deployment: Railway (auto-deploys from main branch).

## Architecture
- src/routes/     — Express route handlers (one file per resource)
- src/middleware/ — Auth, validation, error handling
- src/services/   — Business logic (no direct DB calls here)
- src/db/         — Prisma client and database utilities
- src/utils/      — Shared helpers

## Conventions
- All route files export a router using express.Router()
- Always use async/await — no callback-style code
- Validation: use Zod schemas in src/schemas/
- Error handling: throw errors and let the global handler catch them
- Database: use Prisma client, never raw SQL queries
- Tests: Jest, place test files alongside source with .test.js suffix

## Environment
- .env.local for local development (never commit this)
- .env.example shows all required variables
- DATABASE_URL must be set for any DB operations

## What I Do NOT Want
- Do not use class-based code — functions only
- Do not install new dependencies without asking me first
- Do not modify the Prisma schema without explaining the migration impact
- Do not create index.js files at the folder level

A well-written CLAUDE.md file transforms Claude from "an AI that writes generic Node.js code" into "an AI that writes code matching exactly how my project is structured." The difference in output quality is substantial.

CLAUDE.md Best Practices

• Keep it concise — Claude Code reads the whole file, so dense prose slows the context load.
• Organize with headers — conventions, architecture, dos and don'ts.
• Update it as the project evolves. A stale CLAUDE.md is worse than no CLAUDE.md.
• You can have multiple CLAUDE.md files — one at the root and one in specific subdirectories. Subdirectory files apply only to work in that folder.
• Use /memory in an active session to edit your CLAUDE.md from inside Claude Code.

Permission Modes

Claude Code can take real actions — write files, run shell commands, install packages. Permission modes control how much freedom it has to act without asking you first.

You can also use bypassPermissions mode programmatically when spawning Claude Code from scripts — this is what automation pipelines use. The /permissions slash command lets you adjust settings mid-session.

MCP: Giving Claude Hands

MCP stands for Model Context Protocol — an open standard Anthropic released that allows Claude Code to connect to external tools, data sources, and services. If CLAUDE.md is Claude's memory, MCP is its ability to take action in the world.

Without MCP, Claude Code can only read and write files in your local project. With MCP servers, Claude can:

• Query your PostgreSQL or other database and read real data.
• Search the web for documentation or current information.
• Fetch URLs and read their content.
• Call external APIs on your behalf.
• Read and write to external services (GitHub, Notion, Slack, etc.).

MCP servers are configured in a JSON file. Here is what a minimal configuration looks like:

// ~/.claude/mcp-servers.json
{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/you/projects"]
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "POSTGRES_CONNECTION_STRING": "postgresql://user:pass@localhost:5432/mydb"
      }
    },
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": {
        "BRAVE_API_KEY": "your-api-key-here"
      }
    }
  }
}

Once MCP is configured, you start Claude Code with MCP enabled and tools become available. You can check connected servers with the /mcp command. When you ask Claude to query your database, it actually queries it — not a mock, not a guess, but live data.

This is what makes Claude Code an agentic tool rather than just an autocomplete engine. The combination of CLAUDE.md (persistent context) + MCP (real-world access) + permission controls creates an autonomous coding partner that works within your actual environment.

What AI Gets Wrong About Claude Code

When Claude Code makes mistakes — or when the AI itself gives you bad advice about using Claude Code — it usually falls into these patterns:

Not reading the existing code first

If you start with a vague prompt like "build me a user auth system," Claude will generate something generic that may not match your project's existing patterns at all. Always ground your prompts: "Build a user auth system that follows the same pattern as our existing /orders endpoint in src/routes/orders.js."

Skipping the CLAUDE.md file entirely

Many beginners skip CLAUDE.md because it seems like extra work. This is the single biggest mistake. Without it, Claude gives you generic code. With it, Claude gives you code that fits your project. Spend 15 minutes writing a CLAUDE.md before your first real session. It pays back within the first hour.

Running with unlimited permissions on the first session

New users sometimes see the --dangerously-skip-permissions flag mentioned online and enable it immediately. This is how you end up with Claude deleting test fixtures, overwriting config files, or making sweeping changes you did not intend. Start cautious, loosen permissions as you build trust.

Context window overflow on large projects

Claude Code has a finite context window. On very large codebases, it can only hold so much in memory at once. Signs of context overflow: Claude "forgets" files it read earlier, gives contradictory advice in the same session, or starts hallucinating file paths. Fix: use /compact to compress the conversation, or start a fresh session with a more targeted prompt.

Treating it like a chat assistant, not a coding agent

Claude Code is most powerful when you give it specific, actionable tasks — not open-ended philosophical discussions. "Make the checkout flow faster" is a bad Claude Code prompt. "Profile the three database queries in src/services/checkout.js and add query-level caching using our existing Redis client in src/cache.js" is a great Claude Code prompt.

Claude Code vs. Cursor vs. Windsurf

These are the three tools most vibe coders encounter. They are not directly comparable — they solve different parts of the problem.

Many experienced builders use both: Cursor or Windsurf for day-to-day editing and code review, Claude Code for larger agentic tasks like refactoring entire modules, writing test suites, or running automated deployment pipelines.

If you are brand new to AI tools, Cursor is probably easier to start with — the visual interface is forgiving. If you are comfortable in the terminal and want deeper project-level AI integration, Claude Code is the more powerful choice.

See our full Cursor Beginners Guide for a side-by-side walkthrough of Cursor's specific features.

How to Debug With AI

Claude Code is excellent at debugging, but only when you give it concrete evidence. Here is a workflow that works:

Step 1: Reproduce the error

Run the failing command in your terminal and copy the full error output — stack trace and all. Do not summarize it. Paste the raw text into Claude Code.

Step 2: Provide context

Tell Claude which file you think the error is coming from, what you expected to happen, and what actually happened. Example:

> I'm getting this error when I run `npm run dev`:

TypeError: Cannot read properties of undefined (reading 'id')
  at getUserById (src/services/users.js:42:18)
  at async router.get (/src/routes/users.js:15:20)

I expect src/services/users.js line 42 to return a user object from the database.
Read the relevant files and explain what's causing this.

Step 3: Ask for explanation first, fix second

Say "explain what's causing this" before "fix it." Understanding the root cause prevents the same class of bug from appearing three files over. Once you understand it, ask Claude to fix it and explain the fix.

Step 4: Review the diff

After Claude makes changes, run /diff to see exactly what changed. Read every line. You are the final reviewer. Claude is fast but not infallible — and you are accountable for the code in your project.

What to Learn Next

Claude Code builds on several foundational concepts. If anything in this guide felt fuzzy:

• The Complete Guide to Vibe Coding — the philosophy and workflow behind AI-first development.
• Cursor Beginners Guide — the visual IDE alternative to Claude Code.
• What Is Git? — version control is essential when Claude Code makes sweeping changes.
• What Is an API? — Claude Code excels at building APIs; understand what you are building.
• What Is JavaScript? — the language behind most Claude Code projects.
• AI Tokens & Context Limits — understand why Claude Code sometimes "forgets" what you told it and how to manage your context window.
• Codex vs Claude Code — wondering how Claude Code stacks up against OpenAI's Codex CLI? A detailed head-to-head for complex projects.

FAQ