Claude Code is the part of Anthropic’s lineup that doesn’t get a press release every time it changes, yet it’s the piece most developers actually touch every day. It’s a terminal-native coding agent: you point it at a repository, it reads the code, runs commands, edits files, and reports back, all from a command line session rather than a chat window bolted onto an editor. Search interest in “claude code tutorial” has climbed steadily through 2026 as more teams move past the chatbot phase of AI coding and into agents that can plan a task, execute it across multiple files, and verify their own work.

This tutorial walks through installing Claude Code, configuring it for a real project, wiring up subagents, MCP servers, and hooks, and then building a complete working project end to end: a small Task API with tests, built almost entirely through Claude Code sessions. Every command below reflects Claude Code’s npm package (@anthropic-ai/claude-code) and the CLI’s documented behavior as of early October 2026, including Claude Code 2.1.280’s shift to Claude Opus 5.5 as the default Opus model. Grab a terminal and budget about 60 minutes to follow along.

Why Claude Code Now: What Changed in Late 2026

Claude Code has shipped often enough in 2026 that a tutorial written even a few months ago would already be out of date on a few details. Two releases matter most for anyone starting today. Claude Code 2.1.277, which went out on September 18, 2026, added support for reading an AGENTS.md file automatically when a project has no CLAUDE.md, a change aimed squarely at teams that already standardized on the shared AGENTS.md convention used across other AI coding tools. A few days later, Claude Code 2.1.280 made Claude Opus 5.5 the CLI’s default Opus model, following Anthropic’s September 22, 2026 launch of that model.

That timing matters for anyone who installed Claude Code earlier in the year and hasn’t touched the config since. Opus 5.5 reasons by default through always-on adaptive thinking rather than a toggle, and it ships with a 1 million token context window by default, both of which change the latency and per-call cost profile of a session even if nothing else about your workflow changes. Anthropic has said Opus 5.5 runs roughly 40% cheaper than its predecessor on typical workloads, with cached reads cut 60% to $0.20 per million tokens, so the net effect for most teams is positive, but it’s still a behavior change worth testing rather than assuming.

The broader coding-assistant market moved on a similar clock. GitHub’s own September 2026 changelog confirmed GPT-6.1 Sol and Claude Sonnet 5.5 both rolling out inside GitHub Copilot the same month, and Cursor shipped a Projects feature on September 10, 2026. None of that changes what Claude Code does, but it explains why “claude code tutorial” searches spiked through late September and into October: a cluster of frontier coding tools all refreshed their defaults within about two weeks of each other, and developers went looking for an updated walkthrough rather than trusting a guide written against an older version.

Prerequisites: What You Need Before You Start

Claude Code runs as a single npm-installed CLI, so the list of hard requirements is short. Pin these versions so your terminal output matches the examples in this guide.

  • Node.js 18 or newer, per Anthropic’s own installation documentation
  • npm (ships with Node.js) or an alternative like pnpm or Bun for the install step
  • A terminal on macOS, Linux, or Windows (via WSL is recommended on Windows)
  • Git 2.30 or newer, since Claude Code shells out to git for diffs, commits, and status checks
  • An Anthropic account on Claude Pro, Max, Team, or Enterprise, or an Anthropic API key billed pay-as-you-go
  • A code editor you already use, since Claude Code lives in the terminal alongside it rather than replacing it

Which Claude Plan Do You Need?

Every current Anthropic consumer and business plan includes Claude Code, so the decision usually comes down to usage volume rather than feature access. Pro and Max share usage limits between chat and Claude Code sessions, while Team and Enterprise seats are priced per member. If you’d rather skip the subscription entirely, the API key route bills per token at standard rates, which tends to suit light or bursty usage better than a flat monthly seat.

PlanMonthly price (USD)Claude Code included
Claude Pro$20/monthYes, shares the plan’s usage limit with chat
Claude Max$100 or $200/month, depending on tierYes, both Max tiers include it
Claude Team$25/member (Standard) or $125/member (Premium)Yes, included in every seat
Claude EnterpriseAnnual seat fee, usage billed separately at API ratesYes, included in Enterprise seats
API pay-as-you-goNo flat fee; billed per million tokensYes, works with any API key

