Claude Guides
Rondanini Publishing Ltd.

🤖 Cursor Instructions: Build Claude Guides Complete

Use this document in Cursor to generate the entire Claude Guides project with SVG assets.

🎯 MASTER BUILD INSTRUCTIONS FOR CURSOR

Context

You are building a comprehensive, professional-grade educational platform called "Claude Guides" - a free, open-source curriculum for learning Claude AI from fundamentals to expert level (126 hours of content, 26 guides).

The project follows the pedagogical principles of Berta Chapters (https://github.com/Berta-one/berta-chapters) with a modern, professional design aesthetic similar to Claude's own branding (clean, modern, accessible).

📋 PHASE 1: CREATE ALL JUPYTER NOTEBOOKS

Task: Generate Jupyter Notebooks for All 26 Guides

For each of the 26 guides, create 3 Jupyter notebooks following this structure:

Location: guides/guide-XX-topic/notebooks/

Files to create per guide: 1. 01_introduction.ipynb (1.5-2 hours of content) 2. 02_intermediate.ipynb (2-3 hours of content) 3. 03_advanced.ipynb (1.5-2.5 hours of content)

Notebook Structure Template:

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Guide XX: [Topic Name] - Introduction\n",
    "\n",
    "## Learning Objectives\n",
    "- Objective 1\n",
    "- Objective 2\n",
    "- Objective 3\n",
    "\n",
    "## Time Estimate: 1.5 hours\n",
    "\n",
    "---\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What You'll Learn\n",
    "\n",
    "[Clear explanation of concepts]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code example with clear comments\n",
    "# This demonstrates [concept]"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}

Content Guidelines for Each Notebook:

01_introduction.ipynb: (Beginner-friendly) - Welcome and context - Key concepts explained simply - 5-8 working code examples - Each example builds on previous - Output shown for verification - Encouraging, supportive tone - Marks where to take breaks

02_intermediate.ipynb: (Intermediate level) - Quick review of Guide 1 - Deeper concepts (5-10 cells) - Real-world patterns (5-10 cells) - Code best practices - Common mistakes to avoid - Worked examples with edge cases - Practical application

03_advanced.ipynb: (Advanced/Expert) - Assumes Guide 1 & 2 mastery - Complex patterns - Performance considerations - Edge cases and gotchas - Production-grade code - Integration with other concepts - Expert tips and tricks

Start with Guide 01 (already created) as template, then generate for all others.

Guides to Create Notebooks For:

  1. ✅ Guide 01 - DONE (use as template)
  2. Guide 02: Claude's Capabilities & Models
  3. Guide 03: Prompt Engineering Fundamentals
  4. Guide 04: Using Claude's API
  5. Guide 05: Claude Tokens & Rate Limits
  6. Guide 06: Advanced Prompt Engineering
  7. Guide 07: Building Claude Applications
  8. Guide 08: Tool Use & Function Calling
  9. Guide 09: Building RAG Systems
  10. Guide 10: Multi-Turn Conversations & State
  11. Guide 11: Claude for Data Analysis
  12. Guide 12: Claude for Code Generation
  13. Guide 13: Claude for Content Creation
  14. ✅ Guide 14 - DONE (use as template)
  15. Guide 15: Advanced Reasoning & Complex Tasks
  16. Guide 16: Optimization & Cost Efficiency
  17. Guide 17: Fine-Tuning & Customization
  18. Guide 18: Building Multi-Agent Systems
  19. Guide 19: Claude at Scale (Enterprise Patterns)
  20. Guide 20: Testing, Evaluation & Monitoring
  21. Guide S1: Claude for Business Intelligence
  22. Guide S2: Claude for Research & Academia
  23. Guide S3: Claude for Creative Writing
  24. Guide S4: Claude for Education & Tutoring
  25. Guide S5: Claude for Software Engineering
  26. Guide S6: Claude for Product Management

🐍 PHASE 2: CREATE PYTHON SCRIPTS

Task: Generate Production-Ready Python Scripts

For each guide, create 2-3 working Python scripts demonstrating the concepts.

Location: guides/guide-XX-topic/scripts/

