A structured, market-aligned study plan to become an AI Engineer — focused on what companies actually hire for today: LLM integration, RAG, evaluation, production systems, and cost optimization.
Profile: Intermediate Python, moderate math, familiar with AI tools (Claude Code, etc.) Commitment: 15-25 hours/week Structure: 5 phases over 12 weeks (3 months) Philosophy: LLM-first, production-focused, learn by building with AI assistance
Need more time? See the Extended Version (6-7 months) for a slower pace at 10-15 hours/week.
This accelerated timeline works because:
| Traditional Learning | Learning with Claude |
|---|---|
| Watch 4-hour course → take notes → get stuck → search forums | Ask Claude → get tailored explanation → build immediately |
| Debug alone for hours | Explain error → get fix + understanding in seconds |
| Read docs hoping to understand | "Explain this like I'm a backend dev" → instant clarity |
| Build alone, hope it's right | Real-time pair programming and code review |
| Wait for course to cover your question | Ask exactly what you need, when you need it |
You skip hours of friction per concept.
This roadmap reflects the 2025 reality of AI engineering hiring:
| What Companies Want | What's Now Secondary |
|---|---|
| Ship LLMs to production | Training models from scratch |
| RAG pipelines that work | Custom deep learning architectures |
| LLM evaluation skills | Heavy classical ML focus |
| Cost & latency optimization | Research-only profiles |
| Strong backend engineering | Kaggle as primary signal |
| Product judgment | Feature engineering depth |
The question is no longer "Which model should I train?" It's "How do I integrate LLMs safely, efficiently, and at scale?"
Tier 1 — Start Growing (must-have):
├── RAG (embeddings, chunking, retrieval, vector DBs)
├── LLM APIs (Anthropic, OpenAI — tool use, structured outputs)
├── Backend skills (Python, APIs, async, error handling)
├── Prompt engineering (versioning, testing, guardrails)
└── Basic evaluation (how do you know it works?)
Tier 2 — Stand out (differentiators):
├── Advanced evaluation (golden datasets, A/B testing)
├── Cost optimization (caching, batching, model selection)
├── Agentic systems (planning, tool use, memory)
├── LLM security (prompt injection, PII, output filtering)
└── Production ops (monitoring, rollback, CI/CD for AI)
Tier 3 — Level up (senior/lead):
├── Product judgment (when NOT to use LLMs)
├── Fine-tuning (LoRA, when and why)
├── Multi-modal (vision, audio)
├── System design for AI (architecture decisions at scale)
└── Deep transformer understanding (for debugging, optimization)
┌─────────────────────────────────────────────────────────────────┐
│ MONTH 1: FOUNDATIONS + TRANSFORMERS │
│ ┌─────────────┐ ┌─────────────┐ │
│ │ Week 1-2 │ │ Week 3-4 │ │
│ │ ML Core + │ │ Transformers│ │
│ │ Embeddings │ │ Deep-Dive │ │
│ │ Project 1 │ │ Project 2 │ │
│ └─────────────┘ └─────────────┘ │
├─────────────────────────────────────────────────────────────────┤
│ MONTH 2: LLM ENGINEERING (THE CORE) │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ Week 5-6 │ │ Week 7-8 │ │ Week 9 │ │
│ │ LLM APIs + │ │ RAG │ │ Evaluation │ │
│ │ Prompting │ │ Systems │ │ + Agents │ │
│ │ Project 3 │ │ Project 4 │ │ Project 5 │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
├─────────────────────────────────────────────────────────────────┤
│ MONTH 3: PRODUCTION + SPECIALIZATION │
│ ┌─────────────┐ ┌─────────────┐ │
│ │ Week 10-11 │ │ Week 12 │ │
│ │ Production │ │ Specialize │ │
│ │ + Security │ │ + Portfolio │ │
│ │ Project 6 │ │ Polish │ │
│ └─────────────┘ └─────────────┘ │
└─────────────────────────────────────────────────────────────────┘
Learn math when you hit a concept that requires it, not upfront.
| When You Encounter | Learn | Resource |
|---|---|---|
| Embeddings, similarity | Dot products, cosine similarity | 3Blue1Brown Linear Algebra Ch 1-4 |
| Backpropagation | Chain rule, gradients | 3Blue1Brown Calculus Ch 1-4 |
| Evaluation metrics | Probability basics | StatQuest as needed |
Rule: Embeddings → learn dot products. Backprop → learn chain rule. Just-in-time, not just-in-case.
Goal: Understand ML evaluation, embeddings, and why things work — in 2 weeks, not 8.
| Focus | How to Learn |
|---|---|
| Evaluation metrics (precision, recall, F1, AUC) | Ask Claude to explain with examples from your domain |
| Train/test splits, overfitting | Kaggle Intro to ML micro-course (3-4 hours) |
| When to use ML vs rules vs LLMs | Discuss tradeoffs with Claude |
Build: Simple classifier with scikit-learn. Focus on evaluation, not the model.
| Focus | How to Learn |
|---|---|
| What embeddings are, how they encode meaning | What Are Word Embeddings? — Jay Alammar |
| Similarity metrics (cosine, dot product, euclidean) | Ask Claude to explain + show code |
| Embedding models comparison | Experiment with sentence-transformers |
Project 1: Build an embedding-based semantic search. Given a query, find similar documents. Visualize embeddings with t-SNE or UMAP. GitHub repo.
Key concepts checklist:
- Evaluation metrics: when to use which
- Overfitting and how to detect it
- What embeddings represent
- Similarity search basics
Goal: Understand how LLMs actually work — attention, tokenization, context windows — so you can debug and optimize.
| Focus | How to Learn |
|---|---|
| Self-attention mechanism | The Illustrated Transformer + ask Claude to clarify |
| Multi-head attention, positional encoding | Hugging Face NLP Course — Chapters 1-2 |
| Tokenization (BPE, token counts) | Experiment with different tokenizers in code |
Build: Tokenize various texts, count tokens, understand context limits hands-on.
| Focus | How to Learn |
|---|---|
| Pre-training vs fine-tuning vs RLHF | What Is ChatGPT Doing? — Wolfram |
| Inference parameters (temperature, top-p) | Experiment with Anthropic/OpenAI APIs |
| Fine-tuning basics | Hugging Face NLP Course — Chapters 3-4 |
Project 2: Fine-tune a small model (DistilBERT) on a classification task. Understand the training loop. GitHub repo.
Key concepts checklist:
- Self-attention intuition
- Tokenization and context windows
- Pre-training vs fine-tuning vs RLHF
- Temperature, top-p, sampling
Reading:
- "Attention Is All You Need" — skim for concepts, not math
- The Illustrated GPT-2
Goal: This is the core. RAG, agents, evaluation, prompt engineering. Where you'll spend 50% of your time.
| Focus | How to Learn |
|---|---|
| Anthropic API (messages, system prompts, tool use) | Anthropic API Docs + Anthropic Courses |
| Prompt patterns (few-shot, chain-of-thought, structured outputs) | Anthropic Prompt Engineering Guide |
| Tool use / function calling | Anthropic Cookbook examples |
Project 3: LLM app with structured outputs and tool use — an assistant that can search, calculate, call APIs, and return typed JSON. GitHub repo.
Key concepts checklist:
- System / user / assistant roles
- Few-shot prompting
- Chain-of-thought
- Structured outputs (JSON mode, tool use)
- Prompt versioning
| Focus | How to Learn |
|---|---|
| RAG architecture end-to-end | DeepLearning.AI: LangChain for LLM Application Dev |
| Chunking strategies | Experiment: fixed vs semantic, different sizes, overlap |
| Vector databases | Chroma (start here), Pinecone, Weaviate |
| Re-ranking, hybrid search | Implement and compare retrieval quality |
Project 4: Production-quality RAG system — PDF ingestion, smart chunking, retrieval with citations, answer generation. Measure retrieval quality. GitHub repo.
Key concepts checklist:
- Chunking: size, overlap, semantic vs fixed
- Vector DB: indexing, querying, filtering, metadata
- Retrieval metrics: precision, recall, MRR
- Re-ranking strategies
- Caching for embeddings
| Focus | How to Learn |
|---|---|
| LLM evaluation without ground truth | RAGAS, DeepEval |
| RAG metrics (faithfulness, relevance) | Build evaluation pipeline for Project 4 |
| Agent patterns (ReAct, tool use, memory) | DeepLearning.AI: Building Agentic RAG |
| MCP (Model Context Protocol) | MCP Docs |
Project 5: AI agent with multi-step reasoning, multiple tools, memory, and error handling. Add evaluation suite to Project 4. GitHub repo.
Key concepts checklist:
- Evaluation without ground truth
- RAG metrics: faithfulness, context precision
- Golden datasets
- ReAct pattern
- Agent memory (short-term, long-term)
- MCP basics
Reading:
- LLM Powered Autonomous Agents — Lilian Weng
- RAG paper
Goal: Ship reliable, cost-effective, secure AI applications. This separates demos from products.
| Focus | How to Learn |
|---|---|
| FastAPI for AI apps | FastAPI Tutorial — async, streaming |
| Docker | Docker Get Started |
| Streaming LLM responses | Implement in your API |
| Cloud deployment | AWS Lambda / GCP Cloud Run / Railway |
Build: Containerize and deploy Project 4 or 5 as an API with streaming.
| Focus | How to Learn |
|---|---|
| Token cost management | Build cost tracking into your app |
| Caching strategies (Redis) | Cache embeddings and repeated queries |
| Model routing (cheap → expensive) | Implement Haiku-first, Sonnet-fallback |
| LLM security | Prompt injection, PII handling, output filtering |
| Observability | LangSmith or Helicone |
Project 6: Production-deployed full stack — API + RAG + caching + cost tracking + security layers + monitoring + CI/CD. GitHub repo with deployment instructions.
Key concepts checklist:
- Async Python, streaming
- Docker containerization
- Token counting and cost calculation
- Caching strategies
- Model routing
- Prompt injection defense
- PII detection
- CI/CD for AI apps
- Monitoring and observability
Goal: Pick a direction, polish your portfolio, prepare for opportunities.
| Focus | Action |
|---|---|
| Choose specialization | RAG Systems, AI Agents, LLM Security, AI Infrastructure, or Fine-tuning |
| Portfolio polish | Clean READMEs, add diagrams, record demo videos |
| Write about your learning | Blog post or detailed GitHub docs |
| Open source | One PR to LangChain, Anthropic Cookbook, or similar |
Specialization options:
| Track | What to Build |
|---|---|
| RAG Systems | Advanced retrieval with re-ranking, evaluation dashboard |
| AI Agents | Multi-agent system, complex tool orchestration |
| LLM Security | Red team toolkit, guardrail library |
| AI Infrastructure | LLM gateway with routing, caching, observability |
| Fine-tuning | LoRA fine-tune for specific domain, evaluation suite |
Monday: Study — docs, courses, papers (3 hrs)
Tuesday: Study + hands-on exercises (3 hrs)
Wednesday: Build — project work with Claude (4 hrs)
Thursday: Build — project work with Claude (4 hrs)
Friday: Build — finish weekly milestone (3 hrs)
Saturday: Review + math if needed + reading (2 hrs)
Sunday: Rest or light exploration
# Learning a concept
"Explain [embeddings] like I'm a backend dev who knows Python
but is new to ML. Give me a concrete code example."
# Building
"I want to build [RAG system]. Walk me through the architecture
first, then let's implement step by step."
# Debugging understanding
"I don't understand why [attention] works. What's the intuition?
Skip the math, give me the mental model."
# Code review
"Review this [RAG implementation]. What would a senior AI engineer
at Anthropic change? Be specific."
# Unstuck
"I'm getting [error]. Here's my code. What's wrong and why?"| # | Project | What It Demonstrates |
|---|---|---|
| 1 | Semantic search with embeddings | Embeddings, similarity, evaluation basics |
| 2 | Fine-tuned classifier | Transformers, training loop, Hugging Face |
| 3 | LLM app with tools | API integration, structured outputs, tool use |
| 4 | RAG system + evaluation | Chunking, retrieval, vector DB, metrics |
| 5 | AI agent with memory | Multi-step reasoning, planning, error handling |
| 6 | Production full stack | Docker, API, caching, security, monitoring, cloud |
| Week | Milestone | Proof |
|---|---|---|
| 2 | Understand embeddings, built semantic search | Project 1 on GitHub |
| 4 | Explain transformers, fine-tuned a model | Project 2 on GitHub |
| 6 | Build LLM apps with tools and structured outputs | Project 3 on GitHub |
| 8 | Build production-quality RAG | Project 4 on GitHub |
| 9 | Build agents, evaluate LLM systems | Project 5 on GitHub |
| 11 | Deploy secure, cost-optimized AI app | Project 6 on GitHub |
| 12 | Specialization chosen, portfolio polished | All projects documented |
- Embeddings and similarity search
- RAG: chunking, retrieval, vector databases
- LLM APIs: Anthropic, OpenAI — structured outputs, tool use
- Prompt engineering: few-shot, CoT, versioning
- Basic evaluation: know if your system works
- Advanced evaluation: RAGAS, golden datasets
- Cost optimization: caching, model routing
- Agents: ReAct, tool use, memory, MCP
- LLM security: prompt injection, PII
- Production: Docker, CI/CD, monitoring
- Product judgment: when NOT to use LLMs
- Fine-tuning: LoRA, dataset curation
- System design at scale
- Open source contributions
- Anthropic API Docs
- Anthropic Prompt Engineering Guide
- Anthropic Courses
- Anthropic Cookbook
- Model Context Protocol (MCP)
- LangChain Documentation
- Hugging Face NLP Course — Chapters 1-4 only
- DeepLearning.AI Short Courses — LangChain, RAG, Agents
- Kaggle Intro to ML — 3-4 hours
- Jay Alammar — Illustrated Transformer, GPT-2, BERT, Word2Vec
- Lilian Weng — LLM Agents, RAG
- 3Blue1Brown — Math when needed
- "Attention Is All You Need" — understand the concepts
- "RAG for Knowledge-Intensive NLP" — understand the pattern
| Traditional (2020-2023) | This Plan (2025, 3 months) |
|---|---|
| 8+ weeks on classical ML | 2 weeks, focused on evaluation + embeddings |
| 12 weeks on deep learning | 2 weeks, transformers only |
| First LLM project at week 21 | First LLM project at week 5 |
| Learn alone, get stuck | Learn with Claude, build faster |
| 10-12 months | 12 weeks |
| Courses then projects | Projects from day 1 |
Week 1-2: Foundations + Embeddings → Project 1
Week 3-4: Transformers → Project 2
Week 5-6: LLM APIs + Prompting → Project 3
Week 7-8: RAG Systems → Project 4
Week 9: Evaluation + Agents → Project 5
Week 10-11: Production + Security → Project 6
Week 12: Specialize + Polish → Portfolio ready
By week 12: 6 projects on GitHub, production deployment experience, evaluation skills, and a specialization direction.
Note: This is aggressive but achievable with focused effort and AI-assisted learning. The key is building every week, not just consuming content. You learn by doing, and Claude accelerates the doing.