AI Knowledge Map

Role144 nodesmap v2026-05-22-002

Take the qualification test to see what you know.Sign in

StrongPartialWeakUntestedTrend chips use dashed borders.

GPU & CUDA

40 nodes

Execution Model

CUDA Hello World Threads, Blocks, and Grids Mapping to Hardware — SMs Warps — 32 Threads in Lockstep

Memory Access Patterns

Why Access Patterns Matter Coalesced Access Strided & Random Access Putting It Together

Memory Hierarchy

The Memory Ladder Registers & Register Spill Shared Memory & L1 Cache HBM — Where Your Model Lives NVLink & PCIe

Operator Fusion & FlashAttention

The Kernel Launch Problem Operator Fusion FlashAttention: The Problem FlashAttention: The Solution

Roofline Model

The Bottleneck Question Reading the Roofline Plot Where ML Operations Fall Prefill vs Decode Changing the Roof

Tensor Cores & Mixed Precision

Beyond CUDA Cores Precision Formats Precision-Throughput Tradeoff Dimension Alignment Mixed Precision Training & Inference

Tiling & Matrix Multiply

Naive Matrix Multiply The Tiling Idea Tiled Matmul Kernel Why Tiling Works Tree Reduction From Tiling to FlashAttention

Triton & torch.compile

The CUDA Expertise Gap torch.compile When to Use What

Why GPUs?

The CPU — Few Powerful Cores The GPU — Thousands of Simple Cores ML Is Matrix Math What Is CUDA?

LLM Internals

54 nodes

Self-Attention

Q / K / V Projections Why Attention?Q, K, V: Three Roles Computing Attention Scores From Scores to Output Multi-Head Attention Causal Masking

Batching

Why GPUs Need Batching Static Batching Continuous Batching Prefill vs Decode Scheduling Memory Limits the Batch Batching in Production

Embeddings

From Token IDs to Vectors What Do Dimensions Mean?Tokens in Space Measuring Similarity Positional Encoding Why Embeddings Matter

Text Generation

One Token at a Time From Logits to Probabilities Temperature Top-K and Top-P Sampling Greedy vs Creative Generation in Practice

KV Cache

The Redundancy Problem The KV Cache Solution Prefill vs Decode Memory Cost GQA: Shrinking the Cache KV Cache in Production

Paged Attention

The Fragmentation Problem Virtual Memory for GPUs PagedAttention in Practice The Full Serving Stack

Quantization

INT8 vs INT4 Quantization The Size Problem How Numbers Shrink The Quantization Process The Outlier Problem Modern Methods What to Quantize

Tokenization

Why Tokenization?BPE: The Algorithm Explore the Patterns Training vs Inference Byte-Level BPE Why It Matters

Transformer Block

The Transformer Block Layer Normalization Residual Connections The Feed-Forward Network Pre-Norm vs Post-Norm Modern Variants & Scale

Trends

AI Agents

49 nodes

The Agent Loop & State

Why Agents?Strip Away the Peripherals The State Object Inside a Tick Why Workflows First?The Anatomy of a Harness

Capstone — Three Designs

The Task & Three Designs Trace Comparison Failure Modes + Trifecta Exposure Cost & Reliability Plot The Decision Rule

Context Engineering

Context as Scarce Resource The 4 Failure Modes The 4 Fixes Tool-Loading Strategy Subagents as Context Isolation

Evals & Diagnostics

Compounding Errors Error Analysis First Golden Cases Pass/Fail vs Score The 4 Eval Failure Modes

Planning & Reflection

The Single-Shot Failure When to Spend More Tokens When to Pause and Observe When to Retry When to Stop

Retrieval & RAG

Why Retrieval?Embeddings as Coordinates Retrieve-Then-Generate Chunking Strategies ANN — Recall vs Speed RAG Failure Modes

Security & the Lethal Trifecta

The Lethal Trifecta Draw the Data-Flow Graph Cut a Leg Capability Scoping Output Exfiltration via Tool Calls

Tool Use & Function Calling

Why Tools?The Tool Schema Tool Design — ACI + Anti-Patterns Structured Outputs MCP, Two Ways Skills as a Primitive Tools as Attack Surface

Workflow Patterns

When NOT to Use an Agent Chaining + Routing Parallelization + Voting Orchestrator-Workers + Subagents Evaluator-Optimizer