Files per guide: - main_application.py - Complete working example - utilities.py - Helper functions - examples/example_1.py - Use case 1 - examples/example_2.py - Use case 2 - examples/example_3.py (optional) - Advanced use case

Quality Requirements: - ✅ Production-ready code - ✅ Full error handling - ✅ Comprehensive docstrings - ✅ Type hints throughout - ✅ PEP 8 compliant - ✅ Well-commented - ✅ No hardcoded secrets - ✅ Working code (not pseudocode) - ✅ Can run standalone - ✅ Clear example usage

Python Script Template:

#!/usr/bin/env python3
"""
[Guide XX]: [Topic Name] - Main Application

Demonstrates: [What this script shows]

Usage:
    python main_application.py [arguments]

Requirements:
    - anthropic >= 0.7.0
    - python-dotenv >= 1.0.0
"""

import os
from typing import Optional
from anthropic import Anthropic
from dotenv import load_dotenv


def initialize_client() -> Anthropic:
    """Initialize Anthropic client with API key from environment."""
    load_dotenv()
    api_key = os.environ.get("ANTHROPIC_API_KEY")
    if not api_key:
        raise ValueError("ANTHROPIC_API_KEY environment variable not set")
    return Anthropic(api_key=api_key)


def main():
    """Main application logic."""
    client = initialize_client()
    # Application code here
    pass


if __name__ == "__main__":
    main()

Guides Needing Scripts: All 26 guides

📝 PHASE 3: CREATE EXERCISES

Task: Generate Exercise Sets with Solutions

For each guide, create 3 exercises with complete solutions.

Location: guides/guide-XX-topic/exercises/

Files per guide: - exercises.md - Problem statements (Beginner, Intermediate, Advanced) - starter_code/exercise_1.py - Template 1 - starter_code/exercise_2.py - Template 2 - starter_code/exercise_3.py - Template 3 - solutions/exercise_1_solution.py - Full solution 1 - solutions/exercise_2_solution.py - Full solution 2 - solutions/exercise_3_solution.py - Full solution 3

Exercise Format (exercises.md):

# Exercises for Guide XX: [Topic]

## Exercise 1: [Name]
**Difficulty**: Beginner | **Time**: 30 min

[Clear problem description with context]

### What You'll Learn
- Skill 1
- Skill 2
- Skill 3

### Requirements
- [ ] Requirement 1
- [ ] Requirement 2
- [ ] Requirement 3

### Hints
- Hint 1
- Hint 2

### Resources
- Link to relevant section
- External reference

---

## Exercise 2: [Name]
[Same format, Intermediate level]

---

## Exercise 3: [Name]
[Same format, Advanced level]

Starter Code Format:

"""
Exercise [N]: [Name]

[Problem description]

TODO: Complete the implementation below
"""

def solve_problem(input_data):
    """
    [Description of what to implement]

    Args:
        input_data: [Type and description]

    Returns:
        [Type and description]
    """
    # TODO: Your code here
    pass


if __name__ == "__main__":
    # Test your solution
    test_input = "[Test data]"
    result = solve_problem(test_input)
    print(result)

Solution Format: Same as main scripts - production-ready, fully commented.

📊 PHASE 4: CREATE DIAGRAMS

Task: Generate Mermaid Diagrams

For key concepts in each guide, create Mermaid diagrams.

Location: guides/guide-XX-topic/assets/diagrams/

Required Diagrams Per Guide (2-3): - Concept architecture - Process flow - System interaction - Workflow diagram

Mermaid Examples:

graph LR
    A[Input] --> B[Process]
    B --> C{Decision}
    C -->|Yes| D[Output 1]
    C -->|No| E[Output 2]

sequenceDiagram
    User->>Client: Request
    Client->>API: Call Claude
    API->>Claude: Process
    Claude->>API: Response
    API->>Client: Return
    Client->>User: Display

graph TD
    A[Start] --> B[Step 1]
    B --> C[Step 2]
    C --> D{Check}
    D -->|OK| E[End]
    D -->|Error| F[Handle Error]
    F --> B

📦 PHASE 5: CREATE SVG ASSETS

Task: Generate SVG Graphics Matching Claude Design