For this tutorial, any of the above works. If you’re using an API key instead of a subscription, Claude Opus 5.5 is priced at $4 per million input tokens and $20 per million output tokens, down from $5 and $25 on the prior Opus release, with cached reads at $0.20 per million tokens. Claude Sonnet 5.5, the faster and cheaper model in the same family, is the better default for routine edits, reserving Opus 5.5 for harder multi-file refactors. Switch between them mid-session with /model rather than committing to one for an entire project, since a quick typo fix and a cross-file migration don’t need the same reasoning budget.

Where Claude Code Fits Next to Your Editor

It helps to know what kind of tool you’re installing before you install it. Claude Code is terminal-native and editor-agnostic: it doesn’t live inside a specific IDE the way GitHub Copilot’s extension lives inside VS Code or JetBrains, and it isn’t a forked editor the way Cursor is built as its own VS Code fork. You run Claude Code from a shell, in a split pane next to whatever editor you already use, and it edits files on disk directly rather than through an editor’s own plugin API.

That design tradeoff cuts both ways. You lose inline ghost-text completions as you type, the kind Copilot is built around, since Claude Code is session-driven rather than keystroke-driven. In exchange, you get a tool that works identically whether your editor is Vim, Zed, JetBrains, or VS Code, and that can run unattended in a CI job or a headless container just as easily as on a laptop, since it was never tied to a GUI in the first place. Teams that want both experiences typically keep an editor’s inline-completion assistant for small, line-level suggestions and reach for Claude Code specifically for multi-file tasks: a refactor, a migration, a new feature that touches routes, tests, and docs together.

Step 1: Install Node.js and the Claude Code CLI

If you don’t already have Node.js 18 or newer, install it through your platform’s version manager rather than a system package, since Claude Code’s installer checks the active Node version at install time and will refuse to proceed on anything older.

# check your current Node version
node --version

# install or switch via nvm if needed
nvm install 22
nvm use 22

# install Claude Code globally
npm install -g @anthropic-ai/claude-code

# confirm the install
claude --version

Expect output close to this, with the exact build number varying by the day you install:

2.1.280 (Claude Code)

If claude --version fails with a “command not found” error, your global npm bin directory isn’t on your shell’s PATH. Run npm config get prefix to find where npm installs global binaries, then add that directory’s bin subfolder to your PATH in .bashrc, .zshrc, or your shell’s equivalent startup file.

Step 2: Authenticate and Choose a Plan

Run claude with no arguments inside any directory to start the authentication flow. The CLI opens a browser window for you to log into your Anthropic account, or lets you paste an API key directly if you’d rather bill per token than use a subscription seat.

cd ~/projects
mkdir claude-code-demo && cd claude-code-demo
git init
claude

On first run, the CLI asks which account or API key to use and stores the credential locally so you don’t repeat this step every session. If you’re on a Team or Enterprise seat, your organization admin may need to approve the device before Claude Code will authenticate, which shows up as a pending-approval message rather than an error.

Step 3: Run Your First Session and Initialize With /init

Once you’re inside an interactive session, the single most useful first command on any new project is /init. It scans the repository, infers the stack, and drafts a starting CLAUDE.md file so the agent has working context before you ask it to do anything.

/init

Claude Code reads your package.json, lockfiles, existing README, and directory structure, then writes a draft CLAUDE.md summarizing the project. Review it before you trust it. Auto-generated summaries occasionally mischaracterize a secondary framework as primary, especially in a repo with mixed tooling. Treat the output as a first draft, not a finished config.

Step 4: Write a CLAUDE.md File That Actually Helps

CLAUDE.md is the persistent memory layer Claude Code reads at the start of every session in that directory (and in parent directories above it). It’s not a prompt you write once, it’s a living reference for conventions, commands, and constraints the agent would otherwise have to rediscover by trial and error every session.

# claude-code-demo

## Stack
Node.js 22, Express 5, Vitest for tests, ESLint + Prettier.

## Commands
- Install: npm install
- Run dev server: npm run dev
- Run tests: npm test
- Lint: npm run lint

## Conventions
- Use ES modules, not CommonJS.
- All routes live in src/routes, one file per resource.
- Every new route needs a matching test in tests/.
- Do not add new dependencies without asking first.

## Out of bounds
- Never edit files under /migrations directly; generate a new migration instead.
- Do not commit or push without explicit confirmation.

Keep it short and specific. A 40-line CLAUDE.md that lists real commands and real constraints outperforms a 400-line document that reads like an onboarding wiki, because every line in the file competes for space against the actual code the model needs to reason about. If your repository already has an AGENTS.md file from another tool, Claude Code will read that instead when no CLAUDE.md is present, a behavior Anthropic shipped in Claude Code 2.1.277 specifically so teams with multiple AI coding tools don’t have to maintain duplicate config files.

