A complete, battle-tested 12–18 month roadmap to go from zero computer science knowledge to a professional AI Developer & Prompt/Context Engineer — crafted for curious minds with strong reasoning. No CS degree required.
Click to expand / collapse
| # | Section | Description |
|---|---|---|
| 01 | 🧠 Foundation Mindset & Meta-Learning | Science-backed techniques to learn 2–3× faster |
| 02 | 💻 Computer Science Fundamentals | Core CS: logic, data, algorithms, internet, OS |
| 03 | 🐍 Python Programming | The language of AI — from zero to confident |
| 04 | 📐 Mathematics for ML/AI | Stats, linear algebra, calculus — simplified |
| 05 | 🤖 Machine Learning | Core ML concepts, algorithms & workflow |
| 06 | 🧬 Deep Learning & Neural Networks | CNNs, RNNs, Transformers explained simply |
| 07 | 🔮 AI & Large Language Models | How ChatGPT, Claude, Gemini actually work |
| 08 | ✍️ Prompt Engineering — Complete Mastery | Zero-shot, few-shot, CoT, RAG, agents & more |
| 09 | 🏗️ Context Engineering (Advanced) | System prompts, memory, long-context mastery |
| 10 | 🛠️ AI Developer Toolkit & Projects | Tools, APIs, portfolio & real-world projects |
| 11 | 🗺️ Career Roadmap & Timeline | Month-by-month 12–18 month study plan |
| 12 | 📚 Resources, Books & Communities | Best free & paid resources handpicked for you |
| 13 | ⚙️ Fine-Tuning LLMs | LoRA, QLoRA, PEFT — customize any model |
| 14 | 🔍 Embeddings & Semantic Search | The technology powering RAG & AI memory |
| 15 | 🎨 Multimodal AI & Open Source LLMs | Vision+text models and running AI locally |
| 16 | 🛡️ AI Safety, Cost & Model Selection | Build responsibly, efficiently, strategically |
| 17 | 🐛 Failure Patterns & Prompt Versioning | Top 10 failure modes + treat prompts like code |
| 18 | 💼 Career Deep Dive | Freelance rates, interview prep, portfolio |
| 19 | 📖 Glossary | Every AI/ML term defined in plain English |
| 20 | ✅ Progress Tracker | Check off your milestones week by week |
"Install a better OS in your brain before running complex software."
Before diving into code or AI theory, mastering how to learn gives you a 2–3× speed advantage.
| Technique | What It Does |
|---|---|
| 🃏 Spaced Repetition | Review at increasing intervals (1→3→7→21 days). Tool: Anki |
| 🔁 Active Recall | Close the book, recall from scratch — 2× more effective than re-reading |
| 🧑🏫 Feynman Technique | Explain it to a 10-year-old → find gaps → re-learn those gaps |
| 🗺️ Mind Mapping | Draw concept networks (Miro, MindMeister). Matches how your brain works |
| 🔨 Project-Based Learning | Build something real every week. Theory without practice fades in 48 hrs |
| 🍅 Pomodoro Technique | 25-min focus sprints → 5-min break → repeat × 4 → 30-min break |
| 😴 Sleep & Review Cycle | Review before sleep — deep sleep consolidates memories for free |
| 🔀 Interleaving | Mix topics in one session. Feels harder, creates stronger connections |
🌅 Morning (30 min) → Anki flashcard review
📖 Session 1 (90 min) → Learn new concept + Feynman explanation in notebook
💻 Session 2 (90 min) → Hands-on coding / practice problems
🌆 Evening (20 min) → Mind map the day's learning
🌙 Before bed (10 min) → Recall the 3 most important things you learned
You don't need a CS degree. You need the CORE IDEAS.
🔢 How Computers Think
- Binary & Bits — Everything is 0s and 1s. Text, images, video — all binary
- CPU vs GPU — CPU executes instructions; GPU runs thousands of parallel calculations (crucial for AI)
- RAM vs Storage — RAM = short-term memory; Hard Drive = long-term memory
- Operating System — Linux is the OS of AI servers — learn the basics
🗂️ Data Structures
- Arrays/Lists —
[1, 2, 3, 4]— Foundation of everything in AI - Dictionaries —
{'name': 'Claude', 'type': 'AI'}— Used in every ML pipeline - Trees & Graphs — Decision trees in ML are literally tree data structures
- Matrices/Tensors — The CORE data structure of all AI/ML computations
🌐 Internet & Networking
- HTTP/HTTPS — GET (fetch data), POST (send data) — you'll use this daily
- APIs — Programs talking to each other. OpenAI API = send text, get AI response
- JSON — Universal data format for APIs:
{'message': 'hello', 'model': 'gpt-4'} - REST API — Standard way to design APIs. You'll consume AI APIs via REST constantly
🗄️ Databases & Version Control
- SQL —
SELECT, INSERT, UPDATE, DELETE— 6 commands cover 90% of needs - Vector Databases — NEW & critical for AI. Stores embeddings. Tools: Pinecone, ChromaDB
- Git — Track code changes.
git init, add, commit, push, pull— master just these 5 - GitHub — Your professional portfolio as an AI developer
⏱️ Recommended Time: 3–4 Weeks | 📺 Resources: CS50x (Harvard, FREE), freeCodeCamp
Python is THE language of AI. 95% of all ML/AI code is written in Python.
🟢 Level 1 — Absolute Basics
# Variables & Data Types
x = 5 # integer
name = 'Claude' # string
pi = 3.14 # float
flag = True # boolean
# Functions — building blocks of AI
def greet(name):
return f'Hello {name}'
# Lists & Dictionaries
data = [1, 2, 3]
info = {'key': 'value'}🟡 Level 2 — Intermediate Python
# List Comprehensions
squares = [x**2 for x in range(10)]
# Error Handling
try:
result = int(user_input)
except ValueError:
print("Invalid input")
# Classes & OOP
class AIModel:
def __init__(self, name):
self.name = name🔴 Level 3 — AI-Specific Python
import numpy as np # Matrix operations
import pandas as pd # Data analysis
import requests # Call web APIs
import json # Parse API responses
import os # Environment variables (API keys)
# Call Claude API
key = os.getenv('ANTHROPIC_API_KEY')⏱️ Recommended Time: 6–8 Weeks | 📺 Resources: Python.org, Automate the Boring Stuff (FREE)
You don't need to be a mathematician. You need enough math to UNDERSTAND what ML algorithms are doing.
🎯 The Secret: Learn math ALONGSIDE the AI algorithm that uses it.
When studying Linear Regression → learn Statistics.
When studying Neural Nets → learn Calculus.
| Domain | Key Concepts | Why It Matters |
|---|---|---|
| 📊 Statistics | Mean, Std Dev, Probability, Bayes' Theorem | AI models output probabilities constantly |
| 🔢 Linear Algebra | Vectors, Matrices, Dot Product | Every neural net layer = matrix multiply |
| 📈 Calculus | Derivatives, Gradients, Chain Rule | This is HOW neural networks learn |
⏱️ Recommended Time: 4–5 Weeks | 📺 Resources: 3Blue1Brown YouTube, Khan Academy, StatQuest
Teaching computers to learn from data instead of being explicitly programmed.
┌─────────────────┐ ┌──────────────────┐ ┌─────────────────────┐
│ SUPERVISED │ │ UNSUPERVISED │ │ REINFORCEMENT │
│ LEARNING │ │ LEARNING │ │ LEARNING │
│ │ │ │ │ │
│ Labeled data │ │ Find hidden │ │ Learn by trial & │
│ Spam detection │ │ patterns │ │ error with rewards │
│ Price prediction│ │ Clustering │ │ Game AI, Robots │
└─────────────────┘ └──────────────────┘ └─────────────────────┘
⚙️ The Standard ML Workflow
1️⃣ Collect Data → Gather relevant dataset
2️⃣ Explore (EDA) → Pandas & Matplotlib. Find patterns & outliers
3️⃣ Clean Data → Handle missing values. "Garbage in = garbage out"
4️⃣ Feature Engineer → Transform raw data into useful model features
5️⃣ Split Data → Train (80%) | Validation (10%) | Test (10%)
6️⃣ Train Model → model.fit(X_train, y_train)
7️⃣ Evaluate → Accuracy, Precision, Recall, F1, RMSE
8️⃣ Tune & Improve → Adjust hyperparameters, try different algorithms
9️⃣ Deploy → FastAPI, Streamlit, or Flask
⏱️ Recommended Time: 6–8 Weeks | 📺 Resources: Scikit-learn docs, Kaggle Learn, Andrew Ng's ML Course
The technology behind image recognition, voice assistants, translation, and LLMs.
🏛️ Key Architectures
| Architecture | Best For |
|---|---|
| FNN (Feedforward) | Tabular data |
| CNN | Images — detects edges, shapes, faces |
| RNN / LSTM | Sequences, time-series, speech |
| 🌟 Transformer | THE revolution — powers ALL modern LLMs |
| GAN | Image generation, synthetic data |
| Autoencoder | Anomaly detection, embeddings |
⚡ The Transformer — Most Important Architecture
Self-Attention → Each token 'looks at' ALL other tokens for context
Multi-Head → Run attention multiple times in parallel
Positional Enc. → Adds position info to token embeddings
Encoder → Reads & understands input (BERT, T5)
Decoder → Generates output token by token (GPT series)
Scaling Law → More params + data + compute = better performance
⏱️ Recommended Time: 6–8 Weeks | 📺 Resources: fast.ai, Deep Learning Specialization, Andrej Karpathy YouTube
You don't need to build one — but you must understand the engine to drive it masterfully.
| Concept | Plain English Explanation |
|---|---|
| 🔤 Tokenization | LLMs read tokens (~¾ of a word). Context windows measured in tokens |
| 🌐 Embeddings | Words → high-dimensional vectors. Similar words are geometrically close |
| 🏋️ Pre-training | Trained on trillions of tokens to predict the next token. Costs millions |
| 🎯 RLHF | Human feedback makes models helpful, harmless, and honest |
| 📏 Context Window | Max text the model can "see" at once. Claude = up to 200K tokens |
| 🌡️ Temperature | 0.0 = focused/deterministic. 1.0 = creative/random |
OpenAI → GPT-4o, o1, o3 (via openai library)
Anthropic → Claude 3.5 Sonnet/Opus (via anthropic library) ← Often best at instructions
Google → Gemini 1.5 Pro, Ultra (via google-generativeai)
Meta → Llama 3 (open source) Run locally for free
Mistral → Mistral-7B, Mixtral Highly efficient open source
Part science (understanding model behavior), part art (creative problem framing), part UX design.
🎯 Core Techniques
| Technique | When to Use |
|---|---|
| Zero-Shot | Simple, well-defined tasks |
| Few-Shot | Specific formats, tone matching, classification |
| Chain-of-Thought (CoT) | Math, logic, complex multi-step reasoning |
| Role/Persona Prompting | Expert consultations, specific writing styles |
| Self-Consistency | High-stakes factual questions, math |
| Tree of Thoughts (ToT) | Creative brainstorming, strategic planning |
| ReAct | Agentic tasks with tool use |
| RAG | Grounding answers in real data, beating hallucinations |
┌──────────────────────────────────────────────────────────────────┐
│ [ROLE] You are a [expert] with [experience]... │
│ [CONTEXT] The situation is [background]. Goal is [end]... │
│ [TASK] Your task is to [action verb] [object]... │
│ [FORMAT] Respond in [JSON/bullets/table]. Include [X]... │
│ [CONSTRAINTS] Do NOT [exclusion]. Max [limit]. Use [tone]... │
│ [EXAMPLES] Here are 2-3 ideal examples: [examples]... │
└──────────────────────────────────────────────────────────────────┘
What separates junior AI developers from senior AI architects.
🧩 Memory Architecture Types
In-Context Memory → Current window. Fast but temporary
External Memory → Vector DB (Pinecone, ChromaDB). Long-term retrieval
Summary Memory → Compress conversation history to save tokens
Entity Memory → Track key entities across conversations
Episodic Memory → Store full interaction summaries for personalization
💰 Token Budget Planning
System Prompt ████░░░░░░ 10%
History ███░░░░░░░ 30%
Retrieved Data ███░░░░░░░ 30%
Output Space ███░░░░░░░ 30%
💡 Order matters: Put the most critical instructions FIRST and LAST — models have primacy & recency bias.
# Essential Libraries
pip install langchain # #1 LLM app framework
pip install llama-index # Specialized for RAG
pip install openai # GPT-4 access
pip install anthropic # Claude access
pip install streamlit # Build AI web apps in pure Python
pip install fastapi # High-performance AI backends
pip install chromadb # Local vector database
pip install sentence-transformers # Free local embeddings🟢 BEGINNER
├── Personal AI Chatbot (system-prompted Claude via Streamlit)
├── Document Q&A App (PDF upload + basic RAG with ChromaDB)
├── Prompt Template Library (web UI to store & test prompt templates)
└── AI Writing Assistant (grammar + tone + summarizer)
🟡 INTERMEDIATE
├── Multi-Source RAG System (50+ docs, hybrid search, Q&A chatbot)
├── AI Research Assistant (agent that searches web & synthesizes)
├── Code Review Bot (GitHub Actions + AI PR reviews)
└── Customer Support Bot (multi-turn + memory + knowledge base)
🔴 ADVANCED / SENIOR-LEVEL
├── Full AI SaaS Application (auth + billing + AI core feature)
├── Multi-Agent Pipeline (researcher + writer + fact-checker)
├── AI Evaluation Framework (automated prompt quality testing)
└── Fine-tuned Specialist Model (domain-specific open-source model)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
MONTHS 1–2 │ 🏗️ FOUNDATION
│ CS50x + Python basics + Git + API calls
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
MONTHS 3–4 │ 🐍 PYTHON & MATH
│ Intermediate Python + NumPy + Pandas + Stats
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
MONTHS 5–7 │ 🤖 ML FUNDAMENTALS
│ Andrew Ng Specialization + Kaggle competitions
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
MONTHS 8–10 │ 🧬 DEEP LEARNING & AI
│ fast.ai + PyTorch + Transformers + HuggingFace
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
MONTHS 11–13 │ 🔮 LLMs & PROMPT ENGINEERING
│ LangChain + LlamaIndex + 5 portfolio projects
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
MONTHS 14–16 │ 🏗️ CONTEXT ENGINEERING & ADVANCED
│ System prompt architecture + FastAPI + Docker
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
MONTHS 17–18 │ 🚀 JOB SEARCH & LAUNCH
│ 5 apps/week + freelance + open source contributions
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🎯 TARGET │ Job offer OR 3+ freelance clients. YOU MADE IT! 🎉
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
| Resource | What You'll Learn |
|---|---|
| CS50x — Harvard | Best CS foundations course ever made |
| fast.ai | Practical deep learning — results first |
| Andrew Ng — ML Specialization | Industry-standard ML foundation (audit free) |
| 3Blue1Brown YouTube | Visual math masterpieces |
| Andrej Karpathy YouTube | Build neural nets from scratch |
| HuggingFace Course | Official NLP & transformers course |
| StatQuest | ML explained with humor & clarity |
| Book | Why Read It |
|---|---|
| Python Crash Course — Eric Matthes | Best beginner Python book |
| Hands-On ML — Aurélien Géron | The practical ML/DL bible |
| Deep Learning — Goodfellow et al. | FREE at deeplearningbook.org |
| Designing Data-Intensive Applications | For serious AI data pipelines |
OpenAI API → platform.openai.com (GPT-4o)
Anthropic API → console.anthropic.com (Claude — best instruction following)
Google AI → aistudio.google.com (Gemini — generous free tier)
Groq API → console.groq.com (blazing-fast open source inference)
HuggingFace → huggingface.co (1000s of free models)
Bake your instructions and style directly into the model weights — like training an employee once instead of giving them a manual every day.
┌────────────────────────────────────────────────────────────┐
│ FINE-TUNE DECISION MATRIX │
├────────────────────────────────────────────────────────────┤
│ Use PROMPTING when → <100 examples, diverse tasks │
│ Use FINE-TUNING when → 500+ consistent examples needed │
│ Use RAG when → Knowledge changes frequently │
│ Use ALL THREE when → Production-grade domain AI │
└────────────────────────────────────────────────────────────┘
| Method | Memory | Best For |
|---|---|---|
| Full Fine-tuning | 80GB+ VRAM | Rarely practical |
| LoRA | ~16GB | Most popular PEFT method |
| QLoRA | ~8–12GB | Fine-tune 7B on a single consumer GPU 🎯 |
| Prefix Tuning | ~4GB | Ultra-lightweight, fastest |
# QLoRA Fine-tuning — The Accessible Way
pip install transformers trl peft bitsandbytes unsloth
# Step-by-step workflow:
# 1. Collect 100–5000 high-quality instruction-response pairs
# 2. Format as {instruction, input, output} JSON
# 3. Choose base model: Llama 3.1 8B / Mistral 7B / Phi-3
# 4. Configure LoRA: rank=16, alpha=32
# 5. Train with SFTTrainer on Google Colab A100 (free tier!)
# 6. Evaluate on held-out test set
# 7. Merge & deploy via Ollama
The unsung heroes of modern AI applications. Every RAG system is built on embeddings.
TEXT → [Embedding Model] → [0.23, -0.87, 0.45, ... 1536 numbers]
"dog" and "puppy" → vectors CLOSE together ✅
"dog" and "spacecraft" → vectors FAR apart 📡
"King - Man + Woman" → ≈ "Queen" ✨
INDEXING PHASE (once):
Documents → Chunk (256–512 tokens) → Embed → Store in Vector DB
RETRIEVAL PHASE (every query):
User Query → Embed → Search Vector DB → Get Top-K Chunks
GENERATION PHASE:
System Prompt + Retrieved Chunks + User Query → LLM → Grounded Answer
| Model | Cost | Best For |
|---|---|---|
text-embedding-3-small (OpenAI) |
$0.02/M tokens | Best quality/cost ratio |
voyage-3 (Anthropic/Voyage) |
Paid | Top-ranked on MTEB benchmark |
bge-m3 (HuggingFace) |
FREE | Multilingual, runs locally |
nomic-embed-text (HuggingFace) |
FREE | Excellent open-source, runs on CPU |
| Model | Strengths |
|---|---|
| GPT-4o | Text + image + audio. Most capable via API |
| Claude 3.5 Sonnet | Excellent at charts, diagrams, screenshots, handwriting |
| Gemini 1.5 Pro | Text + image + audio + video. 1M token context |
| LLaVA | Open-source vision-language. Run locally |
# Install Ollama (Mac/Windows/Linux — one click)
curl -fsSL https://ollama.com/install.sh | sh
# Pull and run any model instantly
ollama pull llama3.1 # Download 8B model (~4GB)
ollama run llama3.1 # Start chatting immediately
ollama run mistral # Or Mistral
ollama run phi3 # Or Microsoft Phi-3
# Use as OpenAI-compatible API
# Runs on localhost:11434 — drop-in replacementimport ollama
response = ollama.chat(model='llama3.1', messages=[
{'role': 'user', 'content': 'Explain transformers simply'}
])
print(response['message']['content'])
| Task | Best Model | Why |
|---|---|---|
| Complex reasoning | Claude 3.5 Sonnet / o1 | Best instruction following |
| Code generation | GPT-4o / Claude 3.5 | Both excel at code |
| High-volume simple tasks | GPT-4o-mini / Claude Haiku | 10–20× cheaper |
| Long documents (100K+) | Claude 3.5 / Gemini 1.5 Pro | Best long-context recall |
| Vision/image analysis | GPT-4o / Claude 3.5 Sonnet | Both excellent |
| Privacy-sensitive data | Llama 3.1 (local via Ollama) | Data never leaves your machine |
| Embeddings for RAG | text-embedding-3-small | Best quality-to-cost ratio |
Model Routing → Route 90% simple tasks to cheap models. Saves 60–80% costs
Prompt Caching → Anthropic/OpenAI cache repeated system prompts at 10% cost
Batch API → 50% discount for non-real-time workloads
Token Counting → Use tiktoken before sending. Never overspend
Output Compression → Instruct: "Respond in under 100 words." Output tokens = 2–3× input cost
Response Caching → Cache identical queries with Redis. 20% repeat queries = 20% cost cut
| # | Pattern | Fix |
|---|---|---|
| 01 | Vague Instructions | Specify length, audience, format explicitly |
| 02 | Missing Context | Always provide role, goal, background |
| 03 | Ambiguous Pronouns | Use explicit nouns: "Document A" vs "it" |
| 04 | Instruction Overload | Use numbered lists; chain across separate calls |
| 05 | Wrong Temperature | Factual → 0.0–0.3; Creative → 0.7–1.0 |
| 06 | No Output Format | Always specify format + provide an example |
| 07 | Negative Instructions | Reframe: "Focus on X" not "Don't mention Y" |
| 08 | Sycophancy | Instruct: "If my premise is wrong, say so directly" |
| 09 | Context Poisoning | Start fresh conversations for new tasks |
| 10 | Prompt Drift | Pin model versions; run regression tests after updates |
/prompts
├── system_prompt_v1.0.txt ← version controlled in Git
├── system_prompt_v1.1.txt ← every change = commit
├── system_prompt_v2.0.txt ← semantic versioning
└── CHANGELOG.md ← document what changed & why
# Every prompt change documents:
# Date | Author | Version | Change | Reason | Test Results
| Level | Hourly | Project | Monthly Retainer |
|---|---|---|---|
| Beginner (0–6 mo) | $25–$50/hr | $200–$800 | $500–$1,500 |
| Intermediate (6–18 mo) | $50–$100/hr | $800–$3,000 | $1,500–$4,000 |
| Advanced (18+ mo) | $100–$200/hr | $3,000–$15,000 | $4,000–$12,000 |
| Senior / Specialist | $200–$400/hr | $15,000–$50,000 | $10,000–$30,000 |
Prompt Engineer AI Engineer LLM Engineer
AI/ML Engineer Generative AI Developer NLP Engineer
AI Solutions Architect Context Engineer AI Product Engineer
ML Platform Engineer Foundation Model Engineer AI Integration Developer
💡 Salary range (US, full-time): Junior $80–120K → Mid $120–180K → Senior $180–280K → Staff $280K+
- GitHub with daily green squares (consistency visible to hiring managers)
- 3–5 deployed, live apps (HuggingFace Spaces is free!)
- A working RAG project — #1 thing hiring managers look for
- A multi-agent / tool-use project
- Before/after prompt engineering case study
- 1–2 blog posts explaining what you built (Medium, dev.to)
- An automated prompt evaluation framework (rare & impressive)
Click to expand — 36+ AI/ML terms defined in plain English
| Term | Plain English Definition |
|---|---|
| Agent | An LLM that autonomously plans and executes multi-step tasks using tools |
| Attention | Mechanism letting each token "look at" all other tokens for context |
| Backpropagation | Algorithm that flows error backwards to update neural network weights |
| BERT | Google's encoder-only Transformer — great for classification & embeddings |
| Chunking | Splitting documents into smaller pieces for embedding and RAG retrieval |
| Context Window | Max tokens an LLM can process at once. Claude = up to 200K |
| CoT | Chain-of-Thought — ask model to reason step-by-step before answering |
| Embeddings | Vectors capturing semantic meaning. Similar meanings = similar vectors |
| Few-Shot | Providing 2–5 input/output examples in the prompt to show the pattern |
| Fine-tuning | Continue training a pre-trained model on your own domain-specific data |
| Gradient Descent | Iteratively adjust weights in the direction that reduces prediction error |
| Hallucination | When an LLM generates confident but factually incorrect information |
| LLM | Large Language Model — billions of parameters, trained on massive text |
| LoRA | Adds small trainable matrices to frozen model for cheap fine-tuning |
| Multimodal | AI that processes multiple data types: text + images + audio + video |
| Overfitting | Model memorizes training data, fails on new unseen data |
| PEFT | Parameter-Efficient Fine-Tuning — update only a fraction of parameters |
| Prompt Injection | Attack where malicious input overrides your system prompt |
| QLoRA | Quantized LoRA — fine-tune large models on consumer GPUs |
| RAG | Retrieval-Augmented Generation — LLM + knowledge base retrieval |
| RLHF | Reinforcement Learning from Human Feedback — makes models helpful & safe |
| Self-Attention | Each position attends to all others simultaneously |
| Semantic Search | Find documents by meaning, not just keyword matches |
| System Prompt | Hidden instructions that define the LLM's role, rules, and behavior |
| Temperature | Controls output randomness. 0.0 = deterministic, 1.0 = creative |
| Token | Basic unit LLMs process. Roughly ¾ of an average English word |
| Transformer | The 2017 architecture powering ALL modern LLMs (GPT, Claude, Gemini) |
| Vector Database | Specialized DB for storing and searching high-dimensional embeddings |
| Zero-Shot | Task with no examples — relying purely on pre-trained knowledge |
📋 Click to expand your full progress tracker
- Set up Anki and created first 20 flashcards
- Installed Python and VS Code
- Created GitHub account and first repository
- Started CS50x — completed Week 0
- Completed CS50x Weeks 0–3
- Made first API call and parsed JSON response
- Learned core Git commands
- Can explain: CPU vs GPU, HTTP, REST API, JSON
- Level 1 Python: variables, loops, functions, lists, dicts
- Level 2 Python: OOP, file handling, error handling
- NumPy array operations and matrix math
- Load and analyze CSV with Pandas
- Called Claude or OpenAI API from Python
- Built a working chatbot loop
- Khan Academy Statistics basics
- 3Blue1Brown Essence of Linear Algebra (all 15 videos)
- Understand vectors, matrices, dot product
- Understand gradient descent conceptually
- Can explain backpropagation in plain English
- Completed Andrew Ng ML Specialization
- Kaggle Titanic challenge end-to-end
- Reached top 30% on any Kaggle competition
- Know when to use each core ML algorithm
- Completed fast.ai Part 1
- Built a CNN image classifier in PyTorch
- Fine-tuned a BERT model on custom task
- Can explain Transformer self-attention in plain English
- Used HuggingFace to load a pre-trained model
- Can explain tokenization, embeddings, RLHF, context windows
- Practiced all 8 prompting techniques
- Built a working RAG system with ChromaDB + LangChain
- Built an AI agent that uses at least 2 tools
- 3 beginner + 2 intermediate portfolio projects complete
- Mastered context engineering + memory systems
- Deployed at least 1 AI app publicly
- LinkedIn profile updated with AI projects
- Applied to first 5 AI developer roles
- Joined at least 2 AI communities
- First freelance client OR job offer received 🎉
| Principle | What It Means |
|---|---|
| 🧠 Reasoning > Memorization | Understand WHY — don't memorize HOW |
| ⚡ Bias Toward Action | For every hour you consume, spend one hour CREATING |
| 🌱 Embrace Being a Beginner | Confusion IS the learning |
| 📅 Consistency Beats Intensity | 2 hrs/day × 18 months beats weekend marathons |
| 📢 Learn in Public | Tweet, blog, post. Build your brand while you build skills |
| 🎯 Specialize to Stand Out | Domain expert + AI skills = 5× more valuable |
| 🔭 Stay Curious | AI evolves weekly. Maintain a mental map of the field |
🚀 Start Today. Open a Browser. Go to cs50.harvard.edu. Press Play.
Made with ❤️ for curious minds with strong reasoning — no CS background required.
Every expert was once where you are right now.