The Complete Claude
Mastery Guide

Go to claude.ai and click "Sign Up" in the top right corner. You can sign up with your email address, Google account, or Apple ID. The free tier gives you access to Claude Sonnet with limited daily messages. No credit card is required.

Once logged in, you will see the main chat interface. Here is what each part does:

→Sidebar: History

↑Type your message here

←Model selector

• Left sidebar — Your conversation history. Click any past chat to continue it.
• Center area — The main conversation. Messages appear here as you chat.
• Message box (bottom) — Where you type your prompts. Press Enter or click the arrow to send.
• Model selector (top right) — Choose which Claude model to use (Haiku, Sonnet, or Opus).
• Attachment button (paperclip) — Upload files, images, or documents for Claude to analyze.

Claude comes in three model sizes. Each is optimized for different tasks. Choosing the right model saves you time and money.

Type a message in the text box and press Enter. Here are some great first prompts to try:

"Explain what an API is as if I'm 10 years old"

"Summarize the pros and cons of remote work in a table"

"Write a professional email declining a meeting invitation"

"I uploaded a screenshot of an error message — what does it mean?"

Key tip: The more specific your prompt, the better Claude's response. Instead of "write an email," try "write a professional email to my manager requesting Friday off, keeping it brief and polite."

Click the paperclip icon next to the message box, or simply drag and drop files into the chat. Claude can analyze:

• Documents — PDF, Word, text files (up to 30MB per file)
• Images — Screenshots, photos, diagrams (PNG, JPG, WebP)
• Spreadsheets — CSV, Excel files for data analysis
• Code files — Any programming language for review or debugging

Example: Upload a PDF contract and ask "Summarize the key terms and highlight anything unusual."

Artifacts are standalone pieces of content that Claude creates in a separate panel to the right of the chat. They are interactive and downloadable. Artifacts are automatically created when you ask Claude to produce:

• Code — Full programs with syntax highlighting and a "Copy" button
• Documents — Formatted reports, essays, or guides
• Diagrams — Flowcharts, architecture diagrams (using Mermaid or SVG)
• Web pages — Live-preview HTML/CSS/JS that renders in the panel
• Spreadsheets — Data tables you can download as CSV

←Artifact panel

←Download / Copy

Extended thinking (Pro and Max plans) lets Claude "think out loud" before answering. This produces significantly better results for complex problems like math, logic, coding architecture, and multi-step analysis.

How to enable it: Look for the lightbulb or brain icon near the model selector. Click it to toggle extended thinking on. When enabled, Claude will show a "Thinking..." section before its response, revealing its reasoning process.

As you accumulate conversations, use the search bar at the top of the left sidebar to find past chats. Type keywords from any conversation and Claude will surface matching results. You can also star important conversations by clicking the star icon to pin them for quick access.

Projects (Pro and Max plans) are workspaces where you can group related conversations and provide persistent context. Think of a Project as a "briefing folder" that Claude reads before every conversation within it.

How to create a Project:

1. Click "Projects" in the left sidebar
2. Click "New Project"
3. Give it a name (e.g., "Marketing Campaign Q2")
4. Add custom instructions — these are read by Claude at the start of every conversation in this Project
5. Upload context files — documents, style guides, data files that Claude should reference

"You are helping me write blog posts for my tech startup. 
Our brand voice is casual but authoritative. 
We target software developers aged 25-40. 
Always include code examples when relevant.
Our company name is 'DevFlow' — never abbreviate it."

Memory allows Claude to remember facts about you across conversations. When enabled, Claude automatically saves relevant details (your name, preferences, work context) and uses them in future chats.

How to enable Memory:

1. Click your profile icon (bottom-left)
2. Go to Settings → Memory
3. Toggle Memory on
4. You can view, edit, and delete individual memories at any time

Example: Tell Claude "I'm a Python developer who prefers type hints and pytest for testing." In future conversations, Claude will automatically use type hints and pytest without you asking.

Connectors (Max plans) let Claude pull live data from your existing tools. Instead of manually uploading files, Claude can directly search and read from:

• Google Drive — Access your Docs, Sheets, and Slides
• Notion — Search your workspace pages and databases
• Confluence — Read your team's documentation
• Intercom — Access customer support data

How to connect: Go to Settings → Connectors → Click the service you want → Authorize access. Once connected, Claude can reference your data in any conversation.

Styles let you control how Claude writes. Instead of repeating "be concise" or "use formal language" in every conversation, you create a Style preset that applies automatically.

Built-in Styles:

• Normal — Claude's default balanced tone
• Concise — Short, direct answers with minimal explanation
• Explanatory — Detailed answers with context and examples
• Formal — Professional, polished language

Create your own: Go to Settings → Styles → Create Style. Describe how you want Claude to communicate. For example: "Write like a senior software engineer reviewing code — be direct, point out issues clearly, suggest specific fixes."

Claude can process up to 200,000 tokens (roughly 150,000 words or 500 pages) in a single conversation. This means you can upload entire books, codebases, or research papers and ask questions about them.

Go to claude.com/download and download the app for your operating system. Install it like any other application. Sign in with your Claude account.

CoWork tasks are folder-based. You create a folder on your desktop, put relevant files in it, and tell Claude what to do.

1. Open Claude Desktop
2. Click the "CoWork" tab (or look for the task icon)
3. Click "New Task"
4. Select a folder on your computer that contains the files Claude should work with
5. Type your task description — be specific about what you want Claude to produce
6. Click "Start" — Claude begins working independently

→Task description

←Claude's progress

When Claude finishes, it presents its output for your review. You can:

• Accept — Save the output to your folder
• Request changes — Tell Claude what to modify
• Reject — Discard and start over

Example task: "I have 5 meeting transcripts in this folder. Create a summary document highlighting all action items, organized by team member, with due dates."

1. Open Claude Desktop on your computer
2. Go to Settings → Dispatch
3. Click "Enable Dispatch"
4. A QR code appears on screen
5. Open the Claude mobile app on your phone and scan the QR code
6. Your phone is now paired to your desktop

↑Scan with phone

Once paired, you can send tasks from the Claude mobile app. Claude executes them on your desktop computer.

1. Open Claude Desktop → Settings
2. Navigate to CoWork → Computer Use
3. Toggle "Allow Computer Use" on
4. Grant the required screen recording and accessibility permissions
5. Choose your permission level: Ask every time (safest) or Allow automatically

• Web research — "Open Chrome, search for competitor pricing, and compile a comparison spreadsheet"
• Data entry — "Open this Excel file and enter the data from these invoices"
• App navigation — "Open Photoshop and resize all images in this folder to 800x600"
• Email triage — "Open Gmail, read my unread emails, and draft replies for the urgent ones"

Plugins extend CoWork's capabilities by connecting to external services. They let Claude interact with tools like Zapier, Slack, GitHub, and more without needing Computer Use.

How to install: Go to Settings → Plugins → Browse available plugins → Click "Install" → Authorize access.

Skills are reusable task templates. Instead of writing the same detailed prompt every time, you save it as a Skill and invoke it with a single command.

Skill Name: Daily Email Triage
Description: Check inbox, categorize emails, draft responses

Instructions:
1. Open my email inbox
2. Read all unread emails from the last 24 hours
3. Categorize each as: Urgent, Follow-up, FYI, or Spam
4. Draft replies for all "Urgent" emails
5. Create a summary document with all categories
6. Save to my Desktop/Daily-Reports folder

Set tasks to run automatically on a schedule. This turns Claude into a background assistant that handles routine work without you initiating it.

• Daily — "Every morning at 8am, check my email and create a priority list"
• Weekly — "Every Friday at 5pm, compile a weekly status report from my project files"
• On trigger — "Whenever a new file appears in my Downloads folder, organize it"

Open your terminal and run:

npm install -g @anthropic-ai/claude-code

Then navigate to any project folder and launch it:

cd ~/my-project
claude

