15 Claude Code Tips: Beginner to Pro

"The most important things you need to know about Claude Code at every stage. Installation, permissions, context window management, Git workflows, debugging, agent teams, MCP servers, work trees, and the mindset that separates AI developers from accept monkeys."

Version 1.0.0 • Updated 03/01/2026, 12:00 PM EST

Part 0: Intro

Claude Code is the most powerful AI development tool available today. But power without clarity is just confusion.

This tutorial cuts through the noise. It covers the 15 most important tips for using Claude Code effectively, organized into three tiers: beginner, intermediate, and pro. Whether you just installed it or you've been shipping with it for months, there's something here for you.

What this tutorial will show you is:

• ✅ Get Claude Code installed and running in under a minute
• ✅ Understand permission levels and when to use each one
• ✅ Use plan mode to think before coding
• ✅ Manage your context window (the single most important intermediate skill)
• ✅ Use Git and GitHub for real version control
• ✅ Debug with screenshots, error logs, and test-driven development
• ✅ Use Claude Code as a research agent with live web data
• ✅ Install and invoke skills from the marketplace
• ✅ Run agent teams for parallel task execution
• ✅ Connect MCP servers for external tool integration
• ✅ Use work trees to build features simultaneously in separate branches

What to expect: This tutorial is structured in three sections. Start where you are, read what's relevant, skip what you already know.

Tutorial Path

Section 1: Beginner (Tips 1-5)

1. Part 1: Installation (2 min)
2. Part 2: IDEs and Graphical Interfaces (5 min)
3. Part 3: Permission Levels (5 min)
4. Part 4: Plan Mode (10 min)
5. Part 5: Essential Slash Commands (5 min)

Section 2: Intermediate (Tips 6-10)

6. Part 6: Context Window Management (10 min)
7. Part 7: Git and GitHub (10 min)
8. Part 8: Debugging (5 min)
9. Part 9: Claude Code as a Research Agent (5 min)
10. Part 10: The Mindset Shift (10 min)

Section 3: Pro (Tips 11-15)

11. Part 11: Skills (10 min)
12. Part 12: Agent Teams (10 min)
13. Part 13: MCP Servers (10 min)
14. Part 14: Frameworks (5 min)
15. Part 15: Work Trees (10 min)

Requirements

• A computer (Mac, Windows, or Linux)
• A terminal application
• Claude Code installed (we cover this in Part 1)
• Anthropic API key or Claude Max subscription

Section 1: Beginner

Part 1: Installation (2 min)

One Command

Anthropic has simplified installation down to a single line. Open your terminal and run the command for your operating system. It walks you through the setup process interactively.

The full install takes less than a minute. Claude Code will prompt you to authenticate with your Anthropic account or API key.

For the latest install instructions, check the official docs: https://docs.anthropic.com/en/docs/claude-code

Verify It Works

After installation, type:

claude --version
Click to copy

If you see a version number, you're good to go. Type claude to start a session.

Part 2: IDEs and Graphical Interfaces (5 min)

You Don't Have to Live in the Terminal

The terminal can be intimidating if you've never used one. The good news: you don't have to stay there. Claude Code works inside IDEs (Integrated Development Environments), which give you a graphical interface alongside the Claude Code terminal.

Options

Visual Studio Code (VS Code) - Free. The most popular option. You get:

• Claude Code running in the integrated terminal
• A file explorer on the left showing all your project folders and files
• Click any file to see and edit its contents
• Full syntax highlighting and code navigation

Cursor - A VS Code fork with additional AI features built in. Claude Code runs in its terminal just the same.

Claude Code Desktop - Anthropic's own desktop interface. Full Claude Code power with a more approachable UI.

Which One to Pick

If you're just starting out, go with VS Code. It's free, it's the industry standard, and the integrated terminal means you never have to leave the window. You get Claude Code on one side and your project files on the other.

Part 3: Permission Levels (5 min)

What Permissions Control

Permissions dictate what Claude Code can and cannot do without your explicit approval. You cycle through them by pressing Shift+Tab on the keyboard.

The Three Levels

Default (No Permissions Shown)

• Claude can read files on its own
• Any edits or changes require your approval first
• This is the safest setting

