Why This Exists

Most documentation tells you what to do. These tutorials explain how and why complex systems work under the hood — with architecture diagrams, real code walkthroughs, and production-grade patterns.

┌──────────────────────────────────────────────────────────────┐
│                                                              │
│    📖 Typical Docs          vs.     🔬 Awesome Code Docs    │
│    ─────────────                    ─────────────────────    │
│    "Run this command"               "Here's the pipeline     │
│    "Use this API"                    architecture that makes │
│    "Set this config"                 this work, the design   │
│                                      tradeoffs, and how to   │
│                                      extend it yourself"     │
│                                                              │
└──────────────────────────────────────────────────────────────┘

Every tutorial follows a consistent 8-chapter structure:

Each chapter includes Mermaid architecture diagrams, annotated code examples from the real codebase, and summary tables for quick reference.

🔎 Find Tutorials by Goal

Use this quick-start map if you searched for a specific outcome.

🧭 Navigation UX Layer

To reduce context-switching and dead ends:

• every tutorial index now includes a Navigation & Backlinks block
• each block links back to the main catalog, A-Z directory, query hub, and category hubs
• chapter 1 entry links are pinned so readers can jump directly into each track

Quick jump links:

• Tutorials Workspace Guide
• A-Z Tutorial Directory
• Query Hub
• Search Intent Map
• Category Hubs

✅ Source Verification Status

All tutorial indexes were re-verified against referenced upstream GitHub repositories on 2026-04-12:

• tutorials scanned: 203
• tutorials with source repos: 203
• tutorials with unverified source repos: 0
• unique verified source repos: 203

Verification artifacts:

• Tutorial Source Verification Report
• Tutorial Source Verification JSON
• verification script: scripts/verify_tutorial_sources.py

🧬 Taskade Ecosystem Snapshot (Verified 2026-03-21)

Live repository snapshot for high-intent Taskade/Genesis/AI/MCP searches.

📈 Trending Vibe-Coding Repos (Auto-updated 2026-05-04)

Live GitHub market signals for high-impact open-source coding-agent and vibe-coding ecosystems with direct tutorial coverage.

Data source: GitHub REST API (stargazers_count, pushed_at) via scripts/refresh_market_signals.py.

📚 Tutorial Catalog

 ╔════════════════════════════════════════════════════════════╗
 ║  🤖  AI & AGENTS  │  🔧  DEV TOOLS  │  🗄️  DATA  │  🎤 SPEECH  ║
 ║   83+ tutorials    │   50+ tutorials │  14 tutorials │  3 tutorials  ║
 ╚════════════════════════════════════════════════════════════╝

Category Hubs

🤖 AI Agents & Multi-Agent Systems

Build autonomous AI systems that reason, plan, and collaborate.

🧠 LLM Frameworks & RAG

Retrieval-augmented generation, model serving, and LLM tooling.

🖥️ LLM Infrastructure & Serving

Run, serve, and manage LLMs in production.

💬 Chat & AI Applications

Full-stack AI chat platforms and copilots.

🔧 Developer Tools & Productivity

AI coding assistants, build systems, and dev infrastructure.

Terminal Coding Agents

Multi-Agent Orchestration

IDE & Visual Interfaces

Memory, Skills & Context

MCP Servers & Integrations

Legacy & Migration

🗄️ Databases, Knowledge & Analytics

Data platforms, knowledge management, and observability.

⚙️ Systems & Infrastructure

Low-level systems, cloud native, and infrastructure patterns.

🎤 Speech & Multimodal AI

Voice recognition, audio processing, and multimodal AI applications.

🗺️ Learning Paths

 ┌─────────────────────────────────────────────────────────────┐
 │                    CHOOSE YOUR PATH                         │
 │                                                             │
 │  🟢 Beginner    Start here if you're new to AI/ML          │
 │  🟡 Builder     Ready to build production applications      │
 │  🔴 Architect   Designing systems at scale                  │
 └─────────────────────────────────────────────────────────────┘

🟢 Path 1: AI Fundamentals

"I want to understand how AI applications work"

