technology
160 curated learning paths about technology. Each path delivers daily 5-minute drops to build real knowledge over time.
📈Big O Intuition
Stop treating Big O as math you memorized for an interview — build the intuition to spot O(n²) disasters, pick the right data structure without thinking, and rewrite a slow function from O(n²) to O(n) in under five minutes.
🐍Python Decorators Introduction
Build one mental model for Python decorators that covers closures, argument passing, functools.wraps, and stacking — then ship a working caching or logging decorator from scratch in under 30 lines.
🦀Rust Lifetimes Explained
Stop reading `'a` as line noise and start reading it as scope arithmetic — one failing snippet at a time — until you can thread lifetimes through a small parser or iterator adapter without fighting the borrow checker.
☸️Kubernetes Core Concepts
Stop drowning in 30+ resource types. Build the mental model one primitive at a time -- pods, deployments, services, ingress, config -- then deploy a real app with rolling updates and health checks.
💻Elixir Pattern Matching
Stop reading `=` as assignment and start using it as Elixir's core flow-control tool — through function heads, guards, and `with` — until you can rewrite a tiny command parser without a single `if`.
🔐OAuth 2.0 Flows Explained
Understand every OAuth 2.0 flow — auth code, PKCE, client credentials, device — by name, by purpose, and by threat model, then ship a minimal client you can defend on a security review.
🦀Master Rust Error Handling with Result, ? and thiserror
Stop reaching for unwrap() and panic!. Learn Rust's error-as-value model, then wield Result, ?, anyhow, and thiserror well enough to design a clean error hierarchy for a small CLI.
🔗GraphQL Schema Design
Master the schema patterns that separate elegant GraphQL APIs from production nightmares — from connection-based pagination to dataloader batching — by designing one end-to-end product schema along the way.
🦀Rust Traits and Generics
Stop reading Rust traits as 'interfaces with extra steps' and start using them as composable behavior contracts — until you can design a trait-based plugin system with blanket implementations that generates whole APIs from a single impl block.
🔴TDD Workflow Explained
Stop hearing 'red-green-refactor' as a slogan and start feeling it as a five-minute rhythm — drill ten kata cycles, connect TDD to design and coverage, then build a small feature strictly test-first.
🌳Trees and Binary Search Trees
Stop confusing BFS with DFS, in-order with pre-order, and balanced with not-quite. Build the tree intuition that lets you draw any node-and-edge problem on a whiteboard and solve five classic interview questions without freezing.
🔐Authentication vs Authorization
Stop conflating authentication and authorization — define each precisely, reason about the threats specific to each, and design authorization for a multi-tenant SaaS feature you can defend on a security review.
⛓️CI/CD Pipeline Fundamentals
Build a working mental model of CI/CD -- stages, gates, artifacts, environments, rollbacks -- then wire up a real GitHub Actions pipeline and design one for a multi-env deploy you actually own.
🗂️Database Indexing Explained
Stop adding indexes by trial and error and start designing them from first principles — see why B-trees beat full scans for range queries, read EXPLAIN plans like a pro, and index a real schema without slowing down every write.
🗺️Hash Maps from Scratch
Stop using dict, set, and HashMap as black boxes — build one from scratch in fourteen days, see exactly how hashing turns keys into bucket indices, and learn why your map slows to a crawl when load factor crosses 0.75.
⚡Async/Await Patterns
Stop sprinkling await everywhere and writing async code that's slower than the sync version. Build the intuition to spot accidentally-sequential awaits, handle errors and cancelation cleanly, and ship a concurrent fetcher with retries you actually trust.
🗄️Database Normalization Basics
Stop memorizing normal forms abstractly and start using them as design tools — see exactly why redundancy creates update anomalies, walk a messy table through 1NF, 2NF, and 3NF with real before/after schemas, then design a production-ready schema and defend every table you create.
💻Functional Programming Fundamentals
Stop treating FP like an ideology and start using its cheap wins — pure functions, immutability, map/filter/reduce, and composition — until you can rewrite a small imperative program in clean functional style.
🔭Observability: The Three Pillars
Build the mental model that turns three noisy data sources — metrics, logs, and traces — into a single evidence trail, then design an observability plan for a real service.
🐚Linux Shell Essentials
Stop copy-pasting shell commands you don't understand. Build the mental model of files, processes, and pipes — then compose grep, awk, and xargs into a maintenance script with real error handling.
🐢SQL Query Optimization
Stop guessing why a query is slow and start reading its plan like a story — see how the planner picks scans, joins, and orders, then take a real production query from minutes to milliseconds by reasoning from the plan, not from superstition.
🧪Unit vs Integration Testing
Stop arguing about whether something is a unit or integration test — get a sharp shared vocabulary, write the same feature at three test levels, and walk away with a written test strategy for a real service.
🔗Linked Lists from Scratch
Stop memorizing linked-list operations as recipes. Build the pointer intuition that lets you draw any node-and-arrow problem on a whiteboard and solve five classic interview questions without losing your place mid-traversal.
🧠C++ Memory Management Basics
Trade segfaults and double-frees for ownership you can reason about. By drop 14 you'll ship a small RAII resource wrapper that handles exceptions without leaking — and you'll know exactly why unique_ptr is the default and shared_ptr the exception.
☕Java Generics and Wildcards
Stop sprinkling `?` until the compiler stops yelling, and start designing Java generics on purpose — one PECS rule per drop, ending with a generic utility class whose variance you can defend in code review.
🐳Docker Containers Basics
Build the mental model first, then the commands — from containers vs VMs through images, layers, volumes, and networking to composing a multi-service app.
🧪Property-Based Testing
Go beyond example-based tests — learn to express what your code should always do, then let a framework find the inputs that break it.
🦀Rust's Ownership Model
Build a working mental model of Rust's ownership system — from stack vs heap intuition through borrow checker mastery — so you can read and write Rust without fighting the compiler.
🔷TypeScript Type Narrowing
Replace unsafe `as` casts with control-flow narrowing, discriminated unions, and type predicates — then build a type-safe API client that narrows responses by status code.
🧵Understand Concurrency Memory Models and Write Race-Free Code
Stop guessing whether your atomics need `seq_cst` and start picking orderings from first principles — one primitive at a time — until you can write a lock-free counter that provably can't race.
λMaster Haskell Typeclasses: From Functor to Monad
Climb the typeclass ladder one rung at a time - Eq, Show, Functor, Applicative, Monad - until real Haskell stops looking like runes, and you can ship a tiny expression DSL built on your own custom class.
💻Go Error Handling Idioms
Stop writing `if err != nil` on autopilot. Learn why Go treats errors as values, then wrap, sentinel, and type them until you can design a clean error story for a small CLI.
🔗Master SQL Joins and Query Relational Data with Confidence
See joins as set operations first, then write every join type against a real schema, tune them with indexes and query plans, and finish by solving ten realistic reporting queries.
🔌REST API Design Principles
Design REST APIs that teams can actually use — resources, verbs, versioning, and pagination, grounded in the conventions senior engineers argue about on PR threads.
💻The Actor Model
Stop reasoning about locks and start reasoning about mailboxes — across 14 drops you'll build a tiny actor runtime, wire up supervision, and finish by modeling a real workflow as an actor graph.
🌊Node.js Streams Introduction
Stop loading whole files into memory. Learn each Node.js stream type through runnable snippets and finish by building a streaming CSV-to-JSON transformer with proper backpressure and error handling.
💎Ruby Blocks, Procs, and Lambdas
Untangle Ruby's three callable forms one at a time — blocks, procs, and lambdas — until you can convert between them, predict every return-and-arity gotcha, and end by building a small block-taking DSL of your own.
🔒JavaScript Closures Demystified
Build one mental model for closures that covers the setTimeout loop bug, private state, and React hooks — then ship a tiny state container using nothing but functions and lexical scope.
⚛️React Hooks Mental Model
Build one mental model for React hooks — each render is a snapshot, and every hook either reads from it or syncs the outside world to it — then use that model to fix stale closures, tame dependency arrays, and extract clean custom hooks from a real component.
🔁The JavaScript Event Loop
Draw the JavaScript event loop on a whiteboard from memory, then predict the output of any mixed sync/async code — and instrument a real program to prove you're right.
🤖Learn the Planner-Executor Agent Pattern
Stop watching ReAct loops drift through twenty tool calls to do a five-step job. Build the intuition for when an explicit plan beats step-by-step reaction, then sketch the planner and executor for one of your own multi-step workflows.
🤝Master AI Pair-Programming Workflows
Move past the 'accept all' or 'reject all' trap with a tool-agnostic protocol — frame, narrow, verify, refactor — that works whether you're driving Cursor today or whatever assistant ships next year. By the end, you'll have a one-page playbook for AI pair-programming on your own project.
🧠Understand Attention Mechanisms in Neural Networks
Stop bouncing off matrix algebra and start picturing what query, key, and value actually do — by the end you'll trace attention through a five-token sentence and predict which heads attend where before opening the paper.
📈Understand Overfitting and How to Spot It
Stop calling overfitting a vibe — diagnose it from a learning curve in seconds, then prove you understand the cure by overfitting a model on purpose and fixing it three different ways.
🔌Understand the Model Context Protocol (MCP)
Crack open the Model Context Protocol — the host/client/server shape, the three primitives, and the integration math that makes it worth standardizing. By the end you can sketch the MCP server you'd build to expose your own product to AI clients.
🔍Learn AI-Assisted Research Workflows
Learn a four-stage research loop — scope, search, synthesize, verify — that works with any AI tool, then build a personal checklist that catches the failure modes that bite you most often.
✍️Learn AI-Assisted Technical Writing
Learn which parts of writing AI is great at (outline, gap-finding, copyedit) and which it quietly destroys (voice, judgment, taste), then ship a personal protocol that names exactly which steps you delegate and which you guard.
🧩Learn Chunking Strategies for RAG
Compare fixed, recursive, semantic, and document-aware chunking on the same source so trade-offs become visible — then pick a chunking strategy for one of your own document types and defend the choice.
🖱️Learn Computer-Use and Browser Agent Patterns
Separate vision, plan, action, and verification so browser-agent failures stop feeling like 'the agent broke' and start being attributable. By the end, you'll map a real workflow you'd hand to a computer-use agent and predict the exact steps that will be brittle.
🪟Learn Context Engineering
Stop polishing the prompt and start engineering the whole context — system instructions, examples, retrieval, history — as a budget you allocate on purpose. By the end you can refactor one bloated context into a prioritized layout and measure whether quality went up.
🧠Learn Extended Thinking and Reasoning Modes
Stop guessing whether 'thinking mode' helps and start measuring it. By the end you can run the same prompt with and without extended reasoning, see where it lifts accuracy and where it just burns cost, and make the call per task class instead of by vibe.
🎯Learn Few-Shot Prompting
Stop pasting examples and hoping. Curate five that actually shift the model — representative, diverse, ordered, and formatted to match — then measure the lift on a task you ship.
🧭Learn How Embeddings Encode Meaning
Stop treating embeddings as magic vectors. By the end you'll see meaning as geometry — and design a duplicate-FAQ detector for a 1000-question support corpus that you could actually ship.
🔀Learn How Transformers Process Sequences
Trace one token through every block of a transformer — embed, position, attend, FFN, residual — until you can narrate, in plain English, how 'the cat sat' becomes French.
🔍Learn HyDE: Hypothetical Document Embeddings
Stop accepting bad RAG retrievals as a fact of life — see why short queries and long documents land in different regions of embedding space, watch HyDE close the gap by hallucinating a fake answer first, then decide which of your pipelines actually deserve the extra LLM call.
🔎Learn the Architecture of RAG Systems
Separate RAG into three pipelines — offline ingest, online retrieval, generation grounding — so each can be debugged on its own. By the end, you'll sketch a documentation-chatbot architecture and label every failure mode.
🧪Learn to Evaluate LLM Outputs Systematically
Move from eyeballing LLM outputs to running a CI eval that blocks regressions on a real prompt. You'll build a 20-item dataset, write a binary rubric, calibrate LLM-as-judge, and ship the harness in your repo.
🌀Learn Vibe Coding: Agentic Development Workflows
Vibe coding looks like magic until production breaks. This path separates the surface practice — chatting code into being — from the engineering discipline that keeps the result maintainable, ending with a guardrail playbook your team can actually follow.
⚖️Learn When to Use a Small Model vs a Large Model
Stop defaulting to GPT-4 for tasks a 7B model handles fine. Build a per-task decision tree across capability, latency, and cost-per-million-tokens — then route your product's tasks accordingly.
🧪Master Prompt Engineering Principles
Stop chasing magic phrases. Learn the four principles — specificity, constraints, examples, decomposition — that survive every model upgrade, then ship a prompt spec and A/B it against your old one.
🕵️Understand AI-Generated Content and Detection
Stop treating AI detection like a true-or-false test. Learn why statistical detectors fail in both directions, where watermarking and C2PA provenance actually help, and walk away with a content-provenance policy you can hand to your team or class.
🧭Understand Alignment as a Research Problem
Treat AI alignment as a research field with concrete open problems — outer vs inner alignment, deceptive alignment, and scalable oversight — instead of vibes about doom or guardrails. Walk away able to write a one-paragraph map of the alignment landscape that holds up to a skeptical reader.
🧠Understand Chain-of-Thought Reasoning
Stop pasting 'let's think step by step' on every prompt and learn where chain-of-thought actually changes the answer — math reasoning, multi-step planning, ambiguous reading — and where it just burns tokens. Walk away able to point at three of your own prompts that genuinely need CoT, and three that don't.
📊Understand Confusion Matrices, Precision, and Recall
Stop reaching for accuracy by reflex — read a confusion matrix in seconds, compute precision and recall by hand, and pick the right metric for spam, fraud, and cancer-screening problems without second-guessing.
📜Understand Constitutional AI as a Training Principle
See exactly how a written set of principles becomes a training signal — through self-critique, revision, and AI-generated preference labels. By the end you'll draft a 5-principle constitution for one of your own AI applications.
🎛️Fine-Tuning vs In-Context Learning
Stop reaching for fine-tuning every time a prompt fails — diagnose whether you have a capability gap, format gap, or knowledge gap, then pick the cheapest fix that closes it. By the end you'll write a one-page memo your team can defend.
🏷️Supervised vs Unsupervised Learning
Stop memorizing the labels-vs-no-labels split. Learn to classify any ML problem by where its supervision comes from — including the messy self-supervised middle that powers modern AI.
🪟Understand Context Windows in LLMs
See past the 'context length exceeded' error and pick the right fix every time — trim, summarize, retrieve, or upgrade. By the end you can sketch a memory strategy for a chatbot answering from a 500-page handbook without guessing.
📊Understand Cross-Validation
Stop running k-fold on autopilot — see why a single train-test split lies, watch variance shrink across folds you split by hand, and pick stratified, group, or time-series CV for three real datasets without ever leaking the future into the past.
🪄Understand Emergent Capabilities in LLMs
See past the 'mystical jump' headlines: read the original emergence papers next to the 'mirage' rebuttal, watch the same task switch from jumpy to smooth when you swap the metric, and finish able to predict whether the capability you actually care about will scale in steps or in slopes.
🧪Understand Feature Engineering Fundamentals
Stop believing deep learning killed feature engineering — build the discipline of encoding, leakage, and target alignment so you can sketch a feature plan for any tabular problem and consistently beat raw-column baselines.
📉Understand Gradient Descent
Stop treating the optimizer as a black box — walk a 2D loss surface by hand, feel why a learning rate that's too big diverges and one that's too small stalls, and learn to read SGD, momentum, and Adam loss curves the way a doctor reads a chart.
🌀Understand Hallucinations in LLMs
Stop treating LLM hallucinations as one bug — see the three distinct failure modes, force each one on purpose, then add one guardrail to a prompt you actually use and measure whether it worked.
🛡️Understand Jailbreaking and AI Safety
See LLM jailbreaking as four distinct attack families instead of one scary headline, then turn that taxonomy into a one-page risk note for an AI feature you actually ship.
📊Understand LLM Benchmarks: MMLU, HumanEval, and Friends
Stop reading LLM benchmark scores like IQ tests. You'll learn what MMLU, HumanEval, GSM8K, MT-Bench, and friends actually measure, where each gets gamed, and how to rate a model release note's claims with calibrated skepticism.
🧠Understand Mixture-of-Experts (MoE) Architectures
Stop hearing 'experts vote' and start watching a single token route through a sparse layer — by the end you'll predict which inputs land on which expert in a small MoE you design yourself.
🧪Understand Model Distillation
Stop treating model distillation as alchemy. Walk one teacher-student loop with a real loss function, then sketch a distillation plan to take one of your existing prompts to a smaller, cheaper model — by output, by reasoning trace, or by preference.
🧬Understand Multimodal Models
Crack open the three real fusion patterns — early, late, and joint — so when you face a multimodal task at work, the choice between vision, OCR, or both becomes mechanical instead of guesswork.
🧠Understand Neural Network Fundamentals
Strip neural networks back to arithmetic — weighted sums, a squash function, and stacking. By the end you'll trace a forward pass with a pencil and design a tabular-problem architecture you can defend choice by choice.
⚡Understand Prompt Caching and Why It Changes Economics
See exactly what prompt caching caches, why prefix order is suddenly the most important decision in your template, and how a single header flag can cut a 5k-token system prompt's cost by 80% — then ship a cache-friendly template for one of your hottest endpoints.
🛡️Understand Prompt Injection Attacks
Audit your own LLM features for injection surfaces. Separate direct from indirect attacks with worked examples, then apply structured isolation, output filters, provenance, and least-authority tool design.
🎯Understand Reranking in RAG Pipelines
See why a vector search alone almost never returns the right top-3, and add a cross-encoder rerank stage to a RAG prototype that measurably lifts precision@3.
🤖Understand RLHF: Reinforcement Learning from Human Feedback
Walk a single example through SFT, a reward model, and one PPO update so the RLHF loop stops feeling mythical. By the end, you'll sketch a preference-data pipeline for a real prompt in your own product.
🧱Understand Structured Output and Function Calling
Stop bolting regex onto markdown-wrapped near-JSON. Compare prompt-asks, JSON mode, and schema-constrained decoding head-to-head, then write a strict schema for one of your real LLM outputs and test it for compliance.
🎲Understand Temperature, Top-P, and Sampling
See exactly what temperature and top-p do to a model's probability distribution, then justify the sampling settings for your real tasks instead of guessing. Stop tweaking knobs and start engineering output behavior.
📉Understand the Bias-Variance Tradeoff
Turn the bias-variance formula into a hands-on debug checklist — read any train/val gap or learning curve and prescribe the right fix in minutes.
📈Understand the Bitter Lesson and Scaling Laws
Stop quoting Sutton like a slogan and start reading scaling-law curves like a forecaster — by the end, you'll know exactly where the bitter lesson predicts the next AI breakthrough and where it quietly fails.
🔡Understand Tokenization: How Models See Text
Stop counting characters and start seeing text the way the model does — as subword pieces that vary wildly in cost. By the end you'll eyeball a paragraph's token count and know why emoji, code, and rare words inflate your bill.
🔧Understand Tool Use in AI Agents
Stop debugging agents by shouting 'why did it pick that tool' — separate the contract into schema, selection, and execution so each can fail (and be fixed) independently. By the end you'll design two tools for one of your own products with names, schemas, and descriptions you can defend in review.
📐Understand Vector Similarity: Cosine, Dot Product, Euclidean
Stop reaching for cosine similarity by reflex. You'll compute all three metrics on the same vectors, see when normalization collapses two of them into one, and pick the right metric for three real retrieval tasks.
🔗Build a Mental Model of LangChain
Stop reading LangChain as 200 unrelated classes and start seeing one primitive — the Runnable — wired together with a pipe. By the end you can sketch a chain for any task and name every Runnable in it.
🗂️Choose a Vector Database
Build a five-axis scorecard — scale, hybrid search, filtering, ops, cost — that turns vector database selection from hype-driven guesswork into a defensible choice your future self will thank you for.
🔎Combine BM25 and Semantic Search (Hybrid Search)
Build hybrid search layer by layer — BM25 alone, vectors alone, then RRF fusion — so you can debug retrieval failures and predict which query types each layer fixes before you ship.
🆚Compare LlamaIndex and LangChain for RAG
Stop picking a RAG framework from a Twitter poll. See LlamaIndex and LangChain side by side on the same pipeline so you can defend your choice for a real workload with real tradeoffs.
🐛Debug Code with LLMs
Stop chasing the first plausible theory the AI offers. By the end you'll run a real debugging loop — hypothesis, counter-evidence, smallest test — with the LLM as your partner instead of your oracle.
🧱Get Structured Output with Pydantic and JSON Schema
Replace markdown-fenced near-JSON and regex band-aids with a Pydantic schema the API enforces for you. By the end you can convert any ad-hoc prompt to typed output and measure how many parse failures you just deleted.
🔭Learn LLM Observability Fundamentals
Stop finding out about LLM regressions from angry user emails. By the end you'll know what to log on every call, which tools fit which signal, and how to sketch one dashboard an on-call engineer can read at 3am.
🎨Master Text-to-Image Prompt Craft
Build an internal recipe for prompting diffusion models — subject, medium, style, lighting, weight, negative — so you can generate brand-aligned images on demand instead of copying random prompts from marketplaces.
💰Optimize Cost in LLM Applications
Stop watching your LLM bill scale linearly with traffic. By the end you can take any feature, name three cost cuts with dollar estimates, and defend the tradeoffs to your team.
📉PCA: Dimensionality Reduction from Eigenvectors
Connect PCA to the eigenvectors of the covariance matrix, then compress a 50-feature dataset to 5 components and defend exactly how much information you kept.
📡Stream LLM Responses for Snappy UX
Stop shipping six-second blank screens — switch to SSE streaming and watch perceived latency collapse from seconds to milliseconds. By the end you'll add a stop button and graceful retry to a streamed chat without dropping tokens.
✂️Understand Image Segmentation with SAM
Separate semantic, instance, and promptable segmentation so you can pick the right tool — then plan a tiny SAM-powered pipeline that crops product photos for an ecommerce catalog before you write a line of code.
🔊Understand Text-to-Speech Quality Dimensions
Build a five-axis TTS scorecard — naturalness, prosody, latency, consistency, controllability — that replaces demo-vibe-checks with a defensible audit you can take into any voice-agent vendor meeting.
🖼️Understand Vision Transformers (ViT)
Walk one 224x224 image through patching, embedding, and attention until ViT stops feeling like a magic trick — then predict where the heads attend on a cat-and-person photo before the demo confirms it.
🔍Use AI for Code Review
Stop accepting every AI review comment uncritically — and stop ignoring them all. By the end you'll know exactly what AI catches reliably, what it misses, and how to write a review prompt your team actually trusts.
📝Use AI for Meeting Notes That You'll Actually Read
Stop treating AI meeting notes as a dumping ground nobody reads. Build a per-meeting-type workflow that ends in shared decisions and assigned actions — not another inbox full of ignored summaries.
📊Use AI for Spreadsheet Workflows
Stop pasting your sheet into ChatGPT and hoping. Learn four reusable patterns — formula generation, bulk row processing, cleanup, summary — that keep your spreadsheet as the source of truth and let you ship a workflow that cleans, classifies, and summarizes a 200-row dataset.
🧪Use AI to Generate Tests
Turn AI from a happy-path test generator into a real partner that probes boundaries, error paths, and oracle gaps — so the suite catches bugs instead of memorizing them.
🧾Use Vision-Language Models for OCR and Document Extraction
Stop gluing Tesseract to brittle regex parsers. Design VLM-based document extraction pipelines that return typed JSON with confidence scores — and know exactly when classical OCR still wins on cost.
🚦Version and A/B Test Prompts in Production
Stop shipping prompt edits like config tweaks and start treating them like code with versions, canaries, and kill switches. By the end you can write a one-page rollout plan with success criteria, sample size, and a rollback trigger that someone else could execute.
⚖️Audit AI Models for Bias
Three fairness metrics. One model. They disagree. Walk a synthetic loan classifier through demographic parity, equalized odds, and calibration; see where they conflict; then outline a regulator-defensible audit plan for a resume screener.
🔬Build an LLM Eval Harness for Production
Stop running eval notebooks once and forgetting them. Build a three-layer harness — pre-merge CI, pre-deploy gate, online sampling — with the right cadence, budget, and judge calibration for a production RAG app.
🌫️Build Intuition for Diffusion Models
Stop reading 'noise to image' as magic and start seeing it as a learned vector field that pulls samples toward the data. By the end you can sketch one denoising step and explain how classifier-free guidance bends the field toward 'a cat in a hat.'
🗺️Choose an LLM Deployment Topology
Stop choosing between 'just call OpenAI' and 'self-host on H100s' — there are four real LLM topologies in between. By the end you can sketch a 12-month plan that survives 10x traffic growth.
🖼️Understand Image Embeddings and Visual Search
Bridge from text embeddings to image embeddings, then design a duplicate-photo finder for your own library — without ever reaching for perceptual hashes.
📉Detect Drift in LLM and ML Apps
Stop confusing 'data drift' and 'concept drift' — they need different fixes. Walk one feature through both kinds of drift on a real-shaped dataset, then design a drift dashboard for an LLM app where ground truth is delayed by 7 days.
📝Generate Commit Messages with AI
Stop letting your git history decay into 'fix stuff' two weeks after you adopt Conventional Commits. By the end you'll have an AI commit hook reading your diff and producing a compliant message every time — and a team convention doc that makes it stick.
🧬Sentence vs Token Embeddings
Stop grabbing BERT's [CLS] token and calling it a sentence embedding. By the end you'll know exactly when token, pooled, and contrastively-trained vectors each win — and design a 100K-doc semantic search you can defend.
🧭Understand ANN Algorithms: HNSW, IVF, PQ
Stop tuning ef and M by trial and error — see HNSW, IVF, and PQ as physical structures (a multilayer skip graph, a coarse cluster index, and a vector compressor) so you can predict which one fits a 100M-vector workload before you benchmark anything.
🎧Understand Audio Embeddings
Stop forcing audio through text. Drops show the audio-native path — wav2vec, CLAP, MERT — and when it beats transcribe-then-embed for music search, speaker ID, and sound classification. By the end you can plan a 'find similar drums' search over a sample library.
🔏Understand C2PA Content Credentials and AI Watermarking
Stop treating 'is this AI?' as a vibes question. Separate the three layers — hash (hard binding), watermark (soft binding), signed manifest — so provenance becomes verifiable evidence, then design a flow for a media product that ships both human and AI content.
🖼️Understand CLIP and Contrastive Image-Text Learning
Stop treating CLIP as a black-box embedding API. By hand-building the contrastive matrix on five image-caption pairs and tracing one shared embedding space, you'll design a 'photo of a red bicycle' search over an unlabeled folder — and know exactly why it works.
🌐Understand Multilingual Embeddings
Stop bolting translation onto English-only RAG. By the end you'll understand how knowledge distillation aligns embedding spaces across languages — and you'll have a concrete plan for support-doc search across 12 languages, with the low-resource gotchas mapped before you ship.
🎙️Understand Speech-to-Text Accuracy and WER
Stop trusting WER numbers from someone else's benchmark — build a 50-clip eval set from your own production audio so the next time you swap transcription vendors, the decision rests on your data, not theirs.
🚦Use AI Gateways: OpenRouter, Portkey, Helicone
Stop choosing a gateway because a blog post said so. By the end you can pick OpenRouter, Portkey, Helicone, or self-host for a real multi-region app and defend it on failover, cost, and observability.
🧹Use AI to Refactor Legacy Code
Stop shipping AI-refactored legacy code that subtly breaks behavior. By the end you'll take a 200-line legacy function through explore → characterize → refactor → review and produce a version with provable behavior preservation — using AI on the careful steps, not as a shortcut around them.
🧪Use Eval Frameworks: Ragas, DeepEval, TruLens
Stop hunting for a single 'best' RAG eval tool. You'll learn the four core RAG metrics, score the same app in Ragas and DeepEval, see where each framework wins, and ship a layered eval stack you can defend to your team.
🏷️Use Metadata Filtering in Vector Search
Contrast pre-filter, post-filter, and partitioned-index strategies for metadata-aware vector search on the same dataset so the recall failure mode becomes visible, then design a metadata schema for a multi-tenant RAG that needs sub-100ms queries.
🔀Use Query Expansion to Improve RAG Recall
Compare four query-expansion patterns — synonym, multi-query, step-back, and HyDE — on the same hard query so each one's strength is visible, then design a query-expansion stage for a customer-support RAG with 30% short queries.
📇Write Model Cards for AI Transparency
Stop writing model cards from memory. Walk every section of the Mitchell et al. card with a worked classifier, then critique a real card from a major lab and name what's missing — so transparency becomes a habit, not a deliverable.
⚖️Build a Mental Model of the EU AI Act's Risk Tiers
Build the four-tier mental model of the EU AI Act — unacceptable, high, limited, minimal — through worked examples, then self-classify your own product and write a one-page tier assessment you could defend to outside counsel.
🧠Build an AI-Augmented Personal Knowledge Base
Pick the three jobs AI is actually good at inside a note vault — connection discovery, cross-note Q&A, and atomic distillation — then design a daily workflow that still works when the model is offline.
📉Detect Anomalies in Time-Series Data
Stop alerting on every weekend dip and missing the real incidents — learn to separate point, contextual, and collective anomalies, match each to the right detector (Z-score, isolation forest, LSTM autoencoder), and design an SLI alerting rule that survives weekly seasonality plus a slow trend.
📋Document Datasets with Datasheets
Datasets get retrained; the quirks get rediscovered. Walk the Gebru et al. datasheet section by section against a real dataset, compare it to model cards and Google's data cards, then audit one of your team's datasets and flag the gaps.
📈Know When Not to Use ML for Time-Series Forecasting
Stop reaching for LSTMs on tiny series — enforce the baseline ladder (naive, seasonal-naive, ARIMA, then ML), backtest each one properly on real data, and write the decision criteria your team will use to escalate to ML only when the simple model is genuinely beaten.
🦀Rust Borrow Checker Deep Dive
Build a precise mental model of Rust's borrow checker — from the shared-XOR-mutable invariant through NLL and reborrows — so you can refactor tangled code into a clean version the compiler accepts without reaching for clone().
©️Understand Copyright in AI Training Data
Public web is not 'fair to train on,' and not every scrape is theft. Walk the four real threads — what copyright covers, how fair use is being argued, what licensing actually looks like, and which opt-out signals matter — then outline a sourcing policy you'd defend.
🎨Understand Image Style Transfer and Aesthetics
Separate the three knobs of image style transfer — content preservation, style intensity, structural guidance — so you can pick img2img, ControlNet, IP-Adapter, or a LoRA deliberately, then plan a brand-illustration workflow that stays consistent across products.
🎙️Understand Voice Cloning and Its Ethics
Few-shot voice cloning needs 3-30 seconds of audio — the technical story and the ethical one are different. Walk through a consented cloning flow, see why provenance beats 'is it AI?' for fraud, and sketch a consent-and-watermark policy for a feature that clones a customer's own voice.
🎯Use AI to Build Slides and Decks
Stop asking AI to 'make a deck on X' and getting bullet-point sludge that looks like every other AI deck. Learn the outline-first workflow that drives AI from a thinking argument, not a topic — and ship a 7-slide deck for a real talk you can track time saved on.
🐍Build Intuition for State Space Models and Mamba
Stop reading 'Mamba is linear-time attention' as marketing and start seeing the SSM as a controllable filter — A forgets, B absorbs, C reads out, Δ sets the clock. By the end you can predict whether Mamba or a transformer wins on a 1M-token retrieval task and justify it from the architecture.
🧮Choose a Quantization Format: GPTQ vs AWQ vs EXL2 vs GGUF
Stop picking quantization formats from Reddit threads. You'll separate algorithm, file format, and runtime kernel into three clean decisions — then justify any pick for Ollama, vLLM, or a single 4090.
⚖️Compare DPO, IPO, KTO, ORPO, and SimPO
Map each post-DPO algorithm — IPO, KTO, ORPO, SimPO — to the exact failure mode it fixes, so picking one stops being a coin flip. By the end, you'll match three real datasets to the right algorithm and justify each call in a paragraph.
🧠Compare GQA, MQA, and Multi-Head Attention
GQA isn't a new mechanism — it's a single knob (G) that trades KV-cache memory for quality on top of plain attention. You'll learn to pick G for a real serving budget by walking the cache-size math and the quality argument side by side.
⚡Compare LLM Serving Frameworks: vLLM, TensorRT-LLM, SGLang, llama.cpp
Stop picking vLLM because Twitter said so. You'll learn to read a deployment's shape — concurrency, prefix overlap, hardware, lifetime — and narrow the four frameworks to one defensible choice in four questions.
🧪Understand Benchmark Saturation and Contamination
MMLU plateaued. HumanEval is in the training set. You'll separate saturation from contamination, run n-gram and perplexity checks on real test items, and design a holdout that's structurally hard to leak — defensible enough to put in front of a buyer.
🔬Understand bf16, fp16, and Loss Scaling
Stop flipping the precision flag and praying. You'll read a float as sign-exponent-mantissa, see exactly why fp16 NaNs and bf16 doesn't, and prescribe the right fix — loss scaling, bf16, or a mixed policy — for any training run.
📉Understand Chinchilla Scaling Laws and Compute-Optimal Training
Stop repeating '20 tokens per parameter' like a mantra and start picking N and D the way LLaMA-3's team does — by the end, you'll defend a compute budget split that ignores Chinchilla on purpose.
🧮Understand Data, Tensor, and Pipeline Parallelism
Walk one toy 4-layer model through every parallelism axis — DP, TP, PP — until the geometry sticks. By drop 14 you can pick a (DP, TP, PP) tuple for a 70B model on 64 GPUs and defend it from a cost model.
🎯Understand DPO and Why It Replaced PPO for Alignment
Trace DPO from the Bradley-Terry preference equation to the closed-form policy and the log-prob loss so it stops feeling like 'just another trainer' and starts feeling inevitable. By the end, you'll predict on three preference pairs which way DPO will push chosen vs rejected log-probs — then check against a real training run.
⚡Understand FlashAttention and Tiling
Stop treating FlashAttention as a mystery flag — understand the tiling, online softmax, and HBM-vs-SRAM tradeoff that turn the same attention math into 2-4× speedups. By the end you can estimate FA's win for any sequence length on graph paper, before touching CUDA.
🔪Understand FSDP Sharding Strategies
Walk every FSDP sharding strategy across the same toy transformer until all-gather and reduce-scatter become numbers, not folklore. By the end you can pick FULL_SHARD vs SHARD_GRAD_OP vs HYBRID_SHARD for a 7B model on 16 GPUs and defend it.
🧠Understand GPU vs TPU vs NPU vs ASIC
Tell GPUs, TPUs, NPUs, and ASICs apart by the workload each was built for — then defend your accelerator pick for a new AI product with one paragraph of architectural reasoning, not vendor branding.
🧮Understand Gradient Checkpointing
Stop guessing why gradient checkpointing tanks your throughput by 30% — learn to read the activation tape, pick the right granularity, and predict the compute overhead before you launch a single training run.
🧭Understand MoE Routing and Load Balancing
Open the MoE router black box piece by piece — softmax gate, top-k, auxiliary loss, capacity factor, token dropping — until you can predict how capacity factor 1.0 versus 1.25 changes wasted compute and dropped tokens, then verify with an ablation.
🎯Understand Reward Hacking and Goodhart's Law in RLHF
Spot reward hacking in real model outputs — length bias, sycophancy, refusal escalation, sophistication bias — and pick the right mitigation (KL penalty, reward model ensembling, or process-based reward) for each failure mode.
🌀Understand RoPE and Why It Beat Sinusoidal
Stop treating RoPE as a black-box position trick and start seeing it as 2D rotations on pairs of dimensions — by the end you'll predict how it fails past training context and explain on a napkin why position interpolation rescues it.
🧮Understand Tensor Cores and Mixed Precision
Stop hand-waving about '100x faster than CUDA cores.' You'll trace one 4x4 tile through a tensor core's registers, multipliers, and FP32 accumulator, then estimate the real FLOPS uplift from switching one layer of your favorite model to mixed precision.
🧮Understand vLLM PagedAttention and KV Cache Memory
Re-use the virtual-memory analogy you already know to demystify vLLM: by the end you can sketch a block table, explain prefix sharing, and estimate how many 8k-context sequences fit on your GPU.
🧊Understand ZeRO and Its Three Stages
Pencil-and-paper your way through ZeRO stages 1, 2, and 3 — sharding optimizer state, then gradients, then params — until you can pick a stage for a 13B model on 8 A100s and justify it from memory math, not vibes.