Claude Code Changed How People Work. Here's How to Actually Use It.

Last updated August 20, 2026: This guide now reflects Claude Code 2.1.237, Claude Opus 5, Sonnet 5, Fable 5, the desktop and Linux apps, web and mobile sessions, automatic memory, agent view, dynamic workflows, current installation methods, and Anthropic's latest plan limits.

Claude Code can build an app, clean up a chaotic folder, research a market, turn raw notes into a presentation, or keep a long project moving while you do something else.

You don't need to be a developer to find that useful. You do need to understand which Claude product you're looking at, because Anthropic has turned one command-line tool into a small fleet of overlapping agents.

Claude Code now runs in the terminal, VS Code, JetBrains IDEs, Anthropic's desktop app, a browser, and cloud environments you can monitor from your phone. It can read files, run commands, connect to outside services, remember project conventions, schedule recurring work, and split a large job across multiple agents.

That is a lot more than “AI that writes code.” It is also a lot to drop on someone who only wanted help organizing receipts.

This guide starts at zero. We'll explain what Claude Code is, where to use it, which model to pick, how to give it context, how to keep it from wandering off, and how non-developers can use the same ideas without living in a terminal window.

First, what is Claude Code?

Claude Code is Anthropic's agentic work system built around software development. You describe an outcome in ordinary language. Claude can inspect the relevant files, make a plan, edit those files, run tools, check its work, and report back.

The word agent matters. A normal chatbot tells you how to do something. An agent can take the steps, within the permissions and tools you give it.

For a developer, that might mean tracing a bug through a repository, changing five files, running the tests, and opening a pull request. For everyone else, it might mean reading a folder of reports, extracting the important numbers, researching missing context, and producing a finished brief.

Software is still Claude Code's home turf. Its strongest integrations assume files, projects, Git repositories, terminals, and development tools. But its underlying pattern is much broader: give an agent a workspace, clear instructions, useful tools, and a way to verify the result.

If you're comparing Anthropic's agent with OpenAI's, our updated Codex beginner's guide covers the same questions from the other side.

What changed since Claude Code first went viral

The early mental model was simple: install a terminal tool, open a folder, type claude, and start talking. That still works, but it now describes only one part of the product.

As of August 20, 2026:

• Claude Code 2.1.237 is the current CLI release. Anthropic ships updates constantly, so run claude --version instead of assuming a tutorial's screenshots still match your installation.
• Claude Opus 5 and Sonnet 5 are the main current models. Fable 5 sits above them for the hardest and longest-running work, while Haiku remains the fast option for lighter tasks.
• The recommended CLI installation is native. Anthropic provides install scripts, Homebrew, WinGet, apt, dnf, and apk options. The old npm install -g route is no longer the default recommendation.
• Claude Code has a real desktop interface. It supports macOS, Windows, Windows ARM64, and Linux in beta, with multiple sessions, visual diffs, file editing, previews, scheduled tasks, and no terminal requirement.
• Web and mobile are first-class surfaces. Cloud sessions keep running after you close your laptop, and Remote Control lets a phone or browser steer a local session.
• Memory is partly automatic. CLAUDE.md still carries instructions you write, while auto memory saves useful project knowledge Claude discovers as it works.
• Parallel work has several levels. Subagents, agent view, experimental agent teams, worktrees, and dynamic workflows solve different coordination problems.
• Automation has grown up. /goal, cloud Routines, scheduled desktop tasks, hooks, plugins, MCP connections, and cross-session messaging can keep work moving without constant babysitting.

The core product is still recognizable. The edges are where most old guides now break.

Pick the surface that fits you

There is no prize for choosing the most technical interface. Start with the one that makes the work easiest to see and review.

Claude desktop: the easiest starting point

The Claude desktop app is the best on-ramp for most beginners. Open the Code tab, choose a folder or repository, describe the result you want, and review changes visually.

The app can run several sessions side by side, isolate parallel coding work with Git worktrees, show diffs, preview an app, monitor pull requests, and schedule recurring local tasks. It is available on macOS and Windows, including Windows ARM64, with Linux support currently in beta.

The desktop app has three related but distinct tabs:

• Chat is the familiar conversational Claude experience and does not get direct access to your local files.
• Cowork runs broader work in a sandboxed virtual machine, locally or remotely, and is aimed at delegated knowledge work.
• Code is the Claude Code interface with direct project and development tooling.

That distinction is important. Cowork and Claude Code share models, subscriptions, and some agent ideas, but Anthropic's current documentation treats Cowork as a separate product surface.

The terminal: the full-power option

