Ever stared at a new codebase written by others feeling completely lost? This tutorial shows you how to build an AI agent that analyzes local codebases and creates beginner-friendly tutorials explaining exactly how the code works.

This is a tutorial project of Pocket Flow, a 100-line LLM framework. It crawls local directories and builds a knowledge base from the code. It analyzes entire codebases to identify core abstractions and how they interact, and transforms complex code into beginner-friendly tutorials with clear visualizations.

• Check out the YouTube Development Tutorial for more!

• Check out the Substack Post Tutorial for more!

  🔸 🎉 Reached Hacker News Front Page (April 2025) with >900 up‑votes: Discussion »

  🔸 🎊 Online Service Now Live! (May 2025) Try our new online version at https://code2tutorial.com/ – just paste a GitHub link, no installation needed!

🤯 All these tutorials are generated entirely by AI by crawling the GitHub repo!

• AutoGen Core - Build AI teams that talk, think, and solve problems together like coworkers!

• Browser Use - Let AI surf the web for you, clicking buttons and filling forms like a digital assistant!

• Celery - Supercharge your app with background tasks that run while you sleep!

• Click - Turn Python functions into slick command-line tools with just a decorator!

• Codex - Turn plain English into working code with this AI terminal wizard!

• Crawl4AI - Train your AI to extract exactly what matters from any website!

• CrewAI - Assemble a dream team of AI specialists to tackle impossible problems!

• DSPy - Build LLM apps like Lego blocks that optimize themselves!

• FastAPI - Create APIs at lightning speed with automatic docs that clients will love!

• Flask - Craft web apps with minimal code that scales from prototype to production!

• Google A2A - The universal language that lets AI agents collaborate across borders!

• LangGraph - Design AI agents as flowcharts where each step remembers what happened before!

• LevelDB - Store data at warp speed with Google's engine that powers blockchains!

• MCP Python SDK - Build powerful apps that communicate through an elegant protocol without sweating the details!

• NumPy Core - Master the engine behind data science that makes Python as fast as C!

• OpenManus - Build AI agents with digital brains that think, learn, and use tools just like humans do!

• PocketFlow - 100-line LLM framework. Let Agents build Agents!

• Pydantic Core - Validate data at rocket speed with just Python type hints!

• Requests - Talk to the internet in Python with code so simple it feels like cheating!

• SmolaAgents - Build tiny AI agents that punch way above their weight class!

• Showcase Your AI-Generated Tutorials in Discussions!

1. Clone this repository

   git clone https://github.com/The-Pocket/PocketFlow-Tutorial-Codebase-Knowledge

2. Install dependencies:

   pip install -r requirements.txt

3. LLM mode is file-based by default in utils/call_llm.py:

   • For each step, prompt/response files are generated under workspace/llm/<project_name>/prompts/ and workspace/llm/<project_name>/responses/.
   • The process emits a machine-readable signal line:
     • [LLM_SIGNAL]{"type":"llm_manual_request","prompt_path":"...","response_path":"..."}
   • An agent should read prompt_path, write a response to response_path, and the runner automatically continues once the file is non-empty.
   • Consent is asked once per run (when enabled), then subsequent steps proceed automatically.
   • Prompt/response files use stable step names (for example identify_abstractions.txt, write_chapter_01.txt) so reruns can auto-skip steps when response files already exist. You can verify manual mode by running:

   python utils/call_llm.py

4. Configure run settings in YAML:

   # configure_args.yaml
   local_dir: /path/to/your/codebase
   project_name: my-project
   include_patterns:
     - "*.py"
   exclude_patterns:
     - "tests/*"
   output_dir: output
   language: english
   max_file_size: 100000
   use_cache: true
   max_abstraction_num: 10
   llm_require_consent: false
   llm_show_prompt: false
   log_dir: workspace/logs
   llm_cache_file: workspace/cache/llm_cache.json
   llm_manual_dir: workspace/llm
   llm_manual_poll_interval_s: 2.0
   llm_manual_timeout_s: 0
   llm_redact_logs: true

   • Edit this YAML file directly before running.

5. Run the full pipeline:

   python main.py

   • RunConfig loads and shows the effective YAML config, then asks for final approval before crawling starts.

6. Manual mode behavior:

   • No terminal paste is required.
   • The app writes prompt files and automatically waits/polls for matching response files.
   • LLM_SIGNAL lines provide exact prompt/response paths for agent automation.
   • LLM cache is project-scoped under workspace/cache/<project_name>/ (derived from llm_cache_file base name).
   • Polling can be configured in YAML with llm_manual_poll_interval_s and llm_manual_timeout_s.

7. Prompt for your terminal agent:

   • See PROMPT_INIT.md.

The application reads project settings from YAML, crawls the configured local directory, analyzes the codebase structure, generates tutorial content, and saves output to the configured output directory.

• I built using Agentic Coding, the fastest development paradigm, where humans simply design and agents code.

• The secret weapon is Pocket Flow, a 100-line LLM framework that lets Agents (e.g., Cursor AI) build for you

• Check out the Step-by-step YouTube development tutorial: