Claude 101 - Certification Study Guide
Claude 101 - Certification Study Guide
Course: Claude 101 (claude.ai) Modules: 5 sections, 15 lessons Target: New Claude users — business professionals, knowledge workers, teams
MODULE 1: Meet Claude
Key Notes
What is Claude?
Claude is Anthropic’s AI assistant — a large language model (LLM) trained to be helpful, harmless, and honest. Available via:
- claude.ai — web interface (free and Pro tiers)
- Mobile apps — iOS and Android
- API — for developers building Claude-powered applications
- Claude Code — CLI tool for software engineers
- Claude for Teams / Enterprise — organizational deployments
Claude is designed around three core values:
- Helpful — genuinely useful, not just technically correct
- Harmless — avoids causing harm to individuals or society
- Honest — acknowledges uncertainty, doesn’t fabricate facts
The Claude Model Family
Speed / Cost Capability / Cost
| |
v v
+----------+ +-------------+ +----------+
| Haiku | | Sonnet | | Opus |
| | | | | |
| Fastest | | Balanced | | Most |
| Cheapest | | Speed/Power | | Capable |
| Simple | | Most tasks | | Complex |
| tasks | | | | tasks |
+----------+ +-------------+ +----------+
| Model | Best For | Trade-off |
|---|---|---|
| Haiku | Quick Q&A, summaries, classification | Less nuanced on complex reasoning |
| Sonnet | Writing, coding, analysis, most work | Middle ground |
| Opus | Complex research, deep reasoning, hard problems | Slower, higher cost |
The model you use determines the quality and speed of responses. For most claude.ai users, Sonnet is the default and handles most tasks well.
Your First Conversation with Claude
Claude understands natural language — you do not need to use special syntax. However, quality of input directly determines quality of output:
Poor prompt:
“Help me with my email”
Better prompt:
“I need to write a professional follow-up email to a client who hasn’t responded in two weeks about a contract renewal. Keep it warm but direct. The client is Sarah from Acme Corp.”
The better prompt gives Claude: task type, tone, context, specific details, and the recipient. This eliminates guesswork.
Conversation structure tips:
- Start with the goal, not just the topic
- Include relevant background context
- Specify format when you have a preference (bullet points, table, prose, etc.)
- Indicate audience when relevant (beginner, executive, technical team)
- Specify length constraints if important (brief, one page, under 100 words)
Getting Better Results
Technique 1 — Role assignment: Ask Claude to take on a specific perspective or expertise.
“Act as a senior UX designer and critique this landing page copy…”
Technique 2 — Step-by-step thinking: Ask Claude to reason through a problem before answering.
“Think step by step: what are the tax implications of converting my LLC to an S-Corp?”
Technique 3 — Provide examples: Show Claude the style or format you expect.
“Rewrite this in the style of the example below: [example]”
Technique 4 — XML tags for structure: Wrap different parts of your prompt in XML tags to separate context from instructions.
<context>
[background info here]
</context>
<task>
Summarize the key risks from the context above.
</task>
Technique 5 — Iterate and refine: Claude conversations are stateful. You can follow up:
- “Make it shorter”
- “Now make it more formal”
- “Add a section on risks”
- “This paragraph isn’t right — the budget is $50k, not $500k”
Technique 6 — Ask for alternatives:
“Give me three different approaches to this email subject line.”
Claude Desktop App: Three Modes
Claude’s desktop application provides three distinct working modes:
+------------------+ +------------------+ +------------------+
| CHAT MODE | | COWORK MODE | | CODE MODE |
| | | | | |
| Conversations, | | Works with your | | Developer tool: |
| Q&A, | | local files and | | code generation, |
| brainstorming, | | documents | | debugging, CLI |
| exploration | | directly | | integration |
+------------------+ +------------------+ +------------------+
General Files Engineering
- Chat mode — standard conversational interface; ideal for Q&A, brainstorming, drafting text, getting advice
- Cowork mode — Claude can access and work with files on your computer directly; drag in documents, spreadsheets, PDFs; great for document-heavy workflows
- Code mode — for software development; integrates with terminal and development environments; Claude Code functionality in desktop form
Best Practices
- Choose the right model for the task — Haiku for speed, Opus for depth
- Give Claude the “why” behind a request, not just the “what”
- Iterate within the same conversation rather than starting over
- Use role assignment for domain-specific advice
- Structure complex prompts with XML tags or numbered sections
- Be explicit about the output format (table, email, list, JSON, etc.)
- Ask Claude to show its reasoning when dealing with analysis or decisions
Example
Scenario: A marketing manager needs a competitor analysis.
Weak approach:
“Analyze our competitors.”
Strong approach:
“You are a marketing strategist. We sell project management software targeting SMBs (10-50 employees). Our competitors are Asana, Monday.com, and ClickUp. Based on common knowledge of these tools, create a comparison table covering: pricing model, key differentiators, target customer, and main weaknesses. Then write a brief (2 paragraph) positioning statement for our product that highlights gaps we could exploit.”
Result: Specific, actionable, formatted output that requires minimal editing.
MODULE 2: Organizing Your Work and Knowledge
Key Notes
Introduction to Projects
Projects are Claude’s organizational layer — grouping related conversations, files, and instructions into a persistent workspace.
Without projects:
- Every conversation starts fresh
- Claude has no memory of previous sessions
- You repeat context in every chat
With projects:
- Conversations are grouped by topic, team, or client
- Custom instructions persist across all conversations in the project
- Uploaded documents are available throughout the project
- Team members (on Teams/Enterprise plans) can share project contexts
Project use cases:
| Type | Example |
|---|---|
| Client-based | “Acme Corp Project” — all work for one client |
| Role-based | “Marketing Team” — shared prompts, brand guidelines uploaded |
| Topic-based | “Q3 Planning” — budget docs, strategy notes |
| Recurring | “Weekly Reports” — template and examples pre-loaded |
Project Knowledge
Each project has a knowledge base — documents and instructions that Claude references automatically in every conversation within that project.
What you can add:
- Company style guides
- Internal policies and procedures
- Product documentation
- Frequently referenced data (pricing, org charts, processes)
- Example outputs (to establish tone/format expectations)
System instructions — persistent custom instructions Claude follows for the project:
“You are an assistant for the Acme Corp sales team. Always respond in a concise, professional tone. Our products are [X, Y, Z]. We never offer discounts greater than 20%. Reference our pricing guide when quoting numbers.”
This eliminates the need to re-explain context in every conversation.
Creating with Artifacts
Artifacts are Claude-generated outputs displayed in a dedicated side panel — separate from the conversation text. They are designed to be used, copied, and iterated on directly.
Artifact types:
+------------------+------------------------------------------+
| Type | Examples |
+------------------+------------------------------------------+
| Code | Python scripts, SQL queries, functions |
| Markdown Doc | Reports, meeting notes, documentation |
| HTML Page | Simple web pages, email templates |
| SVG Image | Icons, diagrams, charts |
| Mermaid Diagram | Flowcharts, sequence diagrams, ER models |
| React Component | Interactive UI elements |
+------------------+------------------------------------------+
Artifact workflow:
- Ask Claude to create something (report, script, diagram)
- Claude generates it as an artifact in the side panel
- You can preview, copy, or download it
- Ask Claude to modify the artifact: “Make the chart horizontal” / “Add error handling”
- Claude updates the artifact in place — version history preserved
Artifacts are ideal for:
- Code you’ll run or deploy
- Documents you’ll share or publish
- Diagrams you’ll present
- HTML emails or landing pages
Working with Skills
Skills are reusable prompt templates that surface in the Projects panel for quick access — think of them as saved shortcuts for actions you perform repeatedly.
Community skills — pre-built by Anthropic or the community:
- Summarize meeting notes
- Generate social media posts
- Draft job descriptions
- Translate text
- Format data as a table
Custom skills — create your own:
- Write a prompt that works well for your repeated task
- Save it as a skill with a name and description
- Access it from the skill library in your project
- Share it with team members (Teams/Enterprise)
Prompt Library (Community) ──→ Browse → Install → Use in Project
|
Custom Prompts (Your Own) ──→ Create → Name → Save ──→ Use in Project
Skills increase consistency — the same prompt runs the same way every time, preventing drift in quality.
Best Practices
- Create a project for any recurring work (not one-off tasks)
- Write system instructions that cover: tone, audience, terminology, constraints, and what Claude should never do
- Upload reference docs to project knowledge — don’t paste them into every chat
- Use artifacts for all outputs you’ll reuse or share
- Iterate on artifacts in the side panel rather than asking Claude to regenerate from scratch
- Build custom skills for prompts you run more than once a week
- Name skills clearly so team members understand them without reading the prompt
Example
Scenario: A content team running a blog.
Project setup:
- Name: Content Marketing
- Knowledge: Brand voice guide, content calendar, audience personas, SEO guidelines
- System instructions: “You write content for TechStartup.io targeting B2B SaaS buyers. Tone: conversational but expert. Always optimize for SEO. Never make product claims without citing our docs.”
Skill created: “Draft Blog Post” — prompt template that asks for topic, keyword, and length, then generates a full draft following the voice guide.
Artifact workflow: Claude writes a 1,200-word blog post as a Markdown artifact. Editor refines it in conversation, Claude updates the artifact. Final version copied to CMS.
Result: Consistent quality, faster production, no repeated context-setting.
MODULE 3: Expanding Claude’s Reach
Key Notes
Connecting Your Tools
Claude can connect to external applications and data sources via integrations, allowing it to access real-time and organization-specific information rather than relying solely on its training data.
Built-in integrations (claude.ai):
- Google Drive — access Docs, Sheets, Slides, PDFs
- Google Docs — read/write directly
- Slack — search messages, channels, threads
- GitHub — access repositories, files, issues
- Notion — read pages and databases
- Confluence — access wiki pages and documentation
- Jira — view issues and project data
Connection flow:
Claude.ai → OAuth Authentication → Third-party Service → Data Access → Claude Response
With integrations enabled, you can ask:
“Summarize the Q3 results from the spreadsheet in my Google Drive” “What did the #engineering Slack channel say about the deployment last Friday?” “Show me the open issues in the backend-api GitHub repo”
Claude accesses live data rather than requiring you to copy-paste it.
Model Context Protocol (MCP)
MCP (Model Context Protocol) is Anthropic’s open standard for connecting AI models to external data sources and tools. Think of it as a universal adapter.
+-------------+
| Claude |
+------+------+
|
MCP Protocol
|
+----------------+----------------+
| | |
+-----+----+ +------+-----+ +-----+----+
| Database | | File System| | API/Tool |
| (SQL) | | (local) | | (Slack, |
+----------+ +------------+ | GitHub) |
+----------+
MCP matters because:
- Standardized: one protocol for all connections (vs. custom integrations per tool)
- Open source: developers can build their own MCP connectors
- Secure: data stays in your infrastructure; Claude receives only what it needs
- Extensible: connect internal databases, proprietary systems, custom APIs
Enterprise teams use MCP to give Claude access to internal data that wouldn’t be in any public integration (internal knowledge bases, CRM data, proprietary databases).
Enterprise Search
Enterprise search allows Claude to search across all connected organizational data simultaneously — acting as an intelligent search layer across your company’s knowledge.
Without enterprise search:
- You search Google Drive → then Slack → then Confluence → then email separately
- Results are siloed, hard to synthesize
With enterprise search:
- Claude queries all connected sources in one request
- Synthesizes results into a coherent answer with citations
- Understands context (not just keyword matching)
Example query:
“What is our current policy on parental leave, and has this come up in any recent Slack discussions or HR documents?”
Claude searches HR Confluence pages, recent Slack channels, and any uploaded policy docs, then synthesizes a complete answer.
Key difference from regular search: Claude understands what you’re asking, not just the keywords. It can infer intent, disambiguate terms, and summarize multiple sources.
Research Mode for Deep Dives
Research mode is Claude’s autonomous, multi-step research capability. Instead of a single response, Claude performs a research process:
User Query
|
v
+---+----------------------------------+
| RESEARCH MODE PROCESS |
| |
| 1. Query decomposition |
| (breaks question into subtopics)|
| |
| 2. Multi-source search |
| (web, connected tools, uploads) |
| |
| 3. Source evaluation |
| (relevance, credibility) |
| |
| 4. Synthesis |
| (combine findings) |
| |
| 5. Report generation |
| (comprehensive output with |
| citations) |
+-------------------------------------+
|
v
Comprehensive Research Report
When to use research mode:
- Competitive analysis
- Market research
- Technical deep dives
- Due diligence
- Policy or regulatory research
- Literature reviews
Research mode vs. standard chat:
| Feature | Standard Chat | Research Mode |
|---|---|---|
| Sources | Training data | Live web + connected tools |
| Depth | Single response | Multi-step investigation |
| Citations | Limited | Full sourcing |
| Time | Seconds | Minutes |
| Output | Conversational | Structured report |
Research mode produces artifacts — structured reports you can download, share, and build on.
Best Practices
- Connect the tools you use daily first (Google Drive, Slack are highest ROI for most teams)
- When using integrations, specify which tool to search: “In Google Drive, find…” reduces ambiguity
- Use enterprise search for cross-silo questions where the answer spans multiple systems
- Reserve research mode for questions that genuinely need depth — it takes time
- Always review citations from research mode — Claude surfaces sources so you can verify
- For MCP in enterprise: work with IT to determine which internal systems to connect; start with knowledge bases before databases
Example
Scenario: A sales rep preparing for a major account renewal meeting.
Without integrations:
- Manually searches CRM for account history
- Looks through email for previous discussions
- Checks Slack for any mentions of the client
- Reviews Confluence for relevant product docs
With integrations + research:
“Research Acme Corp’s renewal. Check our CRM for deal history, search Slack for any mentions of their issues, and look up our latest product roadmap on Confluence. Summarize the account status and give me three talking points for the renewal call.”
Claude searches all connected systems simultaneously, synthesizes the findings, and produces a ready-to-use briefing document as an artifact.
Time saved: 45 minutes → 2 minutes.
MODULE 4: Putting It All Together
Key Notes
Claude in Action: Use Cases by Role
Claude’s utility is broad. Understanding role-specific applications helps teams adopt it effectively.
Marketing:
- Campaign copy: ads, emails, landing pages, social posts
- Brand voice consistency across all written content
- Content calendars and editorial planning
- A/B test copy generation (multiple variants at once)
- SEO content optimization suggestions
- Competitor messaging analysis
Engineering:
- Code review: find bugs, suggest improvements, check for security issues
- Debugging: analyze error logs, trace root causes
- Documentation generation: README files, API docs, inline comments
- Test case generation: unit tests, edge cases, integration tests
- Code translation: port Python to TypeScript, migrate frameworks
- Architecture planning: review system designs, spot tradeoffs
Sales:
- Personalized outreach emails at scale
- Proposal and RFP drafting
- Objection handling scripts
- Account research and briefings
- CRM note summarization
- Deal stage coaching
HR / People Ops:
- Job description writing (inclusive, compelling)
- Interview question generation by role
- Onboarding documentation
- Policy drafting and review
- Performance review template creation
- Employee survey analysis
Legal:
- Contract review: flag unusual clauses, summarize terms
- Policy drafting: employee handbooks, privacy policies, NDAs
- Regulatory research: understand compliance requirements
- Red-line comparison: compare two contract versions
- Plain-language translation of legal documents
Finance:
- Financial report analysis and summarization
- Model explanation and documentation
- Variance analysis narrative writing
- Presentation of numbers for non-finance audiences
- Budget commentary drafting
- Due diligence document review
+----------+ +-------------+ +----------+ +----------+
|Marketing | | Engineering | | Sales | | HR |
| Copy | | Code Review | | Outreach | | JDs |
| Campaigns| | Debugging | | Proposals| | Policies |
+----------+ +-------------+ +----------+ +----------+
\ | / /
\ | / /
+--------- CLAUDE --------+-------------+
/ | \ \
/ | \ \
+----------+ +-------------+ +----------+ +----------+
| Legal | | Finance | | IT/Ops | | Research |
| Contracts| | Analysis | | Runbooks | | Synthesis|
| Policies | | Reports | | Support | | Reports |
+----------+ +-------------+ +----------+ +----------+
Other Ways to Work with Claude
1. API (Application Programming Interface) For developers building Claude into their own products and workflows:
- Direct HTTP requests or SDK (Python, TypeScript)
- Choose model, set system prompt, control parameters
- Build custom tools, chatbots, automations
- Batch processing of large document sets
- Fine-tune behavior through prompt engineering
2. Claude Code (CLI) For software engineers:
- Command-line interface that runs in the terminal
- Full codebase access: reads, writes, executes code
- Integrates with git, build systems, test runners
- Autonomous coding agent capabilities
- Best for: complex refactors, codebase exploration, multi-file changes
3. Mobile App (iOS / Android) For on-the-go use:
- Same models as web
- Voice input support
- Camera/image input (describe or analyze photos)
- Syncs with web conversation history (on Pro+)
- Good for quick questions, brainstorming, travel
4. Claude for Teams Organizational tier above individual Pro:
- Shared projects across team members
- Admin console for user management
- Data privacy: conversations not used for training
- Higher usage limits
- Shared skills and knowledge bases
5. Claude for Enterprise For large organizations:
- All Teams features plus:
- SSO (Single Sign-On) integration
- Advanced admin controls and audit logs
- Custom data retention policies
- On-premise or VPC deployment options
- MCP for internal system connections
- Priority support and SLAs
- Custom fine-tuning options
Deployment decision matrix:
| Scenario | Recommended |
|---|---|
| Individual professional | claude.ai Pro |
| Small team, shared work | Claude for Teams |
| Large org, compliance needs | Claude Enterprise |
| Building a product | API |
| Software engineering workflow | Claude Code |
| Mobile / on-the-go | Mobile app |
Best Practices
- Start with the highest-leverage use case for your role rather than trying everything at once
- Identify the repetitive, time-consuming writing or analysis tasks first — those are highest ROI
- Share successful prompts with teammates to standardize quality
- Build organization-specific skills for workflows unique to your company
- Use Claude for Teams so knowledge and prompts aren’t siloed to individuals
- Establish guidelines for which data can be shared with Claude (check your org’s AI policy)
- Track time saved on tasks to build internal ROI case for broader adoption
Example
Scenario: End-to-end workflow for a product launch (cross-functional team).
Product Manager Engineering Marketing
| | |
v v v
[Feature spec] [Code review] [Launch copy]
Claude drafts Claude reviews Claude writes
PRD from notes PR, flags issues email, ads, posts
| | |
v v v
[Stakeholder deck] [Test generation] [A/B variants]
Claude builds Claude writes Claude generates
slide structure unit tests 5 subject lines
| | |
+----------+-----------+-----------+-----------+
|
v
Shared Project: "Product Launch Q3"
- All artifacts saved
- All roles can reference shared context
- Knowledge base: specs, brand guide, roadmap
Result: Entire cross-functional launch coordinated through one shared Claude project, with consistent context and reusable artifacts.
MODULE 5: Conclusion & Certificate
Key Notes
What’s Next?
After Claude 101, Anthropic offers additional learning paths:
Advanced courses:
- Claude for Developers — API usage, prompt engineering, building applications
- Claude for Enterprise — admin setup, MCP integration, security configuration
- Prompt Engineering Mastery — advanced techniques, chain-of-thought, structured outputs
- Building with Claude Code — software engineering workflows, agent capabilities
Community resources:
- Anthropic documentation (docs.anthropic.com)
- Claude Prompt Library — community-contributed examples
- Anthropic Cookbook (GitHub) — code examples and recipes
- Discord community — share techniques, get help
Skills to develop over time:
- Prompt pattern library: build personal collection of prompts that work well
- Workflow integration: embed Claude into daily tools (Zapier, Make, API)
- Team enablement: train colleagues, establish standards, share skills
- Measurement: track impact on time saved and quality improvement
Capability Summary
CLAUDE CAPABILITIES MAP
Information ──── Analysis ──── Creation ──── Automation
Processing | | |
| Research Writing Code
Reading Synthesis Editing Scripts
Summarizing Comparison Formatting Workflows
Extraction Critique Translation Pipelines
Claude’s strengths:
- Long-form text generation and editing
- Code generation across 40+ languages
- Synthesis of complex, multi-source information
- Following detailed, nuanced instructions
- Iterative refinement through conversation
- Consistent application of rules and style guides
Claude’s limitations (be aware):
- Knowledge cutoff date (training data has a cutoff; use research mode for current info)
- Cannot access the internet in standard chat (use integrations or research mode)
- Can make mistakes — always verify critical outputs (legal, financial, medical)
- Not a substitute for professional judgment in high-stakes decisions
- Confidential data: check your organization’s AI policy before sharing sensitive info
Certificate of Completion
The Claude 101 certificate is awarded upon:
- Completing all 5 sections
- Passing the assessment (if included in your course version)
- Demonstrating understanding of core concepts
The certificate validates foundational proficiency in:
- Understanding Claude’s model family and capabilities
- Structuring effective prompts
- Using projects, artifacts, and skills
- Leveraging integrations and research mode
- Identifying role-appropriate use cases
Best Practices
- Don’t try to master everything at once — pick one use case and develop fluency there first
- Revisit prompts that produce mediocre results: usually more context or specificity is the fix
- Keep a personal prompt library of what works well
- Treat Claude as a collaborative tool, not a replacement for your expertise — you direct, it executes
- Stay current: Claude models improve regularly; re-evaluate capabilities periodically
- Share what works with your team — adoption accelerates with peer examples
Example
30-day adoption plan for a new Claude user:
Week 1 — Foundations
- Complete Claude 101 course
- Try 3 different use cases from your role
- Experiment with prompt refinement (iterate on same task 3x)
Week 2 — Projects
- Set up 1-2 projects for recurring work
- Upload 2-3 reference documents to project knowledge
- Write system instructions for your main project
Week 3 — Expansion
- Connect 2-3 integrations (Google Drive, Slack)
- Try research mode for one deep research task
- Create 2-3 custom skills for repeated prompts
Week 4 — Optimization
- Share a successful skill with a colleague
- Identify the 3 highest-ROI tasks Claude helps with
- Explore next course in learning path
Final Summary Checklist
Module 1 — Meet Claude
- Understand Claude’s three core values: helpful, harmless, honest
- Know the model family: Haiku (fast), Sonnet (balanced), Opus (capable)
- Can write a well-structured prompt with context, task, format, and audience
- Know the six prompt improvement techniques (role, step-by-step, examples, XML, iterate, alternatives)
- Understand the three Desktop app modes: Chat, Cowork, Code
Module 2 — Organizing Work and Knowledge
- Can explain what a Project is and why to use one
- Understand project knowledge and system instructions
- Know what an Artifact is and all six artifact types
- Can describe how to create and use Skills
- Understand the difference between community and custom skills
Module 3 — Expanding Claude’s Reach
- Know which integrations are available (Drive, Slack, GitHub, Notion, etc.)
- Understand MCP and why it matters for enterprise
- Can explain enterprise search and how it differs from keyword search
- Know when to use research mode vs. standard chat
- Understand the research mode process (decompose → search → evaluate → synthesize → report)
Module 4 — Putting It All Together
- Can name 2-3 use cases for each of: Marketing, Engineering, Sales, HR, Legal, Finance
- Understand the difference between claude.ai, API, Claude Code, and Mobile
- Know the differences between Pro, Teams, and Enterprise
- Can identify the right deployment for a given scenario
Module 5 — Conclusion
- Aware of advanced learning paths (developers, enterprise, prompt engineering)
- Understand Claude’s strengths and known limitations
- Have a plan for personal adoption (use cases, skills, integrations)
- Certificate criteria understood
Study guide covers Claude.ai product as taught in the Claude 101 certification course. For API and Claude Code specifics, see the Building with the Claude API and Claude Code in Action guides.