Accept Edits On

• Claude can make file changes without asking
• Bash commands (installing dependencies, deleting files, interacting with your system) still require your approval
• Good middle ground for daily work

Bypass Permissions On

• Claude can make file changes AND run bash commands without asking
• Requires starting Claude Code with a special flag:

claude --dangerously-skip-permissions
Click to copy

• This is faster but less safe. Claude could theoretically run destructive commands without your approval.

Which to Use

Start with Accept Edits On while you're getting comfortable. It lets Claude work efficiently on code changes while still requiring your OK before it runs system commands.

As you gain experience and confidence, move to Bypass Permissions On for faster workflows. The name sounds scary, but in practice, Claude Code rarely does anything destructive unprompted.

Part 4: Plan Mode (10 min)

The Most Powerful Feature for New Projects

Plan mode changes how Claude Code approaches your request. Instead of immediately writing code, it has a conversation with you first. It asks questions, explores options, and produces a structured plan before touching a single file.

How to Activate It

Press Shift+Tab to cycle through modes until you see Plan Mode On.

How It Works

1. You give Claude Code a task: "Create a simple task tracker app with React and basic UI"
2. Instead of coding immediately, Claude asks clarifying questions
3. You have a back-and-forth conversation about the approach
4. Claude produces a structured plan: setup steps, files to create, app design, implementation steps, and verification
5. You review the plan
6. You're presented with options:
   • Yes, clear context - Execute the plan and reset the context window (recommended)
   • Yes, bypass permissions - Execute with full permissions
   • Yes, manually approve edits - Execute but ask before each change
   • Or tell Claude what to change before executing

Why "Yes, Clear Context" Matters

When you approve with "clear context," Claude resets the context window before executing. This is important because the planning conversation consumed tokens. By clearing, Claude starts the actual coding with a fresh context window and the plan as its guide. You get better output because Claude isn't dragging along the full planning conversation.

What the Plan Looks Like

A good plan includes:

• Setup - What needs to be installed, configured, or scaffolded
• Files - What files will be created or modified
• Design - High-level architecture and component structure
• Steps - Ordered implementation steps
• Verification - How to confirm everything works

The Rule

Always use plan mode when starting a new project or implementing a major feature. It takes an extra few minutes upfront but saves hours of rework.

Part 5: Essential Slash Commands (5 min)

How to Access Them

Type / in the prompt window to see all available slash commands. Claude Code explains what each one does.

The Ones You Need to Know

/model - Switch between models.

• Opus 4.6 (most powerful, most expensive)
• Opus 4.6 with extended context window
• Sonnet (fast, cost-effective for routine work)
• Haiku (cheapest, good for simple tasks)

You can also adjust the effort level for how much thinking Opus does. Not every task needs maximum effort.

/rewind - Go back in time. Reverts both the conversation AND the code to a previous point. Think of it as loading a save point in a video game. If Claude did something you didn't like, /rewind is faster than explaining what to undo.

/context - See how much of your context window has been used. Shows current tokens out of the 200K total and the percentage consumed. This is critical for intermediate-level context management (covered in Part 6).

/clear - Reset the conversation history and token count. Starts the session fresh without losing your actual code files.

/compact - Compress the conversation to save tokens without fully clearing.

/help - Lists all available commands including any custom ones you've created.

Section 2: Intermediate

Part 6: Context Window Management (10 min)

This Is the Most Important Intermediate Skill

If you learn one thing from this entire tutorial, let it be this: managing your context window is what separates productive Claude Code users from people who constantly get bad output.

Tokens: The Currency of AI

Everything Claude does costs tokens. Sending a message, receiving a response, tool usage, system prompts, MCP connections: all of it consumes tokens from your budget.

Claude Code's context window is 200,000 tokens.

The Context Rot Problem

The problem isn't the size of the window. It's what happens when you fill it up. Research shows that when you hit roughly 100,000 to 120,000 tokens (the halfway mark), the quality of Claude's output drops significantly. Responses get less coherent. Claude "forgets" earlier context. Instructions get missed.

This is called context rot, and it's the silent killer of Claude Code sessions.

The Rule