The CLI remains the most flexible version of Claude Code. It fits naturally into Git, scripts, CI systems, remote servers, and developer workflows. It is also where new orchestration features tend to appear first.

You don't need to memorize commands. The terminal matters because it gives Claude access to the same tools a person would use to inspect a project, run a build, search files, or automate repeatable work.

VS Code and JetBrains: stay inside your editor

The VS Code extension provides inline diffs, file mentions, plan review, and conversation history inside the editor. It also works in Cursor. JetBrains users can run Claude Code through the supported plugin and IDE terminal workflow.

This is a comfortable middle ground: more visual than a plain terminal, but still attached to the files and diagnostics developers already use.

Web, cloud, and mobile: hand off work and leave

Claude Code on the web runs inside Anthropic-managed cloud environments. Sessions survive a closed browser or sleeping laptop, and you can monitor or steer them from the Claude mobile app.

From the CLI, claude --cloud "your task" starts a new cloud session. You can later pull a cloud session into the terminal with --teleport, or use Remote Control to keep a local session running while you step away.

This is useful for work that takes 20 minutes, not 20 seconds: a large test run, a repository migration, a deep review, or research that needs several passes.

How to install Claude Code now

If you want the visual route, install the Claude desktop app and open the Code tab. A Pro, Max, Team, or Enterprise subscription is required.

For the CLI, Anthropic currently recommends its native installer.

On macOS, Linux, or WSL:

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

On Windows PowerShell:

irm https://claude.ai/install.ps1 | iex

Homebrew users can install the stable channel with:

brew install --cask claude-code

Windows users can also use WinGet:

winget install Anthropic.ClaudeCode

Native installations update in the background. Homebrew and WinGet installations do not, so upgrade them through the same package manager. Anthropic also provides packages for Debian, Fedora, RHEL, and Alpine.

Once installed, move into the folder you want Claude to work in and start a session:

cd your-project
claude

You can sign in with a paid Claude account, a Claude Console account with pay-as-you-go billing, or supported enterprise providers including Amazon Bedrock, Google Cloud, Microsoft Foundry, and Claude Platform on AWS. Exact model availability varies by provider.

Which Claude model should you use?

The old advice to “always use Opus 4.5 or 4.6” has expired. Claude Code now uses model-family aliases that move forward as Anthropic releases newer versions.

Run /model to see what your account can use. For most people, these four choices matter:

• Sonnet 5 is the everyday model. It is the default in Claude Code for Pro, Team Standard, and Enterprise subscription seats. It is fast enough for regular work and has a native one-million-token context window on Anthropic's API.
• Opus 5 is for complex reasoning, architecture, debugging, and high-stakes changes. It is the Claude Code default for Max, Team Premium, usage-based Enterprise, and Anthropic API users. It is also the strongest option available on Pro.
• Fable 5 is Anthropic's most capable Claude Code model for work that is larger than a single sitting. It is never the automatic default, may require usage credits, and is best saved for problems that truly benefit from longer autonomous work.
• Haiku is the speed and efficiency choice for small questions, formatting, classification, and mechanical edits.

You can select a model by family name rather than pinning today's version:

/model sonnet
/model opus
/model fable

Effort is a separate control. /effort lets you trade speed and token use for deeper reasoning. High is the current default on the newest supported models, while xhigh and session-only max are useful for difficult work. More thinking is not automatically better; a simple file rename does not need a philosophical retreat.

There is also an opusplan mode that uses Opus for planning and Sonnet for execution. It is a sensible option when the architecture is hard but the implementation is routine.

Build a workspace, not a shrine

Many early Claude Code tutorials taught users to create an elaborate “second brain” before doing any real work: context folders, command libraries, output directories, priming rituals, and a giant instruction file.

That can work. It can also turn setup into a hobby.

The current beginner version is simpler:

1. Open the folder that contains the work.
2. Add a concise CLAUDE.md with rules Claude should know every session.
3. Let auto memory capture useful project facts as they emerge.
4. Add skills, rules, hooks, or MCP connections only when a repeated need appears.

For a software project, the folder may be a Git repository. For non-code work, it can be a research folder, a collection of documents, or a workspace with inputs and an outputs directory.

The folder is not magical. It is simply the boundary that tells Claude where to look and what belongs to the task.

CLAUDE.md is still your instruction manual

CLAUDE.md remains one of Claude Code's most useful features. It is a plain Markdown file containing instructions Claude should load whenever it works in that project.

Use it for facts and rules that would otherwise need repeating:

• what this project is for;
• where important files live;
• which commands build, test, or validate the work;
• writing or coding conventions;
• actions Claude must never take without asking;
• the format finished work should use.