Create SVGs in Claude's aesthetic (modern, clean, blue/purple tones):

Location: assets/svg/

SVGs to Create: 1. claude-icon.svg - Claude icon/logo 2. arrow-right.svg - Navigation arrows 3. chevron-down.svg - Expandable elements 4. checkmark.svg - Success indicators 5. code-icon.svg - Code examples 6. book-icon.svg - Learning materials 7. puzzle-icon.svg - Concepts 8. rocket-icon.svg - Getting started 9. star-icon.svg - Featured/premium 10. github-icon.svg - Links 11. lightbulb-icon.svg - Tips 12. warning-icon.svg - Cautions 13. diagram-frame.svg - Diagram container 14. progress-bar.svg - Progress indicator 15. badge-complete.svg - Completion badge

SVG Design Guidelines: - Stroke width: 1.5-2px - Colors: Blues (#2563EB, #1E40AF), Purples (#7C3AED, #6D28D9), Grays (#6B7280, #D1D5DB) - Viewbox: 24x24 for icons - Rounded corners: 2-4px - Fill: "none" for outlines, "currentColor" for flexible coloring - Modern, minimalist style - Accessibility: proper contrast

See PHASE 6 below for SVG code generation

🎨 PHASE 6: SVG CODE GENERATION

Use Cursor to generate the following SVG files based on Claude's design system:

Command for Cursor:

Generate all SVG icons matching Claude's design aesthetic:
- Modern, clean lines
- Blue (#2563EB) and purple (#7C3AED) primary colors
- Gray accents (#6B7280, #D1D5DB)
- Rounded corners
- Stroke-based (not filled)
- 24x24 viewBox for icons
- Professional, minimal style

Specific SVGs to create (detailed prompts below)

📄 PHASE 7: CREATE REMAINING DOCUMENTATION

Task: Complete All Guide READMEs

For guides 02-13 and 15-20 and S1-S6, create comprehensive READMEs following the template in guides that exist (01 and 14).

Each README should have: - Learning objectives (5-7 bullets) - Prerequisites (knowledge, skills, tools) - Time estimates (intro, intermediate, advanced) - Content overview - Key concepts explained - Content structure - Exercises section - Next steps - Further learning - Troubleshooting (if applicable)

Use existing READMEs as template: - guides/guide-01-getting-started/README.md (3,000 words) - guides/guide-14-production-patterns/README.md (3,000 words)

🌐 PHASE 8: CREATE ADDITIONAL RESOURCES

Task: Create Supporting Files

For each guide, create:

RESOURCES.md (500 words): - Official documentation links - Related guides - External resources - Video tutorials - Community links - Paper/research references

requirements.txt (minimal, specific to guide): List only essential dependencies for that guide's scripts

📊 PHASE 9: GENERATE SAMPLE DATASETS

For guides that need them, create sample data files:

Locations: guides/guide-XX-topic/datasets/

Examples: - CSV files with sample data - JSON files with API responses - Text files for NLP examples - CSV with financial/analysis data - Sample emails, documents - User interview transcripts

Quality: - Realistic data - Sufficient for exercises - Privacy-respecting (no real personal data) - Multiple formats where relevant

✅ COMPLETION CHECKLIST

For Each of 26 Guides

🎯 PRIORITY ORDER FOR CURSOR

If Building Everything:

High Priority (Build First): 1. Guides 01-05 (Essentials) - Foundation knowledge 2. Guides 06-09 (Practitioner - Core) - Applications 3. SVG Assets - Used throughout 4. All Jupyter notebooks - Learning materials

Medium Priority (Build Second): 5. Guides 10-13 (Practitioner - Complete) 6. Guides 14-20 (Expert) 7. Python scripts for all guides 8. Exercises for all guides

Lower Priority (Build Last): 9. Guides S1-S6 (Specialized) 10. Additional diagrams 11. Sample datasets 12. Resources pages

🛠️ CURSOR WORKFLOW TIPS

Method 1: Batch Creation

Generate all Jupyter notebooks for Guides 01-05 in one session
Then: Generate all Python scripts for Guides 01-05
Then: Generate all exercises for Guides 01-05
Then: Move to Guides 06-10, repeat

Method 2: Guide-by-Guide

For Guide XX:
1. Generate README
2. Generate all 3 notebooks
3. Generate main script + utilities
4. Generate 3 exercises + solutions
5. Generate 2-3 diagrams
6. Move to next guide

Method 3: Parallel Tasks

Session 1: All READMEs (all 26 guides)
Session 2: All Notebooks (all 26 guides)
Session 3: All Python scripts (all 26 guides)
Session 4: All exercises (all 26 guides)
Session 5: All diagrams (all 26 guides)
Session 6: All SVG assets (one session)

📋 CURSOR PROMPT TEMPLATES

For Jupyter Notebooks:

Create a comprehensive Jupyter notebook for [Guide XX: Topic].
Level: [Introduction/Intermediate/Advanced]
Duration: [1.5-2.5] hours
Topics: [List main topics]
Requirements: [Dependencies needed]

Structure:
- Welcome & learning objectives
- [2-3] concept explanations
- [5-10] working code examples with output
- [3-5] exercises
- Summary

Style: Friendly, encouraging, clear explanations
Tone: Educational, supportive
Code: Production-ready, well-commented, type hints

For Python Scripts:

Create a production-ready Python script for [Topic].
File: [main_application.py]

Requirements:
- PEP 8 compliant
- Type hints throughout
- Comprehensive docstrings
- Full error handling
- Works standalone
- No hardcoded secrets
- Clear usage examples
- ~[150-300] lines

Functions:
1. [Function 1]
2. [Function 2]
3. [Function 3]

For Exercises:

Create 3 progressive exercises for Guide XX: [Topic].

Exercise 1 (Beginner):
- Topic: [Specific concept]
- Time: 30 minutes
- Difficulty: Basic application

Exercise 2 (Intermediate):
- Topic: [More complex concept]
- Time: 45-60 minutes
- Difficulty: Real-world scenario

Exercise 3 (Advanced):
- Topic: [Advanced application]
- Time: 60-90 minutes
- Difficulty: Complex problem-solving

Include:
- Problem statement
- Learning objectives
- Requirements checklist
- Hints
- Complete solutions

For SVG Icons:

Create SVG icons matching Claude's design system:
- Modern, minimal style
- Blue (#2563EB) and purple (#7C3AED) primary
- Gray (#6B7280) accents
- Rounded corners (2-4px)
- Stroke-based (not filled)
- 24x24 viewBox
- Accessible contrast

Icons needed:
1. [Icon name] - [Description]
2. [Icon name] - [Description]
...

🚀 HOW TO START IN CURSOR

Step 1: Copy This File

Save this entire document into Cursor as context

Step 2: Start with Phase 1

@cursor
Using the guide below, create all Jupyter notebooks for Guides 01-05.
Follow the structure and requirements exactly.
Use existing notebooks (01, 14) as templates.

Step 3: Follow the Checklist

Go through each phase systematically

Step 4: Reference Existing Files

@notebook-reference guides/guide-01-getting-started/notebooks/01_introduction.ipynb
@readme-reference guides/guide-01-getting-started/README.md
@script-reference guides/guide-01-getting-started/scripts/simple_chatbot.py

Step 5: Batch Operations

After getting the pattern, ask Cursor to:

Apply the same structure to guides 02-05 simultaneously

📊 TOTAL OUTPUT SUMMARY

When complete, you will have:

Total Content: ~250,000+ words, 5,000+ lines of code, 300+ files

⚡ ESTIMATED CURSOR TIME

Total Cursor Time: ~40-50 sessions (using Cursor's parallelization)

🎨 SVG GENERATION - DETAILED

See next section for complete SVG code generation

✨ NOTES FOR CURSOR

  1. Consistency: Keep style consistent across all outputs
  2. Quality: Prioritize quality over speed
  3. Testing: Ensure all Python scripts actually work
  4. Documentation: Every function needs docstrings
  5. Type Hints: Add to all Python code
  6. Accessibility: SVGs need good contrast and semantics
  7. Comments: Code needs clear, helpful comments

Ready to build? Start with Phase 1 and work systematically through all phases.

This will create a complete, professional-grade educational platform. 🚀