Step 5: Plan Mode and Permission Modes Explained

Before Claude Code edits anything, it’s worth understanding the two settings that control how much it does without asking. Plan mode, entered with /plan or the Shift+Tab toggle, makes the agent research and propose an approach before writing a single line, which is the right default for anything touching more than one or two files. Permission modes control what happens once it starts executing.

  • Default mode prompts for approval before each file edit or shell command.
  • Auto-accept edits lets Claude Code write file changes without asking, but still prompts before running shell commands.
  • Bypass permissions / YOLO mode skips confirmation for both edits and commands, intended for sandboxed or disposable environments only.

Check and change the current mode with /permissions. For a first session on a real codebase, stay in default mode until you’ve seen how the agent behaves on a handful of tasks. The bypass mode is genuinely useful inside a throwaway container or CI job, and genuinely risky on a machine with your production credentials sitting in environment variables.

Step 6: Create a Custom Subagent

Subagents are scoped, reusable personas Claude Code can delegate to for a specific kind of task, each with its own system prompt, its own restricted tool list, and optionally its own model. They’re defined as markdown files with YAML frontmatter, stored in .claude/agents/ for a project or in your user-level config directory for personal subagents you want available everywhere.

mkdir -p .claude/agents
cat > .claude/agents/code-reviewer.md << 'EOF'
---
name: code-reviewer
description: Reviews a diff for correctness, security issues, and test coverage gaps before a commit
tools: Read, Grep, Glob
model: sonnet
---

You are a strict code reviewer. Read the current diff, flag concrete
correctness and security issues, note missing test coverage, and
suggest specific fixes. Do not rewrite code yourself; only review it.
EOF

Invoke it from inside a session with /agents, which lists every available subagent and lets you run one directly, or just ask the main session to "use the code-reviewer subagent on this diff." Restricting the subagent's tools to Read, Grep, Glob means it can inspect code but cannot edit files or run shell commands, which is exactly the boundary a review-only persona should have.

Beyond code review, the same pattern works well for a test-writer subagent scoped to a tests directory, a docs subagent that only touches markdown files, or a migration-runner scoped to a single database schema folder. The common thread is narrowing the blast radius: a subagent that physically cannot touch files outside its lane is a much safer thing to run unattended than a general-purpose session with full tool access, even when both are driven by the same underlying model.

Step 7: Connect an MCP Server

The Model Context Protocol is the open standard Claude Code uses to pull in tools and data sources beyond the local filesystem and shell, things like a project's issue tracker, a database, or a documentation site. You add an MCP server from the terminal, outside an active session, with claude mcp add.

# a remote HTTP-based MCP server
claude mcp add --transport http claude-code-docs https://code.claude.com/docs/mcp

# a local stdio server, run as a subprocess
claude mcp add --transport stdio airtable -- npx -y airtable-mcp-server

# list configured servers
claude mcp list

# remove one
claude mcp remove airtable

Use --scope project when adding a server so teammates who pull the repo inherit the same configuration, or --scope user for servers you want available across every project on your machine. Inside a session, run /mcp to see connection status and handle OAuth authentication for servers that need it. Only add MCP servers from sources you trust. An MCP server is effectively a plugin with access to whatever the agent can see, so a malicious one is a real supply-chain risk, not a theoretical one.

Step 8: Automate Workflows With Hooks

Hooks let you run your own shell commands at specific points in Claude Code's lifecycle, which is how you turn "the agent usually remembers to lint" into "the agent cannot skip linting." Configuration lives in a settings.json file: ~/.claude/settings.json for hooks that apply everywhere, or .claude/settings.json for hooks scoped to one project and safe to commit to the repo.

Hook eventFires when
SessionStartA session begins or resumes
UserPromptSubmitYou submit a prompt, before Claude processes it
PreToolUseBefore a tool call, can allow, deny, or modify it
PostToolUseAfter a tool call completes successfully
PostToolUseFailureAfter a tool call fails
NotificationClaude Code sends a notification
PreCompactBefore conversation history gets compacted
StopClaude finishes responding
SubagentStart / SubagentStopA subagent starts or finishes
SessionEndA session ends

Writing a PostToolUse Lint Hook

The most common first hook teams add runs a linter automatically every time Claude Code edits a file, instead of trusting the agent to remember on its own.

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "npx eslint --fix $CLAUDE_FILE_PATH"
          }
        ]
      }
    ]
  }
}

