ANTHROPIC CLAUDE SERIES

Getting Started with Claude

Accounts · Interfaces · API · First Steps

Presentation 2 of 10 • 2026

Choosing Your Interface

Claude is available through multiple interfaces, each designed for different workflows and skill levels.

Start with Claude.ai if you're new. Move to the API or Claude Code as your needs grow.

Creating an Account

Step-by-Step Signup

Navigate to claude.ai
Click "Sign up"
Choose authentication method:
- Google account (fastest)
- Email + password
- Apple ID
- SSO (Enterprise only)
Verify your email address
Complete phone verification (SMS)
Accept Terms of Service
You're in — start chatting!

Phone Verification

A valid phone number is required for all accounts. Each number can only be linked to one account. This helps prevent abuse.

Requirements

Valid email address
Phone number for SMS verification
Supported country/region
Age 18+ (or 13+ with consent)
Modern web browser

Mobile Access

iOS — App Store
Android — Google Play
Same account works across all devices
Conversations sync automatically

Free vs Pro vs Team vs Enterprise

Feature	Free	Pro ($20/mo)	Max ($100/mo)	Team ($25/user/mo)	Enterprise (Custom)
Models	Sonnet (limited)	Opus, Sonnet, Haiku	Opus, Sonnet, Haiku	Opus, Sonnet, Haiku	All models + fine-tuning
Usage	Limited messages/day	5x more usage	20x more usage	Higher team limits	Custom volume
Projects	Basic	Full access	Full access	Shared projects	Org-wide projects
File Uploads	Limited	Expanded	Expanded	Expanded	Custom limits
Artifacts	Yes	Yes	Yes	Yes	Yes
Priority Access	No	Yes	Yes	Yes	Dedicated capacity
Admin Controls	No	No	No	Basic admin	Full SSO, SCIM, audit
Data Retention	Standard	Standard	Standard	Configurable	Custom policies
Support	Community	Email	Email	Priority email	Dedicated CSM

Tip: Start with Free to explore, upgrade to Pro when you hit limits. Teams of 3+ should consider the Team plan for shared projects and higher collective limits.

Your First Conversation

Anatomy of a Claude Chat

System prompt — hidden instructions that shape behavior (set via Projects or API)
User message — your input: questions, instructions, data
Assistant response — Claude's reply, which may include text, code, or artifacts
Context window — the full conversation history Claude can see (up to 200K–1M tokens depending on model)

What Makes a Good First Prompt

Be specific about what you want
Provide relevant context
Specify the format you prefer
Give examples if helpful

Example first conversation:

You: "Explain how HTTP status codes
work. Group them by category and
give one real-world example for each
common code."

Claude: "HTTP status codes are
three-digit numbers that indicate
the result of an HTTP request...

**1xx — Informational**
- 100 Continue: The server received
  the request headers...

**2xx — Success**
- 200 OK: The standard success
  response...
..."

Key Insight

Claude maintains context throughout the conversation. You can ask follow-up questions, request changes, or build on previous responses without repeating yourself.

Understanding the Chat Interface

Conversation Management

Threads

Each conversation is a separate thread
Auto-titled based on content
Rename by clicking the title
Delete from sidebar menu
Threads persist across sessions
Grouped by Today, Yesterday, Last 7 days, etc.

Projects

Group related conversations into Projects
Add project knowledge (docs, code)
Set custom instructions per project
Share projects with team members
Knowledge persists across all chats in the project

Search & Organization

Search across all conversations
Filter by date range
Star important conversations
Use Projects for topic grouping
Export conversation history
Keyboard shortcut: Ctrl+K

Pro Tip: When to Start a New Thread

Start a new conversation when switching topics. Long conversations consume more tokens and can cause Claude to lose focus on earlier context. Keep threads focused and purposeful.

Uploading Files & Images

Supported Document Formats

PDF — text, scanned (with OCR), multi-page
Text — .txt, .md, .csv, .json, .xml
Code — .py, .js, .ts, .java, .cpp, etc.
Office — .docx, .xlsx, .pptx
Web — .html, .css

Image Formats (Vision)

JPEG, PNG, GIF, WebP
Max size: ~20MB per image
Up to 20 images per message
Claude can analyze charts, screenshots, diagrams, handwriting, photos

Size Limits

Individual file: up to ~30MB
Total per message: ~100MB
PDFs: up to ~100 pages effectively
Very large files may be truncated
Files count toward your context window

Multimodal Capabilities

Describe image contents in detail
Extract text from screenshots/photos
Analyze charts, graphs, and data
Compare multiple images
Code from UI mockups/wireframes
Cannot generate or edit images

Using Projects

Creating a Project

Click "Projects" in the sidebar
Select "New Project"
Name your project descriptively
Add custom instructions (system prompt)
Upload project knowledge files
Start conversations within the project

Custom Instructions

Project instructions act as a system prompt for every conversation in that project. Use them to define:

Role and persona for Claude
Output format preferences
Domain-specific terminology
Coding style guidelines

Project Knowledge