Ollama ──→ LangChain ──→ Chroma ──→ Open WebUI
 (run       (build        (store      (deploy a
  LLMs       chains)       vectors)    full app)
  locally)

🟡 Path 2: Agent Builder

"I want to build autonomous AI agents"

LangChain ──→ LangGraph ──→ CrewAI ──→ AutoGen/AG2 ──→ Langfuse
 (basics)      (stateful     (teams)    (multi-agent    (monitor
                graphs)                  orchestration)  in prod)

🟡 Path 3: RAG Engineer

"I want to build retrieval-augmented generation systems"

LlamaIndex ──→ Haystack ──→ DSPy ──→ RAGFlow ──→ vLLM
 (indexing &    (pipeline    (optimize  (document   (serve at
  retrieval)     search)      prompts)   processing)  scale)

🟡 Path 4: Full-Stack AI

"I want to build AI-powered web applications"

Vercel AI ──→ CopilotKit ──→ LobeChat ──→ Supabase ──→ n8n
 (AI SDK       (in-app        (full chat   (database    (workflow
  basics)       copilots)       platform)    + auth)      automation)

🔴 Path 5: LLM Infrastructure

"I want to run and scale LLMs in production"

llama.cpp ──→ vLLM ──→ LiteLLM ──→ BentoML ──→ K8s Operators
 (local         (GPU     (unified    (model      (orchestrate
  inference)     serving)  gateway)    packaging)   at scale)

🔴 Path 6: AI Coding Tools

"I want to understand how AI coding assistants work"

Continue ──→ Sweep ──→ OpenHands ──→ OpenCode ──→ Tabby ──→ Stagewise ──→ OpenSpec ──→ Kiro
 (code         (issue      (AI SWE      (terminal        (self-hosted     (frontend       (spec-driven   (spec-driven
  completion)   to PR)      agent)       coding agent)    assistant)       browser agent)  delivery)      AI IDE)

🔴 Path 7: Autonomous AI Engineers

"I want to build and understand autonomous software engineering agents"

OpenHands ──→ Devika ──→ SWE-agent ──→ Mini SWE-agent ──→ Aider ──→ BabyAGI
 (multi-agent   (planning    (SWE bench    (lightweight         (pair         (task-driven
  OS layer)      pipeline)    framework)    agent core)          programming)   autonomy)

Duration: 30-45 hours | Difficulty: Advanced

🟡 Path 8: MCP Mastery

"I want to build AI tool servers and extend Claude with custom capabilities"

MCP Python SDK ──→ FastMCP ──→ MCP Servers ──→ MCP Quickstart Resources ──→ Create Python Server ──→ MCP Docs Repo ──→ Create TypeScript Server ──→ Awesome MCP Servers ──→ Composio ──→ Daytona ──→ GenAI Toolbox ──→ awslabs/mcp ──→ MCP Inspector ──→ MCP Registry ──→ MCP Specification ──→ MCP TypeScript SDK ──→ MCP Go SDK ──→ MCP Rust SDK ──→ MCP Java SDK ──→ MCP C# SDK ──→ MCP Swift SDK ──→ MCP Kotlin SDK ──→ MCP Ruby SDK ──→ MCP PHP SDK ──→ MCP Ext Apps ──→ MCPB ──→ use-mcp ──→ MCP Use ──→ MCP Chrome ──→ Firecrawl MCP Server
 (build             (build servers      (reference        (multi-lang             (python scaffold        (archived docs        (typescript scaffold      (discovery and          (tool + auth   (sandbox        (db-focused           (aws server          (debug +            (publish +           (protocol             (client/server         (go sdk +            (rust rmcp +         (java sdk +          (csharp sdk +         (swift sdk +          (kmp core +            (ruby server +          (php server +          (interactive ui +      (bundle pack +         (react hook +         (full-stack          (chrome native +      (web scrape +
  servers)           fast)               implementations)  quickstart set)         bootstrap path)         migration map)        bootstrap path)          curation)               runtime)       infra)          mcp control plane)    ecosystem)           transport tests)     discovery ops)        contract deep dive)    sdk internals)         conformance)          task/oauth focus)      spring modules)        aspnet filters)        lifecycle controls)    transport model)        client workflow)        discovery model)        host bridge model)      sign verify)            archived guidance)      mcp workflows)        semantic tabs)        search/crawl)