Stay out of the back half of your context window. If you're approaching 50-60%, it's time to think about resetting.

How to Monitor

Option 1: Manual check

/context
Click to copy

This shows your current token usage. Check it periodically.

Option 2: Status line (always visible)

You can set up a persistent status line at the bottom of your terminal that always shows:

• Current directory
• Active model
• Context window percentage

To set this up, tell Claude Code:

Build me a status line with context window percentage always visible
Click to copy

Claude Code will configure it for you. Now you always know where you stand.

How to Reset

When you're approaching the danger zone:

/clear
Click to copy

This resets the conversation and token count. Your code files are untouched. Claude Code can still read your project files and understand the current state. You're not losing work, you're just clearing conversational context.

Why This Beats Auto-Compaction

If you never manually clear, Claude Code will auto-compact when it hits the limit. This is worse because:

• Auto-compaction fires at the worst possible time (mid-task, at the limit)
• You have no control over what gets preserved vs. discarded
• Output quality has already degraded by the time it triggers

Manual management keeps you in the quality zone. Auto-compaction is the emergency parachute you never want to use.

Part 7: Git and GitHub (10 min)

Why /rewind Isn't Enough

The /rewind command is a quick save point inside Claude Code. It works, but it's a beginner's approach to version control. It only exists within your current session.

Git and GitHub are the real solution. Git creates code save points (called "commits") locally. GitHub stores them online where you can access them from anywhere, roll back to any point, and collaborate with others.

Setting It Up

Tell Claude Code:

Connect my GitHub account, commit this code, and then push
Click to copy

Claude Code walks you through:

1. Connecting GitHub - Authenticating your account (one-time setup)
2. Committing - Creating a save point of your current code. "Commit" = "save"
3. Pushing - Uploading that save point to your GitHub repository. "Push" = "upload to GitHub"

The Workflow

As you build, commit regularly:

• Finished a feature? Commit.
• About to try something risky? Commit first.
• End of a coding session? Commit and push.

If something breaks, you can roll back to any previous commit. Your entire code history lives on GitHub, accessible from any machine.

Why This Matters

Without Git, your only safety net is /rewind (limited to the current session) and "undo" (limited to the last few changes). With Git, you have a complete, permanent history of every version of your code. This is industry standard for a reason.

Part 8: Debugging (5 min)

Three Approaches to Fixing Things

1. Screenshots

If something looks wrong in your app, take a screenshot and drop it directly into the Claude Code prompt. Just like attaching an image in ChatGPT. Claude Code can see the visual issue and fix it. This is faster and more accurate than describing the problem in words.

2. Copy-Paste Error Logs

If you get errors from external services (deployment platforms like Vercel, CI/CD pipelines, browser consoles), copy the error text and paste it into Claude Code:

I'm getting this error when deploying to Vercel: [paste error here]
Click to copy

Claude Code reads the error, identifies the root cause, and fixes it.

3. Avoid Bugs in the First Place

During your planning phase, tell Claude Code:

Execute this in a test-driven development manner
Click to copy

This means Claude writes tests before writing the actual code. Tests define what the code should do. The code is then written to pass those tests. Bugs get caught immediately instead of in production.

Part 9: Claude Code as a Research Agent (5 min)

More Than Just a Coding Tool

Claude Code has web search capability. It can go online, find current information, and use that data to improve its work.

Why This Matters

Claude's training data has a knowledge cutoff. Things that happened after that cutoff (new libraries, updated best practices, new APIs, security advisories) aren't in its base knowledge. Web search fills that gap.

How to Use It

Instead of:

Make this app look nicer
Click to copy

Say:

Make this app look nicer. Use your web search to look up best practices
for UI design in 2026.
Click to copy

Claude Code will search the web, find current design patterns and best practices, and apply them to your project. This works for anything: framework updates, library comparisons, deployment strategies, security practices.

When to Trigger It

Anytime you want Claude Code to work with information that might have changed since its training cutoff, explicitly tell it to use web search. Claude Code has the tool available but doesn't always use it unless prompted.

Part 10: The Mindset Shift (10 min)

The Real Bottleneck Is You