Upload files that Claude references across all conversations in the project:

Documentation & style guides
Codebase files & configs
Research papers & references
Up to ~200K tokens of knowledge (up to ~1M on Opus/Sonnet 4.6)

Use Cases

Software project — upload codebase docs, coding standards
Writing project — upload style guide, character notes
Research — upload papers, data sets
Business — upload brand guidelines, product specs

Artifacts

Artifacts are standalone pieces of content that Claude creates in a dedicated panel, separate from the chat flow.

Code Artifacts

Complete programs & scripts
HTML/CSS/JS applications
React components
Live preview for web content
Copy or download instantly

Document Artifacts

Markdown documents
Reports & analyses
Structured content
Tables & formatted text
Version history tracking

Visual Artifacts

SVG diagrams & illustrations
Mermaid charts
Interactive visualizations
Data charts (via JS)
Real-time rendering

How to Trigger Artifacts

Claude automatically creates artifacts for substantial, self-contained content. You can also explicitly ask: "Create an artifact with..." or "Make a React component that...". Artifacts can be iteratively refined — ask Claude to modify, extend, or fix them in follow-up messages.

Setting Your Preferences

Profile & Preferences

Access via your profile icon in the bottom-left corner of Claude.ai:

Display name — how Claude addresses you
Custom instructions — global preferences that apply to all new conversations
Theme — light, dark, or system
Language — preferred response language

Custom Instructions Examples

I'm a senior Python developer.
- Use type hints always
- Prefer functional style
- Give concise answers
- Use pytest for testing
- Target Python 3.11+

Controlling Claude's Style

Verbosity: "Be concise" vs "Explain in detail"
Tone: "Be professional" vs "Be casual"
Format: "Use bullet points" vs "Write prose"
Audience: "Explain like I'm a beginner"
Expertise: "Assume I know React well"

Preference Hierarchy

1. Per-message instructions (highest)
2. Project custom instructions
3. Global custom instructions
4. Claude's default behavior (lowest)

More specific instructions always override more general ones.

API Key Setup

Step-by-Step

Go to console.anthropic.com
Sign up or log in (separate from claude.ai)
Navigate to API Keys section
Click "Create Key"
Name your key (e.g., "dev-local")
Copy the key — shown only once!
Add billing info (pay-as-you-go)

Security Best Practices

Never commit keys to version control
Use environment variables or secret managers
Rotate keys periodically
Use separate keys per environment
Set spending limits in the console

Environment Variables

# Add to ~/.bashrc or ~/.zshrc
export ANTHROPIC_API_KEY="sk-ant-..."

# Or use a .env file (with dotenv)
ANTHROPIC_API_KEY=sk-ant-...

# Verify it's set
echo $ANTHROPIC_API_KEY

Key Format

Anthropic API keys follow the pattern:

sk-ant-api03-[base64-string]

The sk-ant prefix identifies it as an Anthropic key. Keep the full key confidential.

Installing Claude Code

Installation

# Recommended: native installer (no Node.js required)
curl -fsSL https://claude.ai/install.sh | sh

# Alternative: install via npm
npm install -g @anthropic-ai/claude-code

# Verify installation
claude --version

# First run — authenticates via browser
claude

Requirements: A terminal emulator and an Anthropic account. Node.js 18+ needed only for npm install method.

Authentication

On first run, Claude Code opens a browser window
Log in with your Anthropic account
Approve the authentication request
Token is stored locally and securely
Uses your Claude Pro/Team/Enterprise subscription or API credits

First Commands

# Start interactive session
claude

# Ask a question directly
claude "explain this codebase"

# Start in a specific directory
cd my-project && claude

# Resume last conversation
claude --continue

What Claude Code Can Do

Read and understand your codebase
Edit files with precision
Run terminal commands
Search across files with grep/glob
Git operations (commit, branch, etc.)
Test and debug your code
Refactor across multiple files

IDE Integration

VS Code

Install the Claude Code extension from the VS Code marketplace
Or use Claude Code CLI with the claude command in VS Code's terminal
Inline code suggestions
Chat panel in sidebar
Context-aware completions
Supports @-mentions for files

JetBrains IDEs

IntelliJ, PyCharm, WebStorm, etc.
Install Claude Code plugin from JetBrains Marketplace
Integrates with the built-in terminal
Works alongside existing JetBrains AI
Supports all JetBrains languages

Cursor

Cursor has native Claude support
Select Claude as your AI model in settings
Use Ctrl+K for inline editing
Use Ctrl+L for chat
Supports Claude Sonnet and Opus
Codebase-wide context via indexing

Choosing the Right Integration

VS Code + Claude Code extension for the most integrated experience. Cursor for AI-first editing with built-in Claude support. JetBrains if you're committed to the JetBrains ecosystem. Claude Code CLI works in any terminal, regardless of IDE.

Your First API Call

Python

import anthropic

client = anthropic.Anthropic()
# Uses ANTHROPIC_API_KEY env var

message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": "Hello! What can "
                       "you help me with?"
        }
    ]
)

print(message.content[0].text)

