The Ultimate Claude Code Guide: Models, MCP, Skills, Sub‑Agents & Memory

Claude Code is far more powerful than just “chatting with an AI in your terminal.” With the right setup, you can turn it into a serious development environment that creates repos, manages tools, runs sub-agents, and follows your custom workflows.

This guide walks through the most useful intermediate and advanced features: model selection, key commands, MCP servers, skills, sub-agents, memory, and a visual interface that makes everything easier to manage.

Start With the Right Model and Core Commands

Claude Code supports multiple Claude models, and choosing the right one has a huge impact on cost, speed, and how much you can get done each month.

Picking the Right Claude Model

You can switch models at any time with the /model command inside Claude Code. In practice, a good setup looks like this:

Sonnet: The best default for most coding and general tasks. Good balance of speed, cost, and capability.

Opus: Use for very complex reasoning, large refactors, or deep architectural work. It’s powerful but expensive, so don’t leave it on by default if you’re on a usage-limited plan.

Haiku: Great for simple tasks, bulk generation, or long-running jobs where you don’t need top-tier reasoning but want to save tokens.

Get into the habit of checking which model you’re on before starting a big task. This alone can dramatically stretch your monthly usage.

Essential Utility Commands

Claude Code has a few built-in commands that help you understand what’s happening under the hood.

/insights: Generates a detailed local report of how you use Claude Code. It analyzes your sessions, highlights patterns, and shows where you’re using it well (or inefficiently). The report opens as a local HTML file with charts and breakdowns.

/cost: If you’re using your own API key, this shows how much your current session has cost so far. If you’re on a subscription, it will typically show as free.

/context: Shows how your context window is being used: system prompt, tools, skills, messages, and remaining free space. It also lists all active MCP tools. This is very useful for spotting tools you don’t actually need loaded, which can bloat context and slow things down.

/compact: Summarizes the current conversation and replaces the full history with a shorter summary. This helps when you’re close to the context limit or want to reduce token usage without completely starting over. It’s not always ideal, but it’s good to know it exists.

Supercharge Claude Code With MCP Servers

MCP (Model Context Protocol) servers are how you give Claude Code real capabilities beyond text: GitHub access, documentation search, browser automation, and more. You can add them at three levels:

Project level: Stored in that project’s .claude folder. Only available inside that project.

User (global) level: Available across all your projects on that machine.

Shared project level: For multi-user setups where everyone on the project shares the same MCP config.

By default, when you add an MCP server from inside a project, it’s scoped locally to that project. If you want it globally, you need to specify that when adding it.

Understanding the .claude Folder

In any directory where you run Claude Code, it will create a hidden .claude folder. This is where project-specific settings live, including:

settings.local.json – project configuration

skills/ – project-level skills

agents/ – project-level sub-agents

claude.md – project-level persistent memory (more on this later)

Global configuration lives in ~/.claude (your home directory). When adding MCP servers, be clear whether you’re writing to the project-level .claude or the global one.

Adding the GitHub MCP Server

One of the most useful MCP servers to add is the GitHub integration. It lets Claude Code:

Create new GitHub repositories

Push code and README files

Work with repos without you manually running git and gh commands

To add it, you run a claude mcp add command in your terminal (outside Claude Code), passing a JSON config that includes your GitHub Personal Access Token (PAT). When doing this, you can add --scope user to make it available globally across all projects.

To get your PAT:

Go to GitHub > Settings > Developer settings > Personal access tokens.

Create a new token with at least repo scope.

Copy the token and paste it into the MCP add command before running it.

Once added, restart Claude Code and run /mcp to confirm that the GitHub server is connected. From there, you can ask Claude to do things like:

“Create a new Git repo here, create a remote GitHub repository, and push a README that says this is a demo application.”

If Claude tries to use the gh CLI and fails, you can nudge it by saying “Use the GitHub MCP server instead,” and it will switch to the MCP tools.

Context 7, Superpowers & Playwright

Some MCP servers are easier to install via the Claude desktop app, which syncs with Claude Code.

In the desktop app:

Go to the Code tab > Customize > Personal plugins > Browse plugins.

Useful ones include:

Context 7: Gives Claude access to live, up-to-date documentation. It’s free and very handy for coding against modern frameworks and APIs.

Superpowers: Adds prebuilt agents and skills for brainstorming, app scaffolding, mockups, and reviews. It’s powerful but uses a lot of context, so it’s best if you’re on a high-usage or max plan.

Playwright: Enables browser automation and UI testing. Claude can spin up Playwright, run tests against your app, and validate flows automatically.

Once installed in the desktop app, these MCP servers become available in Claude Code as well.

Turn Repeated Workflows Into Reusable Skills

Skills are one of the most underrated features in Claude Code. They’re not tools or APIs—they’re documented workflows that Claude can reliably follow again and again.

What a Skill Actually Is

A skill is just a markdown file that describes a repeatable behavior in a structured way. For example:

How to review code in your preferred format

How to deploy a project

How to update a specific config file whenever something changes

Instead of rewriting a long prompt every time, you capture the workflow once as a skill and then reuse it.

Skills live under .claude/skills/<skill-name>/skill.md at the project level, or under the global ~/.claude/skills if you make them global.

Example: A Custom Code Review Skill

Imagine you want every code review to follow the same structure: security, error handling, performance, code quality, and testing. You could describe that once as a skill:

Name: code-review

Description: Structured code review following team standards.

Output structure: Sections for Security, Error Handling, Performance, Code Quality, Testing, each with severity, file location, and recommended fix.

You don’t have to write the markdown file by hand. You can simply tell Claude Code something like:

“Create a new code review skill that reviews code using these sections: Security, Error Handling, Performance, Code Quality, Testing. For each finding, include severity, file path, and a suggested fix.”

Claude will:

Look up the skill format documentation.

Create the appropriate folder and skill.md file.

Fill it with the instructions you described.

Using and Improving Skills

Once a skill exists, Claude Code automatically exposes it as a slash command. For example, if the skill is called code-review, you can run:

/skills – to list all available skills.

/code-review – to run the code review skill.

You can also pass extra instructions, like:

/code-review Review the entire codebase with extra focus on security.

Claude will then run the skill and return results in the exact format you defined. If you don’t want to remember the command, you can also just say something like “Review my code in the main files,” and Claude may automatically choose to invoke the code-review skill.

If you decide a skill should be global instead of project-specific, you can ask Claude to move it to the global ~/.claude scope. It will handle the file moves for you.

Over time, a good pattern is:

Notice a workflow you repeat often.

Ask Claude to turn it into a skill.

Run the skill, see how it behaves, and then ask Claude to refine the skill file until it matches exactly what you want.

If you’re just getting started with Claude overall, it can help to pair this guide with a more general walkthrough like the full Claude tutorial for beginners, then come back to skills once you’re comfortable.

Use a Visual Interface: Nimblelist for Claude Code

Working purely in the terminal can make it hard to see what Claude is doing, what files it’s touching, and how multiple sessions relate. Nimblelist is a free, open-source desktop app that gives you a visual layer on top of Claude Code.

What Nimblelist Adds

When you open a project in Nimblelist, you get:

Claude Code panel on the right, with your active session.

File explorer and markdown viewer on the left.

Kanban board that shows all your Claude Code sessions as tasks in different columns (e.g., Inbox, Implementation, Done).

As you send prompts, sessions move through the Kanban automatically. This is especially helpful if you’re a heavy Claude Code user running multiple sessions in parallel.

Nimblelist also shows live diffs as Claude edits your files. When you ask it to “Review my project guide and make small improvements,” you can:

See the rendered markdown with changes highlighted.

View red (removed) and green (added) sections side by side.

Step through each change and decide whether to keep it.

On top of that, Nimblelist supports custom extensions. You can ask Claude (inside Nimblelist) to build a dashboard extension for your project—for example, a documentation browser that lists all docs, tags, and structure in one place. Nimblelist will then generate that extension and wire it into the sidebar.

There’s also a mobile app that lets you monitor and interact with your Claude Code sessions from your phone, which is handy if you kick off long-running tasks.

Sub-Agents: Delegating Work in Parallel

Sub-agents are additional AI agents that Claude Code can spin up to handle parts of a task in parallel, each with its own context and instructions.

How Sub-Agents Work

When you’re in a Claude Code session and ask for something complex, you can explicitly tell Claude to break the work into sub-agents. For example:

“Audit all of the documentation in this project and give me a concise summary of what it covers and where the gaps are. Spin up one sub-agent per documentation file, have each agent summarize its file, then aggregate the results.”

Claude will then:

Create multiple sub-agents (often using a built-in “explorer” agent type).