This is the most important tip in the entire tutorial, especially for people coming from a non-technical background.

The thing that will trip you up most is that you don't know what you don't know. You will walk into minefields you didn't know existed if you don't tell Claude Code that you need guidance.

The Accept Monkey Problem

Claude Code is good enough that you can get pretty far by just hitting accept on everything. But at a certain point, you hit a wall. The projects get more complex. You don't know the right questions to ask. You can't evaluate whether Claude's approach is correct because you never learned the building blocks.

This is the difference between a "vibe coder" and an actual AI developer.

The Fix: Active Participation

You don't need to know how to code. But you do need to understand how the building blocks come together. And the way to get there is by being an active participant, not a passive acceptor.

Questions you should be asking regularly:

• "What am I not thinking about?"
• "Is this the best approach, or are there alternatives?"
• "What would an expert in [your domain] be doing here?"
• "Explain why you chose this approach over others"
• "What are the tradeoffs of this decision?"
• "What could go wrong with this approach?"

When Claude does something:

If Claude tells you it did something and you don't understand what any of it means, stop and ask. Don't just accept and move on. Ask Claude to explain what it did and why. You're building understanding that compounds over time.

Plan Mode Is Your Safety Net

When building complex features, plan mode prompts you with questions. But you're still leading the way. The gap between "blindly hoping Claude leads you right" and "confidently directing the build" is closed by asking better questions.

This takes time and experience. But starting now, with every session, makes every future session better.

Section 3: Pro

Part 11: Skills (10 min)

What Skills Actually Are

There's a lot of noise around skills. Here's the simple truth: skills are just Markdown files. They are text-based prompts that tell Claude Code how to do something specific in a specialized way.

No special tools. No fancy infrastructure. Just well-crafted instructions in a .md file.

Example: The Front-End Design Skill

The official front-end design skill from Anthropic is just a text file. It contains instructions for creating user interfaces that are significantly better than Claude's default output. If you open the file, all you see is structured text. But that structured text dramatically changes how Claude approaches UI work.

Installing Skills from the Marketplace

/plugin
Click to copy

This opens the plugin marketplace. You can browse available skills:

• Front-end design tools
• Code review
• GitHub integration
• Context7
• And more

Install what's relevant to your work.

Invoking Skills

Two ways:

Natural language:

Use the front-end design skill to improve our UI
Click to copy

Claude loads the skill and applies its instructions.

Slash command:

/front-end-design
Click to copy

Same result, different invocation method.

Creating Custom Skills

Tell Claude Code in plain language:

I want to create a custom skill that does X, Y, and Z
Click to copy

Claude Code creates the SKILL.md file, gives it a name, and makes it available via natural language or slash command.

For a deep dive on creating skills, see How Agent Skills Work in Claude Code.

Part 12: Agent Teams (10 min)

What Agent Teams Do

Agent teams are multiple instances of Claude Code working underneath your primary session, executing tasks in parallel. Each team member works on a different task, and they communicate with each other. There's even a team leader coordinating their actions.

How It Differs from Normal Subagents

Standard subagents run in isolation. They do their task and return a summary. They don't talk to each other.

Agent teams are collaborative. The team member working on UI knows what the team member working on authentication is doing. They coordinate so everything fits together.

Think of it as the difference between hiring freelancers who work independently vs. assembling an actual dev team that communicates.

Enabling Agent Teams

Agent teams are an experimental feature, disabled by default. To enable them, go to the official Claude Code documentation, search for "agent teams," and follow the setup instructions. Or just paste the setup prompt directly into Claude Code.

Using Agent Teams

You need to call it out explicitly:

Use agent teams to do the following:
1. Improve the UI design
2. Add a blog section
3. Add user authentication
4. Add a newsletter signup
Click to copy

Claude Code breaks down the work:

• Assigns each task to a team member
• Defines what files each member will work on
• Shows the team structure and task assignments
• Each member executes their task in parallel
• The team leader coordinates to ensure everything integrates

When to Use Agent Teams

Agent teams shine when you have multiple independent features that need to work together. If the tasks are truly isolated (no shared files, no integration concerns), regular subagents or work trees may be simpler.

Part 13: MCP Servers (10 min)