Duration: 100-135 hours | Difficulty: Intermediate to Advanced

🟢 Path 9: Speech & Voice AI

"I want to build voice-first AI applications"

OpenAI Whisper ──→ Whisper.cpp ──→ OpenAI Realtime Agents ──→ Voice Apps
 (Python ASR,       (edge            (voice-first             (production
  fine-tuning)       deployment)       conversations)           voice apps)

Duration: 25-35 hours | Difficulty: Intermediate

🟡 Path 10: OpenAI Ecosystem

"I want to master OpenAI's tools and APIs"

OpenAI Python SDK ──→ tiktoken ──→ OpenAI Whisper ──→ Realtime Agents
 (core API,          (token         (speech              (voice
  embeddings,         optimization)  recognition)         agents)
  assistants)

Duration: 35-45 hours | Difficulty: Beginner to Intermediate

🔴 Path 11: Vibe Coding Platforms

"I want to build and operate vibe-coding stacks end to end"

Dyad ──→ bolt.diy ──→ Stagewise ──→ Cline ──→ Roo Code ──→ VibeSDK ──→ HAPI
 (local      (OSS app      (frontend      (IDE        (multi-mode    (cloud         (remote
  builder)    builder)      browser agent) agent)      dev team)      platform)      approvals)

Duration: 35-50 hours | Difficulty: Intermediate to Advanced

📊 Collection Stats

╔══════════════════════════════════════════════════════════╗
║                  COLLECTION OVERVIEW                     ║
╠══════════════════════════════════════════════════════════╣
║  📦 Total Tutorials        203                           ║
║  📝 Numbered Chapters      1,624+                        ║
║  📏 Tutorial Markdown      706,049 lines                 ║
║  ⏱️  Estimated Hours        2,000+                        ║
║  ✅ Local Broken Links      0                             ║
║  🧭 Structure Drift         0 (all root canonical)        ║
╚══════════════════════════════════════════════════════════╝

Stats are synchronized against:

• tutorials/tutorial-manifest.json
• scripts/docs_health.py baseline checks

🛠️ How Tutorials Are Built

Each tutorial is generated using AI-powered codebase analysis, then reviewed and enhanced for accuracy. The process:

┌──────────┐    ┌──────────────┐    ┌──────────────┐    ┌──────────┐
│  Crawl   │───→│   Identify   │───→│   Generate   │───→│  Review  │
│  Repo    │    │  Abstractions│    │   Chapters   │    │ & Polish │
└──────────┘    └──────────────┘    └──────────────┘    └──────────┘
   Clone &         Find core          Write 8-ch          Verify code
   index files     classes &          tutorials w/         examples &
                   patterns           diagrams             architecture

Inspired by Tutorial-Codebase-Knowledge by The Pocket.

Built & Maintained With

🤝 Contributing

We welcome contributions! Here's how you can help:

┌─────────────────────────────────────────────────┐
│              WAYS TO CONTRIBUTE                  │
├─────────────────────────────────────────────────┤
│  ⭐  Star the repo to show support              │
│  📝  Suggest a new tutorial via Issues           │
│  🔧  Fix errors or improve existing tutorials    │
│  📖  Write a new tutorial for a project          │
│  💬  Share feedback in Discussions                │
└─────────────────────────────────────────────────┘

What Makes a Great Tutorial?

• Goes deep — explains how and why, not just what
• Real code — examples from the actual codebase, not toy demos
• Visual — architecture diagrams, flow charts, sequence diagrams
• Progressive — builds complexity gradually across chapters
• Production-focused — covers deployment, monitoring, scaling

Open an Issue to suggest a new tutorial or report a problem.

🌍 Community

┌──────────────────────────────────────────────────┐
│                                                  │
│   "The best way to learn a codebase is to        │
│    understand the architecture decisions          │
│    that shaped it."                               │
│                                                  │
└──────────────────────────────────────────────────┘