ai-explained

Learning Roadmap

Reading is half. Building is the other half. This article is a project-based curriculum to take you from zero to “I can ship AI features for money.”

The principle

Learn by building. After every conceptual stage, build something small. After every cluster of stages, build something bigger. Public, with your name on it.

You’ll forget 80% of what you read. You’ll remember 80% of what you build.

A 90-day plan for someone new

Adjust to your starting point, but here’s a defensible default if you have software engineering experience and want to be productive on AI products.

Days 1–10: Foundations + Hello LLM

Read:

  • Stage 4 (language modeling intuition).
  • Stage 5 (tokens & embeddings).
  • Stage 8 (prompting).

Build:

  1. Make 100 API calls to Claude / GPT / Gemini through their SDK.
  2. Build a CLI tool that takes user input → calls model → prints response.
  3. Add streaming.
  4. Add structured output (JSON schema).

You should now be comfortable making API calls and understanding what comes back.

Days 11–25: RAG

Read:

  • Stage 9 (RAG end-to-end).
  • Stage 5 (semantic geometry section).

Build:

  1. Take 1000 of your own notes / a public dataset (Wikipedia subset, ArXiv abstracts).
  2. Chunk, embed, store in pgvector / ChromaDB / LanceDB.
  3. Build a question-answering CLI: query → retrieve → prompt → answer with citations.
  4. Add hybrid search (BM25 + dense).
  5. Build a 50-query eval set; measure recall@10 and faithfulness.

You should now have a working RAG and an honest sense of how it fails.

Days 26–40: Agents

Read:

  • Stage 11 (agents).
  • Stage 7 (reasoning models, briefly).

Build:

  1. Build an agent loop in <100 lines, no framework.
  2. Give it 5 tools: web search, read URL, calculator, save note, finalize.
  3. Make it answer multi-hop questions like “Who was the CEO of Apple when the iPhone 7 launched?”
  4. Add: error handling, retry on tool failure, budget cap.
  5. Deploy as an API or CLI; share with someone.

You can now ship an agent.

Days 41–55: Multimodal

Read:

  • Stage 12 (multimodal).
  • Stage 11 (browser/vision agents).

Build:

  1. CLIP-embed 100 images. Build a search tool: “find a photo of [description].”
  2. Use a VLM (Claude vision, GPT-4o, Qwen-VL) to caption a folder of images.
  3. (Optional, advanced) Build a tiny browser agent with Playwright + Claude Computer Use that handles a single workflow.

You can now do multimodal.

Days 56–70: Production discipline

Read:

  • Stage 13 (production).

Build:

  1. Add observability (Langfuse / Phoenix) to your RAG and agent.
  2. Add cost monitoring and per-query alerts.
  3. Add input filtering (basic moderation).
  4. Add output schema validation.
  5. Build a CI pipeline that runs your eval set on every prompt change.

You can now ship something close to production-ready.

Days 71–90: Build something real

Pick one:

  • A vertical agent for a domain you know (legal contract review, recipe planner, code reviewer).
  • A vertical RAG over a corpus you care about (academic papers in your field, a friend’s notes).
  • A useful workflow (transcribe meetings → action items, summarize daily news, …).

Make it polished enough to share. Write up the engineering decisions.

Post on:

  • GitHub (code).
  • Hacker News, Reddit (discussion).
  • Your own blog or LinkedIn (writeup).

This last 20 days is the highest-leverage thing in the whole 90.

After 90 days

You’ll have:

  • A portfolio of public work.
  • Calibrated intuitions about what’s hard.
  • Identified specific gaps in your knowledge.

Next moves:

  • Apply for AI engineer roles with your portfolio.
  • Contribute to open-source AI projects (vLLM, llama.cpp, sentence-transformers, agent frameworks).
  • Specialize: pick a stage / area, go deep.
  • Build a production-grade product — actual users, actual feedback.

If you have ML background already

You’re ahead. Skip to:

  • Stage 6 (transformers from scratch — even if you’ve used them, build one).
  • Stage 7 (modern LLM landscape).
  • Stage 10 (fine-tuning patterns).
  • Stage 11–14.

Build a fine-tuned LoRA on a domain dataset. Deploy it. Compare to a prompted baseline.

If you’re a research-track person

Read the foundational papers in addition to (not instead of) this path:

  • “Attention Is All You Need” (2017)
  • “Language Models are Few-Shot Learners” (GPT-3, 2020)
  • “Training Language Models to Follow Instructions” (InstructGPT, 2022)
  • “Chain of Thought Prompting” (Wei, 2022)
  • “Direct Preference Optimization” (Rafailov, 2023)
  • DeepSeek R1 paper (2024)
  • LLaMA 3 / 4 technical reports
  • Frontier model system cards

Read 3 papers a week. Re-implement one a month. Write summaries publicly.

Anti-patterns

  • Watching tutorials forever. Building > watching.
  • Picking too big a first project. Start with a 1-day version, then expand.
  • Building in private. Public work compounds career capital.
  • Ignoring evaluation. Without it, you don’t know what’s broken.
  • Chasing every new model release. Pick one, go deep, then evaluate alternatives.

A 12-month plan, briefly

If 90 days is “fluent enough to be productive,” 12 months is “specialist.”

  • Month 4–6: Build something with active users. Get real feedback.
  • Month 7–9: Specialize — vertical agent, niche RAG, fine-tuning expert.
  • Month 10–12: Contribute to open-source meaningfully, write a series of technical blog posts, or land at a top-tier AI team.

By month 12, you’re recognizably “the person who knows X” in your network.

See also