Keep it concise. Anthropic says shorter files produce better adherence, and files over roughly 200 lines can become expensive background context. If a rule applies only to one directory or file type, put it in .claude/rules/. If it is a multi-step procedure, turn it into a skill.

You can create a starting file with:

/init

Claude analyzes the project and proposes useful build commands and conventions. Treat that draft as onboarding material, not scripture. Delete anything generic and add what Claude could not discover on its own.

One habit from Claude Code creator Boris Cherny still holds up: when Claude repeats a mistake, add the correction to CLAUDE.md. The goal is not to document every thought. It is to stop paying for the same misunderstanding twice.

Automatic memory changes the “second brain” advice

Every Claude Code session starts with a fresh context window, but the product now carries knowledge forward in two ways:

• CLAUDE.md contains instructions you write.
• Auto memory contains useful notes Claude writes for itself.

Auto memory is on by default in current versions. Claude can remember build commands, architecture notes, debugging discoveries, and preferences without you ending every session with “please update the knowledge base.” Run /memory to inspect, edit, or disable what it has saved.

That does not make context management irrelevant. A long conversation still accumulates file contents, command output, loaded skills, tool results, and dead ends. Use:

• /context to see what is taking up space;
• /compact to summarize the conversation while keeping the current task alive;
• /clear when you are switching to unrelated work;
• /resume to return to a named older session.

Sonnet 5 has a native one-million-token context window on Anthropic's API, and several newer Claude models support extended context. That is far larger than the 200,000-token window quoted in older guides. It is not permission to dump a filing cabinet into every prompt. Large, irrelevant context still costs time and usage.

The durable lesson is the same: context beats prompt cleverness. Give Claude the right source material, current rules, and a clear definition of done. A poetic prompt cannot rescue missing information.

Start difficult work in plan mode

Plan mode lets Claude inspect a project and propose an approach without editing the source. In the CLI, press Shift+Tab until the status bar shows plan mode, prefix one request with /plan, or launch with:

claude --permission-mode plan

Use it when the cost of a wrong approach is higher than the cost of a five-minute review: database changes, a large refactor, a new automation, or anything involving several systems.

A useful plan should tell you:

• what Claude believes you asked for;
• which files, systems, or data it needs;
• the order of operations;
• what could go wrong;
• how it will verify the result.

When the plan is ready, you can approve it, keep planning with feedback, open it in your editor, or choose how much permission Claude gets during execution.

The product now has several permission modes:

• Ask before edits is the safest starting point.
• Auto accept edits lets Claude change files while you review the diff afterward.
• Plan mode permits exploration but not edits.
• Auto mode reduces approval prompts while a separate safety classifier reviews actions. It is still a research preview and is not available on every plan or provider.
• Bypass permissions removes the normal guardrails and belongs only inside an isolated environment you are prepared to lose.

Older tutorials often recommend aliases that launch Claude with --dangerously-skip-permissions. Beginners should not make that their default. Speed is nice. An agent with broad access and no review is still an agent with broad access and no review.

Skills, commands, hooks, MCP, and plugins

Claude Code's customization layer has become easier to understand, even if the vocabulary still sounds like a convention badge lanyard.

Skills package repeatable work

A skill is a folder with a SKILL.md file that teaches Claude a reusable procedure. You might create a skill for a weekly client report, a security review, a product-requirements document, or a deployment checklist.

Claude can load a skill automatically when it matches the task, or you can invoke it directly with /skill-name. Custom slash commands have now been merged into skills. Old files in .claude/commands/ still work, but .claude/skills/<name>/SKILL.md is the recommended format for new workflows.

Hooks run at lifecycle events

Hooks fire when something happens, such as a file edit, a tool call, a completed task, or a teammate going idle. They are useful for formatting, tests, notifications, policy checks, and quality gates that should run consistently rather than relying on Claude to remember.

MCP connects outside systems

The Model Context Protocol gives Claude access to tools and data beyond the local folder. An MCP server can connect Jira, Slack, Google Drive, a database, a browser, or an internal service.

Treat MCP access like giving a coworker credentials. Start read-only when possible, grant the narrowest useful permissions, and make write actions easy to review.

Plugins bundle the whole setup

Plugins package skills, hooks, subagents, MCP servers, and other configuration so a workflow can be reused across projects or distributed through a marketplace.

Do not install ten plugins on day one. Add one when it removes a repeated setup step you can already describe.

Parallel agents: choose the right level

The phrase “run an army of Claudes” is catchy. It is also an expensive way to learn that nine agents can be confused at the same time.

Claude Code now offers several distinct ways to parallelize work:

Subagents

Subagents handle focused side jobs in their own context and return a summary to the main session. Use them when research, logs, or file reading would clutter the main conversation.