Claude Code will ask you to authenticate. Follow the prompts to log in with your Anthropic account. Once authenticated, you will see a prompt where you can start typing commands.

These are the commands you will use every session:

CLAUDE.md is the most important file in your project. It tells Claude about your project's architecture, coding standards, and how to work with your codebase. Run /init to generate one automatically, then customize it.

# Project: My Web App

## Architecture
- React 19 frontend with TypeScript
- Express.js backend with PostgreSQL
- Tailwind CSS for styling

## Build & Test Commands
- `npm run dev` — Start development server
- `npm test` — Run test suite
- `npm run lint` — Check code quality

## Coding Standards
- Use functional components with hooks (no class components)
- All functions must have TypeScript types
- Use async/await (never raw Promises)
- Tests go in __tests__/ directories next to source files

The .claude/ directory is the brain of your Claude Code setup. Here is the complete structure:

.claude/
├── settings.json    # Permissions: allow/deny tool patterns
├── rules/           # Path-scoped rules (e.g., "*.test.ts" rules)
├── commands/        # Custom slash commands (Markdown + frontmatter)
├── skills/          # Reusable workflow templates
├── agents/          # Custom subagent definitions
└── mcp.json         # MCP server configurations

MCP (Model Context Protocol) lets Claude connect to external tools and services. Think of MCP servers as plugins that give Claude new abilities — reading Notion pages, posting to Slack, querying databases.

# Add an MCP server (example: filesystem access)
claude mcp add filesystem -s user -- npx -y @anthropic-ai/mcp-filesystem ~/Documents

# List all connected servers
claude mcp list

# Remove a server
claude mcp remove filesystem

Skills are Markdown files with YAML frontmatter that define reusable workflows. They live in .claude/skills/.

---
name: component
description: Create a new React component with tests
arguments:
  - name: ComponentName
    description: Name of the component (PascalCase)
---

# Create React Component: $ComponentName

1. Create `src/components/$ComponentName/$ComponentName.tsx`
2. Create `src/components/$ComponentName/$ComponentName.test.tsx`
3. Export from `src/components/index.ts`
4. Follow project coding standards from CLAUDE.md

Invoke it: Type /component UserProfile and Claude creates the full component with tests.

Context engineering is the practice of deliberately shaping what information Claude sees. It is the single most impactful skill for getting better results from any AI tool.

# .claude/rules/tests.md
---
globs: ["**/*.test.ts", "**/*.spec.ts"]
---

When writing tests:
- Use describe/it blocks (not test())
- Mock external dependencies with vi.mock()
- Test edge cases: empty input, null, undefined
- Aim for >80% coverage on new code

Subagents are specialized AI assistants that Claude can delegate tasks to. They run in isolated contexts with their own instructions and tool permissions.

# .claude/agents/security-reviewer.md
---
name: security-reviewer
description: Reviews code for security vulnerabilities
tools:
  - Read
  - Grep
  - Glob
---

You are a security-focused code reviewer.
Analyze code for: SQL injection, XSS, CSRF, 
auth bypasses, secrets in code, and insecure defaults.
Output a structured report with severity levels.

Use it: Ask Claude "Run the security-reviewer agent on the auth module" and it delegates the task to the subagent.

Headless mode lets you call Claude Code from scripts, CI/CD pipelines, and other programs. No interactive terminal needed.

# Basic headless usage — send a prompt, get text output
claude -p "Explain the main function in src/index.ts"

# Get structured JSON output
claude -p "List all TODO comments" --output-format json

# Use a JSON schema for typed extraction
claude -p "Extract all API endpoints" \
  --output-format json \
  --json-schema '{"type":"array","items":{"type":"object","properties":{"method":{"type":"string"},"path":{"type":"string"}}}}'

# Pipe output into another command
claude -p "Generate a test for utils.ts" | tee new-test.ts

# Restrict tools for safety in CI/CD
claude -p "Run linting and fix issues" \
  --allowedTools "Read,Write,Bash(npm run lint)"

Install the Playwright MCP server to give Claude full browser control:

claude mcp add playwright -s user -- npx -y @anthropic-ai/mcp-playwright

Now you can ask Claude to:

• "Navigate to our staging site and take a screenshot of the homepage"
• "Scrape all product prices from competitor.com and save to a CSV"
• "Fill out the registration form on our test site and verify it works"
• "Generate a PDF of our documentation site"

Agent Teams (experimental) let you run multiple Claude instances in parallel, each working on a different part of a task.

# Enable the feature
export CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1

# Start Claude and ask it to use teammates
claude

> "Refactor the auth module. Use 3 teammates:
  - Teammate 1: Rewrite the login flow
  - Teammate 2: Update all tests
  - Teammate 3: Update the API documentation"

Use cron jobs or GitHub Actions to run Claude Code on a schedule:

# Cron job: Run code review every morning at 9am
# Add to crontab with: crontab -e
0 9 * * * cd /path/to/project && claude -p "Review all commits from yesterday and create a summary" --output-format json > /tmp/daily-review.json

# GitHub Actions workflow
name: Daily Code Review
on:
  schedule:
    - cron: '0 9 * * 1-5'  # Weekdays at 9am UTC
jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npx @anthropic-ai/claude-code -p "Review recent changes"

At Level 10, you build systems where Claude Code operates as infrastructure — agents that create other agents, self-improving codebases, and multi-hour autonomous coding sessions.

Open your terminal and run the onboarding wizard:

npx clawdbot-onboard

The wizard will guide you through:

1. Choosing your AI provider (Anthropic, OpenAI, etc.)
2. Entering your API key
3. Selecting which messaging channels to connect
4. Setting your agent's name and personality

After setup, OpenClaw starts a Gateway — a local server that routes messages between your messaging apps and the AI model. Verify it is running:

# Check if the Gateway is running
curl http://localhost:3007/health

# You should see: {"status":"ok"}

Open your browser and go to http://localhost:3007. This is the Control UI — a dashboard where you can monitor conversations, manage skills, and configure settings.

→Conversations

←Settings

OpenClaw supports multiple messaging platforms simultaneously. Each platform requires its own setup:

OpenClaw has three core components:

• Gateway — The central server that routes messages between channels and the AI model
• Channels — Connectors to messaging platforms (WhatsApp, Telegram, etc.)
• Skills — Reusable capabilities that extend what the agent can do (weather, reminders, web search)

ClawHub is the marketplace for OpenClaw skills. Browse and install community-created skills:

# Browse available skills
openclaw skills search weather

# Install a skill
openclaw skills install @clawhub/weather

# List installed skills
openclaw skills list

Create your own skills as YAML files:

name: daily-standup
description: Collect standup updates from team members
triggers:
  - schedule: "0 9 * * 1-5"  # Weekdays at 9am
  - message: "standup"
actions:
  - ask_each:
      channel: team-chat
      members: ["@alice", "@bob", "@carol"]
      question: "What did you work on yesterday? What's planned for today?"
  - compile:
      format: markdown
      send_to: "#standup-log"

Heartbeats are scheduled tasks that run at regular intervals. They let your agent proactively check for things and take action without being asked.

For always-on operation, deploy OpenClaw to a Virtual Private Server:

# On your VPS (e.g., DigitalOcean, Hetzner)
# 1. Install Node.js v22+
curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
sudo apt-get install -y nodejs

# 2. Install OpenClaw
npx clawdbot-onboard

# 3. Run as a background service with PM2
npm install -g pm2
pm2 start openclaw --name "my-agent"
pm2 save
pm2 startup  # Auto-start on server reboot

Configure OpenClaw to use different AI models for different tasks — fast models for simple questions, powerful models for complex reasoning:

{
  "models": {
    "default": "claude-3-5-haiku-latest",
    "complex": "claude-sonnet-4-20250514",
    "creative": "gpt-4o"
  },
  "routing": {
    "code_review": "complex",
    "casual_chat": "default",
    "writing": "creative"
  }
}