What MCPs Do

MCP (Model Context Protocol) servers let Claude Code interact with external programs and services. Notion, Figma, Slack, Canva, GitHub, Supabase, Vercel, and hundreds more.

Setting Them Up

Option 1: Official command (for popular services)

Check the Claude Code documentation for pre-built MCP commands. For popular services, there's a single command you paste into Claude Code:

/mcp
Click to copy

This shows available MCP connections and lets you configure them.

Option 2: Plain language (for anything else)

Set up the [service name] MCP server. Use your web search for guidance.
Click to copy

Claude Code will find the documentation online and set it up for you.

The Hidden Token Cost

This is critical and often overlooked. Every MCP server you have enabled consumes tokens from your context window, even when you're not using it. The tool descriptions get loaded into context at session start.

Some MCP servers are lightweight (a few hundred tokens). Others are heavy and can consume 10-20% of your 200K window immediately.

Management Rules

• Configure 20-30 MCPs total
• Keep under 10 enabled per project
• Keep under 80 tools active at once
• Disable MCPs you're not actively using

Use disabledMcpServers in your project config to keep servers configured but not consuming tokens:

{
  "disabledMcpServers": ["figma", "notion", "slack"]
}
Click to copy

Enable them when you need them. Disable them when you don't.

Part 14: Frameworks (5 min)

What Frameworks Are

Frameworks like GSD (Get Shit Done) or BMAD are "mods" for Claude Code. They don't replace Claude Code. They change the logic for how Claude approaches problems.

Think of it as installing a different playbook. Claude Code is still doing the work, but the framework changes its strategy for things like:

• Context window management
• Subagent usage
• Task decomposition
• Error handling
• Planning methodology

Should You Use One?

This is personal preference. Some developers swear by frameworks. Others find them unnecessary overhead.

Consider a framework if:

• You're building complex, multi-component projects
• You want more structured approaches to context and subagent management
• You've hit quality walls with vanilla Claude Code on larger projects

Skip frameworks if:

• Your projects are straightforward
• You're still learning Claude Code basics
• You prefer to build your own patterns (skills, commands, rules)

Where to Find Them

Search for Claude Code frameworks on GitHub. GSD, BMAD, and others are open source. Read the documentation before installing. Understand what the framework changes before committing to it.

Part 15: Work Trees (10 min)

What Work Trees Do

Work trees let you run multiple Claude Code sessions simultaneously, each working on a different feature in a separate Git branch. When both features are done, you merge them together.

How It Differs from Agent Teams

How to Use Them

Open separate terminal windows. In each one, start Claude Code with the --work-tree flag and a feature name:

Terminal 1:

claude --work-tree feature-dark-mode
Click to copy

Terminal 2:

claude --work-tree feature-exports
Click to copy

Each terminal runs its own Claude Code session with its own context window, working on its own Git branch.

The Workflow

1. Open separate terminals for each feature
2. Start Claude Code with --work-tree feature-name in each
3. Give each session its task
4. Let them run simultaneously
5. When both are done, merge the branches

When to Use Work Trees vs. Agent Teams

Work trees when features are independent and you want clean branch separation. Good for features that don't share files or have integration concerns.

Agent teams when features need to coordinate during development. Good for features that touch shared files or need to be aware of each other's changes.

Quick Reference

Permission Levels

Essential Slash Commands

Context Window Rules

• Total budget: 200K tokens
• Danger zone: 100K+ tokens (context rot begins)
• Action zone: 50-60% usage (time to think about resetting)
• Best practice: monitor constantly with a status line

Debugging Checklist

1. Screenshot the visual issue and drop it in the prompt
2. Copy-paste error logs from external services
3. Use test-driven development to prevent bugs in the first place

Resources

• Claude Code Docs: https://docs.anthropic.com/en/docs/claude-code
• Visual Studio Code: https://code.visualstudio.com
• GitHub (free account): https://github.com
• Slash Commands Tutorial: /tutorials/claude-code-slash-commands
• Agent Skills Tutorial: /tutorials/claude-code-agent-skills
• Hackathon Winner Setup: /tutorials/claude-code-hackathon-winner-setup