Agent view

Run claude agents to open a research-preview dashboard for background sessions. It shows what is running, finished, or waiting for you. Agent view is best when several jobs are independent and you want to manage them yourself from one screen.

Agent teams

Agent teams are experimental and disabled by default. A lead session coordinates teammates through a shared task list and direct messaging. Unlike subagents, teammates can communicate with each other.

Enable the feature in settings with:

{
"env": {
"CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
}
}

Agent teams help when workers must compare findings or coordinate separate parts of one project. They use significantly more tokens, add coordination overhead, and do not automatically isolate teammates in separate worktrees. Start with three to five teammates only when the tasks are genuinely independent.

Dynamic workflows

Dynamic workflows are for work larger than a handful of agents: codebase-wide audits, hundreds of file changes, multi-pass research, or jobs where several findings must be checked against each other. A script holds the plan and orchestrates the subagents, which makes the process less dependent on one lead agent keeping every thread in its head.

Worktrees

Git worktrees give parallel sessions separate checkouts so they do not edit the same files. Use them whenever two coding sessions might touch overlapping parts of a repository. The desktop app and agent view can handle much of this isolation automatically.

The beginner rule is simple: one agent first, subagents second, a team only when the work needs communication, and dynamic workflows only when the job has outgrown a conversation.

Give Claude a way to verify its work

This remains the most important practical advice in the original guide.

An agent cannot reliably improve what it cannot inspect. For code, give Claude tests, a build command, a browser preview, logs, a simulator, or a reproducible error. For non-code work, give it source links, a checklist, a required schema, known totals, or an example of a correct final deliverable.

Instead of saying:

Make this presentation better.

Try:

Rebuild this presentation for a first-time buyer. Keep it under 12 slides, preserve every cited number, use one idea per slide, render the result, and check for clipped text before you finish.

The second prompt gives Claude a target and a test. That is more useful than adding “think harder” six times.

Ask for evidence proportional to the risk. A casual brainstorm can come back as prose. A financial analysis should show its inputs and calculations. A website should be opened and tested. A production change should pass its automated checks and still receive human review.

Claude Opus 5 and Fable 5 are better at self-verification than earlier models, but model improvements do not remove the need for observable checks. “Claude said it worked” is not a test result.

Claude Code for non-developers

Non-developers have two reasonable paths.

The first is the Claude desktop app's Code tab. It removes the terminal while keeping direct access to a chosen folder, visual diffs, previews, and multiple sessions. This works well for technically adjacent jobs: building a small website, cleaning structured files, analyzing data, creating an internal tool, or managing a project with lots of documents.

The second is Cowork. It is built for broader knowledge work and runs jobs inside a sandboxed virtual machine. Cowork can work with documents, spreadsheets, browser tasks, connected services, and files without asking you to think like a software engineer.

In Boris Cherny's original Cowork demo, Claude renamed receipt files from the dates inside the PDFs, extracted the line items into a spreadsheet, moved the data into Google Sheets, and drafted an email. That remains a useful example because the job has clear inputs, visible steps, and an output a person can check.

The updated distinction is this: Cowork is not simply Claude Code with nicer buttons. It is a separate Anthropic product built around delegated computer work. Use Code when the folder or repository is the center of the job. Use Cowork when the job spans documents, apps, and browser actions.

Good first projects for a non-developer include:

• rename and organize a folder of documents using a consistent rule;
• compare several vendors and produce a sourced decision brief;
• turn meeting notes into a project plan with owners and deadlines;
• clean a CSV and create a chart-ready workbook;
• build a simple internal webpage from a written description;
• review a content archive for broken links, duplicates, or outdated claims;
• create a repeatable weekly report from the same source files.

Start with copies of important files. Review the first run closely. Increase permissions only after you understand what the workflow touches.

Plans, pricing, and usage limits

Claude Code is included with every paid Claude plan. It is not currently included with the Free plan as a standalone benefit, although Free users can use Claude's regular chat and creation features.

Current individual pricing is:

• Pro: $20 per month, or $200 per year.
• Max 5x: $100 per month.
• Max 20x: $200 per month.

Team Standard and Premium seats add centralized billing and collaboration, while Enterprise adds deeper security, governance, retention, identity, and compliance controls. Enterprise's current self-serve structure charges a seat fee plus usage at API rates. Check the live Claude pricing page before purchasing; these are precisely the numbers product teams enjoy changing after an article ranks.

Usage across Claude web, desktop, mobile, Cowork, and Claude Code draws from the same account pool. Every plan uses a rolling five-hour session window, and paid plans add weekly limits. The amount consumed depends on the model, context size, effort, parallel agents, and tools involved, so there is no reliable “messages per day” number.