Drop that into .claude/settings.json, commit it, and every teammate who runs Claude Code on the project inherits the same automatic lint pass. You can verify a hook is registered with /hooks inside a session, which lists every active hook and its matcher.

Step 9: Manage Context With /compact, /clear, and /context

Claude Code sessions accumulate context fast once you're a dozen tool calls deep into a refactor: file contents, command output, and the model's own reasoning all stay in the conversation unless you manage it. Three commands handle this directly.

  • /context shows how much of the context window is currently in use, broken down by category.
  • /compact summarizes the conversation so far into a shorter form, freeing up space while preserving the gist of what happened.
  • /clear wipes the conversation entirely and starts fresh, which is the right move between unrelated tasks rather than carrying stale context forward.

On Claude Opus 5.5, the default context window is 1 million tokens with a 128,000-token max output, which buys considerably more headroom than earlier Claude generations before you need to compact. That headroom doesn't remove the need for good habits, though: a model that can hold a million tokens can also happily burn through a much larger bill per call if you let an entire monorepo pour into context for a one-line fix. Run /clear between unrelated tasks and reach for /compact when /context shows you climbing past roughly 70 to 80% usage mid-task.

There's a second, subtler reason to compact proactively rather than waiting for a hard limit. Anthropic has acknowledged, in the context of an earlier Claude Code reliability episode, that caching and compaction logic can occasionally lose track of reasoning from earlier in a session if left unmanaged for too long. A session that compacts regularly stays coherent longer than one that runs for hours without ever summarizing, since each compaction gives the model a clean, deliberate checkpoint of what it has done so far rather than an ever-growing, unreviewed transcript.

Steps 10-13: Build a Complete Working Project — a Task API With Tests

With the fundamentals in place, the last stretch of this Claude Code tutorial builds something real: a small Express-based Task API with a health check, CRUD routes, and a test suite, driven almost entirely through Claude Code prompts rather than hand-typed code. This is the workflow that actually proves out everything configured above, and it mirrors how most teams use Claude Code day to day: a short plain-language brief, a scaffold pass, a review pass, and a commit, rather than line-by-line dictation of what to type.

Resist the urge to skip straight to a prompt without the CLAUDE.md and subagent groundwork from the earlier steps. The difference shows up immediately: a session with no project context tends to guess at conventions (CommonJS vs ES modules, which test runner, where routes live), while a session that's already read a concise CLAUDE.md gets the structure right on the first pass and spends its effort on the actual logic instead. The ten minutes spent writing that file earlier pays for itself on the very first scaffolding prompt.

Project Structure

Start a fresh session in an empty directory and describe the project in plain language, letting Claude Code scaffold it rather than writing boilerplate by hand.

mkdir task-api && cd task-api
git init
npm init -y
claude

Step 10: Scaffold the project. Inside the session, prompt: "Set up an Express 5 API with an in-memory task store, routes for GET/POST/PUT/DELETE on /tasks, and a /health endpoint. Use ES modules. Add Vitest and Supertest for testing." Claude Code plans the layout, installs dependencies, and writes the initial files, asking for approval on each shell command and file write unless you've switched to auto-accept mode.

Step 11: Review and run /init. Once scaffolding finishes, run /init to generate a CLAUDE.md tailored to the actual project (not the draft from earlier), then spot-check the generated route file.

// src/routes/tasks.js
import { Router } from 'express';

const router = Router();
const tasks = new Map();
let nextId = 1;

router.get('/', (req, res) => {
  res.json(Array.from(tasks.values()));
});

router.post('/', (req, res) => {
  const { title } = req.body;
  if (!title) return res.status(400).json({ error: 'title is required' });
  const task = { id: nextId++, title, done: false };
  tasks.set(task.id, task);
  res.status(201).json(task);
});

router.put('/:id', (req, res) => {
  const task = tasks.get(Number(req.params.id));
  if (!task) return res.status(404).json({ error: 'not found' });
  Object.assign(task, req.body);
  res.json(task);
});

router.delete('/:id', (req, res) => {
  const existed = tasks.delete(Number(req.params.id));
  if (!existed) return res.status(404).json({ error: 'not found' });
  res.status(204).end();
});

export default router;

Step 12: Ask for tests, then run them. Prompt: "Write Vitest and Supertest tests covering the happy path and the 400/404 error cases for every route, then run npm test and fix anything that fails." Claude Code writes the test file, executes npm test itself through its shell tool, and iterates on failures without you copy-pasting error output back into the chat.