Assign each one a specific file or task.

Collect their outputs and combine them into a final response.

In tools like Nimblelist, you can see a dedicated “Sub-agents” tab, where each sub-agent appears as its own mini-session. You can click into them to see the prompts they received and what they did.

Custom Sub-Agents vs. On-the-Fly Agents

There are two ways to use sub-agents:

On-the-fly sub-agents: Claude creates them as needed based on your request. This is usually enough for most workflows.

Custom sub-agents: You define reusable agents with their own system prompts, tools, and memory.

Custom agents live under .claude/agents. You can create them via the /agents command in Claude Code:

Run /agents and choose to create a new agent.

Give it an identifier (e.g., test-writer).

Paste a system prompt describing its job (e.g., “You are a test writer that generates high-quality unit tests for this project”).

Choose which tools it can use (all tools, only MCP tools, no execution tools, etc.).

Select a model (e.g., Sonnet) and memory scope (none, user, local, or project).

Claude will then create the agent definition file. To use it, you don’t necessarily need a special command—you can just say something like “Test the test writer agent,” or give Claude a task that obviously belongs to that agent. Claude will then invoke the agent as needed.

In practice, you often don’t need many custom agents. It’s usually more effective to:

Give Claude clear instructions to parallelize work (“spin up N sub-agents”).

Let it create temporary agents on the fly.

Reserve custom agents for very specific roles (e.g., a locked-down deployment agent with limited tools).

Anthropic’s documentation goes deep into sub-agent configuration, including tool scoping, MCP per-agent, conditional rules, and hooks. If you want to push this to the limit, it’s worth having Claude ingest that doc and summarize the patterns that fit your workflow.

Memory and Project Knowledge in Claude Code

Unlike chat-style Claude, Claude Code doesn’t have automatic cross-session memory. If you tell it “My name is Alex” in one session, it won’t remember that in a new session—unless you explicitly write it down.

claude.md: Simple Persistent Memory

The simplest way to give Claude persistent memory is to use a claude.md file. You can ask:

“Create a claude.md file and save that my name is Alex.”

Claude will create an all-caps CLAUDE.MD (or claude.md depending on environment) file in the project’s .claude folder with content like:

Project owner: Alex

Every time you start a new Claude Code session in that project, it will automatically read claude.md and load that context. You can have:

A project-level claude.md in .claude/.

A global claude.md in ~/.claude/ for things you want Claude to know across all projects.

Beyond One File: Building a Memory Folder Structure

As your projects grow, a single claude.md file isn’t enough. A better pattern is to create a structured workspace of markdown files that Claude can read as needed.

A good example of this approach is how some AI orchestration frameworks (like Open Claude) organize their workspaces:

workspace/

docs/ – project documentation

memory/ – long-term notes, decisions, user preferences

contracts/ – agreements, specs, and constraints

skills/ – reusable workflows

state/ – current status, checkpoints, and run history

You can replicate a similar structure for Claude Code. For example:

Create a docs/ folder with key project docs.

Create a memory/ folder with markdown files for user preferences, architecture decisions, and recurring patterns.

Reference these files from claude.md (e.g., “See docs/architecture.md and memory/preferences.md for more context”).

Claude will often automatically read relevant markdown files when they’re clearly named and referenced. If it doesn’t, you can explicitly tell it which files to consult.

This is how you simulate “long-term memory” in Claude Code: by writing down what matters in markdown and giving Claude a clear, organized file tree to work with.

Putting It All Together

Claude Code becomes dramatically more powerful once you move beyond simple chat and start treating it as a programmable environment:

Pick the right model for each task with /model, and keep an eye on usage with /context, /cost, and /insights.

Add MCP servers like GitHub, Context 7, and Playwright so Claude can take real actions, not just suggest them.

Wrap your repeatable workflows into skills so you get consistent, high-quality outputs every time.

Use sub-agents to parallelize work and, when needed, define custom agents for specialized roles.

Build a simple memory architecture with claude.md and a well-structured docs/memory folder so Claude always has the context it needs.

If you’re still on the fence about adopting Claude Code as your main AI dev tool, it can help to compare it with other options—our in-depth benchmark of Claude Code vs Google Antigravity is a good place to start.

Once you’ve wired in MCP, skills, sub-agents, and memory, Claude Code stops feeling like a chat window and starts feeling like a real AI teammate embedded in your development workflow.