Use /usage in Claude Code or Settings → Usage in the Claude apps to see your current limits. Paid users can enable usage credits to keep working at standard API rates after included capacity runs out. API and supported cloud-provider accounts use their own metered billing and rate limits.

One recent quality-of-life improvement is worth knowing: since Claude Code 2.1.234, the CLI can automatically continue a session when its usage limit resets. You can turn that behavior off in /config. It does not create more usage, but it means a long-running task does not need a ceremonial restart when the clock rolls over.

Parallel sessions and agent teams burn through limits faster because each worker has its own context and model calls. More agents increase throughput only when the work actually splits cleanly.

The practical beginner workflow

You do not need a perfect setup. You need one useful task with a result you can judge.

1. Choose the surface. Start in desktop Code if you want a visual interface, Cowork for general computer work, or the CLI if you are comfortable in a terminal.
2. Work on a copy. Use a test repository or duplicate folder until you understand the permission model.
3. Describe the outcome. Include the audience, constraints, source material, and what “done” means.
4. Ask Claude to inspect before acting. For a complex job, use plan mode and review the proposed approach.
5. Give it a check. Tests, a rendered preview, source citations, a checklist, or a known total all work.
6. Review the result. Look at changed files, diffs, calculations, and external actions before accepting them.
7. Save what should repeat. Put permanent rules in CLAUDE.md, let auto memory retain discoveries, and turn repeated procedures into skills.
8. Add parallelism last. Use a subagent for one contained side job before you create a team.

The fastest way to become good at Claude Code is not to copy a power user's entire dot-folder. It is to finish three real tasks, notice where the agent got confused, and improve the system around those failures.

Useful commands to know

You can get far without memorizing any of these, but the following commands solve the most common problems:

• /help shows the current command list.
• /model switches models and saves your choice for future sessions.
• /effort adjusts how much reasoning the active model uses.
• /plan starts one request in plan mode.
• /usage shows plan consumption, reset timing, and usage drivers.
• /context explains what is occupying the context window.
• /compact summarizes the current conversation.
• /clear starts fresh for a new task.
• /memory shows CLAUDE.md, rules, and automatic memory.
• /resume returns to an earlier session.
• /tasks shows background and cloud work.
• /goal gives Claude a completion condition and lets it keep working across turns.
• /schedule creates a recurring cloud Routine from the CLI.
• /desktop hands a terminal session to the visual desktop app where supported.

Commands change quickly. The official Claude Code changelog is a better source than a screenshot from six months ago.

Where this is going

The original Claude Code story was about replacing keystrokes. The current product is about moving responsibility.

Developers still decide architecture, risk, priorities, and what belongs in production. Operators still decide which source is trustworthy, which customer gets contacted, and whether a number makes sense. Claude increasingly handles the searching, editing, running, checking, and packaging between those decisions.

That changes the useful human skill. The person who gets the most from Claude Code is not always the person who types fastest. It is the person who can define a good outcome, supply the right context, design a check, and notice when the result does not add up.

Boris described Claude Code as intentionally general because Anthropic did not yet know which workflows users would invent. That bet has aged well. The product now includes more interfaces, memory, orchestration, and automation, but the best starting move has not changed: give it one real job and watch what happens.

Quick-start checklist

• Install the Claude desktop app or the native Claude Code CLI.
• Open a test folder or repository.
• Run /init and trim the resulting CLAUDE.md to rules that matter.
• Start one concrete task in plan mode.
• Review the plan before allowing edits.
• Give Claude a way to test or verify the result.
• Check /usage and /context during longer work.
• Review auto memory with /memory after a few sessions.
• Turn a repeated procedure into a skill.
• Try a subagent before enabling an agent team.
• Use Cowork instead when the job is primarily documents, apps, or browser work.

Videos referenced in the original guide

• Boris Cherny on Startup Ideas Podcast: Cowork demonstrations, Claude Code setup, and parallel workflows.
• Boris Cherny at AI Engineer World's Fair: the history of programming interfaces, planning, and Claude Code's design philosophy.
• Simon Scrapes: Agent Teams in 13 Minutes: subagents, agent teams, and coordination tradeoffs.
• John Kim: Claude Code Workflows That 10x Productivity: persistent project knowledge, skills, and automation.
• John Kim: Claude Code on Phone: mobile task steering and the limits of phone-only review.
• Liam Ottley: Ultimate Beginner's Guide: workspaces, context, planning, and repeatable commands.
• Simon Scrapes: 10 Tips That Change Everything: skills, hooks, commands, and verification techniques.