$ npm test

 ✓ tests/tasks.test.js (6 tests) 142ms
   ✓ GET /health returns 200
   ✓ POST /tasks creates a task
   ✓ POST /tasks without title returns 400
   ✓ PUT /tasks/:id updates a task
   ✓ PUT /tasks/:id on missing id returns 404
   ✓ DELETE /tasks/:id removes a task

 Test Files  1 passed (1)
      Tests  6 passed (6)
   Duration  380ms

Step 13: Add the code-reviewer subagent and commit. Before committing, invoke the subagent built in Step 6: "Use the code-reviewer subagent to check the diff for this feature." Address whatever it flags, then let Claude Code stage and write the commit message, confirming before it actually runs git commit if you're in default permission mode. That closes the loop: scaffold, implement, test, review, commit, all from one terminal session.

Common Pitfalls When Adopting Claude Code

Most friction reports trace back to a handful of recurring mistakes rather than bugs in the tool itself. Each of these shows up repeatedly enough in team retros and support threads that it's worth checking your own setup against the list before you blame the model.

  • Treating CLAUDE.md as a wish list instead of rules. A file full of aspirational statements ("write clean, maintainable code") wastes context. Concrete commands and hard constraints work; vague style guidance mostly doesn't.
  • Running bypass-permissions mode outside a sandbox. Skipping confirmation prompts on a machine with real credentials turns one bad instruction into a real incident. Reserve it for disposable containers or CI.
  • Letting context balloon without compacting. A session that never runs /compact or /clear gets slower and pricier as it goes, especially on tasks that pull in large files repeatedly.
  • Adding MCP servers without checking the source. An MCP server runs with the same visibility into your project as Claude Code itself. Treat it like installing a dependency, not like flipping a feature flag.
  • Assuming a model swap is free. Switching the default model to Opus 5.5 changes latency and per-call cost because of its always-on reasoning and larger context window. Re-test token spend on high-volume, low-complexity tasks before rolling a model change out broadly.
  • Overscoping a subagent's tools. Giving every subagent the full default tool list defeats the point of delegation. Scope each one down to exactly what its job requires.

Troubleshooting Claude Code: 8 Common Errors and Fixes

These are the issues that come up most often when teams move from a first install to daily use.

SymptomLikely causeFix
EACCES error during npm install -gGlobal npm directory needs root, or ownership is wrongUse a Node version manager like nvm instead of a system Node install, so global packages don't need sudo
"command not found: claude" after installnpm's global bin directory isn't on PATHRun npm config get prefix, add that path's bin folder to your shell profile
Authentication keeps failing or loopingStale cached credential or expired sessionRun /logout inside a session, then re-authenticate with claude
Session hits a rate limit mid-taskHigh-volume usage on a shared Team/Enterprise seat, or API tier limitCheck /cost and /status for usage, stagger heavy sessions, or move to a higher API tier
Context window fills up and responses degradeLong session with no compactionRun /compact proactively, or /clear between unrelated tasks
Claude Code keeps asking for the same permissionPermission mode reset between sessions, or scope too narrowCheck /permissions and set a persistent rule for the specific tool or directory
MCP server shows as disconnectedAuth token expired, or the server process crashedRun /mcp to see status and re-authenticate, or claude mcp remove and re-add the server
Hook doesn't fireWrong matcher pattern, or hook defined in the wrong settings.json scopeRun /hooks to confirm registration, and check you edited .claude/settings.json for project scope
CLAUDE.md seems to be ignoredAn AGENTS.md file in the same directory is taking priority, or the file sits outside the working directory treeConfirm which file Claude Code is actually loading with /memory, and consolidate to one file

When none of these match your symptom, run /doctor, which diagnoses installation and configuration issues directly and is usually the fastest path to a root cause before filing a support request. Most of the entries in that table share a root cause worth internalizing: Claude Code's defaults are deliberately conservative, so a surprising number of "bugs" turn out to be the permission or scope system doing exactly what it was configured to do, just not what you expected. Checking /status, /permissions, and /mcp before assuming something is broken saves more debugging time than any single fix on this list.

Advanced Tips for Power Users