# Install the SDK first
pip install anthropic

TypeScript

import Anthropic from
  "@anthropic-ai/sdk";

const client = new Anthropic();
// Uses ANTHROPIC_API_KEY env var

const message =
  await client.messages.create({
    model: "claude-sonnet-4-20250514",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: "Hello! What can "
          + "you help me with?",
      },
    ],
  });

console.log(message.content[0].text);

# Install the SDK first
npm install @anthropic-ai/sdk

Understanding Tokens & Usage

What Are Tokens?

Tokens are the fundamental units of text that LLMs process. They're sub-word pieces:

"Hello" = 1 token
"artificial intelligence" = 2 tokens
"supercalifragilistic" = 5-6 tokens
Rough rule: 1 token ≈ 4 characters in English
~750 words ≈ 1,000 tokens

Token Counting

API responses include usage field with exact counts
input_tokens — what you sent
output_tokens — Claude's response
Use the tokenizer tool on docs.anthropic.com

Pricing (API)

Model	Input	Output
Opus	$15/MTok	$75/MTok
Sonnet	$3/MTok	$15/MTok
Haiku	$0.25/MTok	$1.25/MTok

MTok = million tokens. Prices as of early 2025; check anthropic.com for current pricing.

Managing Costs

Use Haiku for simple, high-volume tasks
Use Sonnet for balanced quality/cost
Reserve Opus for complex reasoning
Set max_tokens to limit output
Use prompt caching for repeated contexts
Monitor usage in the API console

Rate Limits & Quotas

API Tier System

Tier	Spend Req.
Tier 1	$0 (new)
Tier 2	$40+
Tier 3	$200+
Tier 4	$1,000+
Scale	Custom

Higher tiers unlock higher rate limits. Tiers upgrade automatically based on cumulative spend.

Types of Limits

Requests per minute (RPM) — how many API calls you can make
Tokens per minute (TPM) — total tokens processed per minute
Tokens per day (TPD) — daily token budget
Limits apply per model and per organization

Handling Rate Limits

import anthropic
import time

client = anthropic.Anthropic()

try:
    response = client.messages.create(...)
except anthropic.RateLimitError as e:
    # Implement exponential backoff
    wait_time = e.response.headers.get(
        "retry-after", 30
    )
    time.sleep(int(wait_time))
    # Retry the request

The SDK has built-in retry logic with exponential backoff.

Best Practices for Beginners

Be Clear & Specific

Vague: "Write some code"
Clear: "Write a Python function that takes a list of integers and returns the top 3 most frequent values"
State the goal, not just the task
Specify format, language, constraints

Provide Context

Share relevant background information
Include error messages in full
Mention your tech stack & versions
Explain what you've already tried
Upload relevant files rather than describing them

Iterate & Refine

Start with a rough request, then refine
Ask Claude to explain its reasoning
Request alternatives ("What about using X instead?")
Build on previous responses
Say "That's close, but change X to Y"

Use Structure

Break complex tasks into steps
Use numbered lists for multi-part requests
Provide examples of desired output
Use XML tags to delineate sections:
```
...
...
...
```

Common Pitfalls

What to Avoid

Overly long conversations — context degrades; start fresh for new topics
Trusting without verifying — always review code and check facts
Sharing sensitive data — don't paste passwords, API keys, or PII
Ambiguous prompts — "Make it better" without saying how
Ignoring token limits — massive inputs may get truncated
Not reading error messages — share the full error with Claude

API-Specific Pitfalls

Forgetting to set max_tokens
Not handling rate limits gracefully
Hardcoding API keys in source code
Ignoring the stop_reason field
Not using streaming for long responses

Common Misconceptions

"Claude remembers past chats" — No, each conversation is independent (unless using Projects)
"Claude can browse the web" — Not by default; it uses training data up to its cutoff
"Longer prompts are better" — Concise, structured prompts often work best
"Claude is always right" — It can hallucinate; always verify critical information
"Claude learns from my chats" — Your conversations don't train the model

Recovery Strategies

If Claude goes off track: "Let's start over"
If output is wrong: share the specific error
If too verbose: "Be more concise"
If too vague: "Give me concrete code"

Next Steps

You're ready to start using Claude. Here's where to go next in the series and beyond.

Coming Up in This Series

03 — Claude.ai Deep Dive (web interface mastery)
04 — Claude Code (terminal-based coding)
05 — API & SDK (building applications)
06 — Integrations (third-party tools)
07 — Agents (autonomous workflows)
08 — Productivity (real-world workflows)
09 — The Future of Claude
10 — Reference & Resources

Essential Resources

docs.anthropic.com — official documentation
console.anthropic.com — API dashboard
claude.ai — start chatting now
github.com/anthropics — SDKs & examples
anthropic.com/research — research papers

Recommended First Projects

Have Claude analyze a document you're working on
Create a Project for your current work
Write your first API script using the code from Slide 15
Install Claude Code and explore a codebase
Build a simple chatbot with the API

Presentation 2 of 10 Next: Claude.ai Deep Dive