Once the basics from this Claude Code tutorial are solid, a few habits separate a team that merely has Claude Code installed from one that gets real leverage out of it.

  • Use git worktrees for parallel sessions. Running two Claude Code sessions against the same checkout causes file-state conflicts. A worktree per task lets you run multiple agents on unrelated features simultaneously without stepping on each other.
  • Pin subagent models by cost, not habit. A review-only subagent rarely needs the most expensive model available; route it to Sonnet 5.5 and reserve Opus 5.5 for the primary session doing multi-file reasoning.
  • Commit .claude/settings.json and .claude/agents/ to the repo. Hooks and subagents defined at project scope travel with the codebase, so every teammate who clones it inherits the same guardrails instead of reinventing them.
  • Use /rewind when a session goes sideways. Rather than manually reverting files after a bad multi-step edit, /rewind steps the conversation and the code changes back together.
  • Watch /cost during long sessions. It's the fastest way to catch a runaway context problem before it shows up as a surprise on the monthly invoice.
  • Give hooks a narrow matcher. A PostToolUse hook scoped to Edit|Write on every file runs on every single change, including generated files or lockfiles you don't want linted. Narrow the matcher to a path pattern or a specific tool call where possible, so the hook fires only where it's actually useful.
  • Treat CLAUDE.md as code, not documentation. Review changes to it in pull requests the same way you'd review a CI config change, since a bad edit to CLAUDE.md quietly degrades every session on that project until someone notices the agent behaving oddly and traces it back to the file.

For teams scaling usage across an engineering org, Anthropic's own quickstart documentation and slash command reference are worth bookmarking, since both get updated as new commands ship. The subagents, MCP, and hooks references cover edge cases this tutorial doesn't have room for, including advanced matcher syntax for hooks and multi-server MCP authentication flows.

Frequently Asked Questions

Is Claude Code free to use?

Claude Code itself has no separate license fee. It's included with every current Claude subscription tier (Pro at $20/month, Max at $100 or $200/month, Team, and Enterprise), and it also works with a standalone Anthropic API key billed per token for teams that would rather pay for usage directly than hold a seat.

What's the difference between CLAUDE.md and AGENTS.md?

Both are markdown files holding persistent project instructions. CLAUDE.md is Claude Code's native format, while AGENTS.md is a shared convention used across several AI coding tools. Claude Code reads AGENTS.md automatically when no CLAUDE.md exists in the working directory or a parent directory, so teams standardizing on one shared file across multiple AI tools don't need to maintain duplicates.

Can Claude Code run inside a CI/CD pipeline?

Yes. Running it non-interactively with bypass-permissions mode inside a disposable CI container is a common pattern for automated reviews, migrations, or scaffolding jobs, since there's no human available to approve prompts mid-run. Keep CI credentials scoped tightly, since an unattended agent with broad permissions in a CI environment is a meaningfully larger blast radius than the same agent on a developer's own laptop.

How big is Claude Opus 5.5's context window inside Claude Code?

Claude Opus 5.5 ships with a 1 million token default context window and a 128,000 token maximum output, per Anthropic. That's large enough to hold a mid-sized codebase and a long session history without manual chunking, though cost still scales with tokens processed, so a bigger window doesn't mean context management stops mattering.

What's the difference between a subagent and an MCP server?

A subagent is a scoped persona within Claude Code itself, with its own system prompt and restricted tool access, used to delegate a specific kind of task like code review or test-writing. An MCP server is an external connector that gives Claude Code access to a new tool or data source entirely, like a database, an issue tracker, or documentation search. They're complementary: a subagent can use an MCP server's tools if you grant it access.

Why does Claude Code keep asking for permission on every edit?

That's the default permission mode working as intended, prompting for approval before each file edit or shell command. If the prompts are slowing down a workflow you trust, switch to auto-accept-edits mode with /permissions, which still confirms before running shell commands but stops asking for simple file writes.

Does switching to Claude Opus 5.5 change how Claude Code behaves?

Yes. Opus 5.5 reasons by default through always-on adaptive thinking rather than offering a separate toggle, which tends to improve output on multi-step tasks but adds latency and token cost on simple ones. Claude Code 2.1.280 made Opus 5.5 the default Opus model, so teams upgrading from an earlier Claude Code version should expect a different latency and cost profile even without changing anything else in their workflow.

Can multiple developers share the same CLAUDE.md, hooks, and subagents?

Yes, and it's the recommended setup. CLAUDE.md, .claude/agents/, and project-scoped .claude/settings.json all live inside the repository, so committing them means every teammate who clones the project gets the same configuration, hooks, and subagents without any manual setup beyond installing the CLI itself.