Learn LLM Engineering

Build a reproducible AI repo with safe Git defaults, a clean-clone eval gate, shell diagnostics, and Linux process habits.

Package the access-request scorer in a portable Docker image with a small build context, mounted data, runtime configuration, a non-root user, and a reproducible gate.

Learn Python by building a small evaluator: read JSONL, validate fields, count correct predictions, and test the difference between bad input and a wrong answer.

Learn NumPy shape reasoning from first principles: name axes, predict indexing and broadcasting, reduce safely, distinguish reshape from transpose, and add shape guards.

Follow one access-ticket batch from CPU memory into CUDA kernels. Learn thread and memory hierarchy, coalesced access, roofline decisions, safe device placement, honest timing, and first-line diagnosis for setup, OOM, and throughput failures.

Train the same PyTorch ticket classifier on Apple silicon: select the `mps` device, keep tensors together, handle unsupported ops, time queued work honestly, and respond to unified-memory pressure.

Choose Python lists, hash-based collections, deques, heaps, trees, graphs, tries, and caches by the operations an AI system must serve.

Turn an in-memory support retriever into durable SQL tables. Model versioned sources, query safely, preserve permissions and lineage, and inspect the paths that keep retrieval correct as data changes.

Count work in a small retriever, compare scans, heaps, and radix trees, evaluate prefill versus decode complexity, and enforce latency budgets in production AI pipelines.

Train a one-weight latency predictor by reading a slope, taking a downhill step, tracing chain-rule paths, and checking the same gradient in PyTorch.

Trace one latency prediction into matrix products and token tensors. Check shapes, distinguish dot products from cosine similarity, and catch silent axis mistakes.

Find hidden directions in a support-incident matrix with SVD, then use rank, PCA, truncation, and condition numbers without losing sight of what the numbers mean.

Trace SGD, momentum, RMSProp, Adam, AdamW, schedules, and gradient clipping on a 100-to-1 loss valley. Learn what each optimizer buffer measures and how to validate a training choice.

Use one API abuse-risk detector to learn events, random variables, distributions, conditional probability, independence, Bayes rule, and base-rate mistakes.

Update a coding agent's unknown success rate with beta-binomial evidence, compare priors, measure uncertainty, and expose sampling failures.

Estimate a review queue's abuse rate with bootstrap and Wilson intervals, distinguish sampling variation from bias, and assess calibration without overstating the evidence.

Match binary outcomes, routes, tool-call counts, and latency to first distributions, then reject a simulation that doesn't fit the traces.

Compare a code-generation model with paired evidence, uncertainty for lift, and pass@k under a fixed sampling budget.

Build a CodeAssist timeout-risk neural network from scratch: derive affine maps, prove why non-linearities prevent layer collapse, compare core activations, track batched tensor shapes, and implement backpropagation with NumPy and PyTorch autograd.

Trace a CNN over a 4 by 4 crop: shared kernels, feature-map shapes, pooling winners, padding artifacts, and a matching NumPy-to-PyTorch forward pass.

Follow a decode-latency model through reverse-mode autograd, the PyTorch training loop, batching dynamics, vanishing gradients, weight initialization, and early stopping.

Turn raw class scores into stable probabilities and a useful learning signal, then apply the same loss to next-token predictions.

Trace an RNN over ordered events, see why gradients fade or grow, and use LSTM and GRU gates to control memory.

Compress a 5 by 5 screenshot crop through a latent bottleneck, then train a VAE so prior samples can decode.

Trace a three-token prompt through causal attention, residual updates, and a vocabulary head. Build and test one complete decoder in PyTorch.

Learn how next-token prediction becomes a trainable language model, from bigram counts and neural n-grams to causal Transformer generation and KV-cache serving.

Trace how decoder-only models grew into modern LLMs, then inspect scaling, instruction tuning, open weights, MoE, and serving tradeoffs with runnable examples.

Build an incident-triage prompt with clear roles, useful examples, structured outputs, evidence checks, and a separate authorization boundary.

Turn a grounded prompt into a reliable API boundary with server-side secrets, typed results, bounded retries, safe actions, and useful telemetry.

Run one local rotation-decision app with a browser form, checked provider boundary, durable traces, and tests of the actual HTTP path.

Follow a decoder language model from training to serving, check the artifacts after compression, and turn production symptoms into evidence-led investigations.

Fit assistant latency with a line, derive OLS and gradient descent from first principles, and expose hidden non-linearities through residual diagnostics.

Route access-change requests with logistic regression from scratch: derive sigmoid and log loss, fit NumPy weights, select a cost-aware threshold on validation data, audit ranking and calibration, then compare with scikit-learn.

Route the same access-change requests with axis-aligned rules: compute Gini, fit a stump, watch extra depth memorize R3, average bootstrap trees, boost residuals, and audit MDI versus SHAP.

Turn the earlier one-shot access-review label into an MDP. Compute discounted returns and Bellman backups, run value iteration and Q-learning, watch abandonment reverse a policy, and connect REINFORCE to LLM post-training.

Split access-review requests by time and user, block post-decision fields, fit preprocessing on training rows only, and treat public LLM benchmarks as contamination-prone.

Audit a prompt sweep with risk bounds, construct a VC shattering proof, measure noise fitting, and test claims about interpolation and sample size.

Build finite-sample conformal prediction intervals, compute corrected calibration quantiles, and diagnose subgroup and distribution-shift failures.

Inspect unlabeled developer-message embeddings with k-means and PCA, then stress-test whether apparent neighborhoods survive scale, metric, and compression choices.

Fit a Gaussian mixture from six latencies, reproduce EM's lower-bound argument, diagnose collapsed and symmetric components, and connect exact inference to VAEs.

Build and evaluate the evidence-selection stage of a technical-docs assistant with BM25, dense similarity, rank fusion, reranking, and approximate search audits.

Explore exponential token search spaces. Implement stable softmax, greedy and beam search with length and repetition penalties, top-k/top-p/min-p sampling, and test-time reasoning verifiers.

Design a trustworthy online experiment for an incident-assistant change: randomize incidents, measure useful outcomes, quantify uncertainty, and reject false wins.

Separate correlation from intervention, diagnose Simpson's reversal, estimate adjusted treatment effects, and inspect overlap before trusting observational AI evaluations.

Trace logits, gradients, updates, and validation in runnable PyTorch loops. Work through unequal micro-batches, CUDA AMP ordering, independent snapshots, and checkpoint resumption.

Build versioned AI datasets with schema gates, grouped splits, contamination checks, and auditable receipts.

Turn training-job events into stable prediction inputs while preventing leakage and training-serving mismatch.

Replay job-SLA features at decision time from events, then keep that same meaning in online serving.

Train an SLA-risk booster, select rounds and thresholds on later jobs, challenge it with cheap baselines, and record what the release evidence actually supports.

Rank documents for a developer using candidate retrieval, relevance metrics, and feedback-loop safeguards.

Forecast batch-job demand with time-aware evaluation and turn large forecast errors into reviewable operational alerts.

Monitor predictive models from feature freshness through delayed labels, then gate retraining, promotion, and rollback.

Explore Sutton's Bitter Lesson across search, learning, and heuristics, then analyze the compute economy across pretraining, serving, and test-time search.

Build a subword tokenizer, master BPE, WordPiece, and SentencePiece Unigram, and debug production failure modes from fertility tax to glitch tokens.

Turn token IDs into vectors, learn what nearby usage captures, and see why a word such as charge needs sentence-dependent representations.

Compute perplexity from held-out token probabilities, compare models under a fixed protocol, normalize across tokenizers, and decide what PPL can't tell you.

Turn PDFs, scans, HTML, and Markdown into faithful evidence records with provenance and quality checks before retrieval.

Turn clean documents into retrieval units that preserve answers, citations, and measurable search quality.

Build an evaluation suite for a policy-answering LLM: score evidence use, understand public benchmark contracts, control judge bias, and make release decisions from private tests.

Teach a base language model to answer as an assistant: curate grounded SFT rows, serialize chat turns exactly, choose loss targets, pack safely, and detect serving-time template drift.

Shrink and inspect embedding indexes without guessing: measure recall while testing PCA, projections, native shortening, and quantization.

Build and evaluate reasoning controllers: single traces, answer voting, and bounded tree search for multi-step LLM decisions.

Build a safe tool-calling runtime that validates model requests, executes controlled actions, feeds observations back, and evaluates complete workflows.

Trace stateless MCP requests, test a local stdio tool, and separate connection health, protocol validity, and permission.

Curate the evidence, tools, and notes in each model request. Test token budgets, package reusable Agent Skills, and resume work from checked artifacts rather than status claims.

Build a prompt-injection-resistant agent boundary: quarantine untrusted tool content, validate typed action proposals, require approval, and measure unsafe side effects.

Turn a tool-bearing LLM workflow into auditable evidence: classify its use, own risks, version controls, preserve traces, and gate releases.

Define neighboring datasets and privacy budgets, implement protected-unit-aware clipping, distinguish DP-SGD from redaction, and audit membership leakage.

Turn traces into reviewed feedback data: preserve privacy, measure agreement, select useful cases, and protect independent evaluation.

Evaluate model-promotion agent runs by final state, observable trace, safety gates, cost, and repeatability, then map private tests to public benchmarks.

Design a secure, traceable RAG service around versioned policy evidence, grounded answers, abstention, release gates, and latency budgets.

Upgrade a permission-safe RAG retriever with BM25, semantic scores, rank fusion, and recall gates for exact codes and paraphrased policy questions.

Rank retrieved passages with cross-encoders, measure candidate recall and ordering, and preserve source permissions, text boundaries, and serving budgets.

Separate evidence support, citation accuracy, relevance, and completeness. Build a small RAG evaluation harness, test misleading answers, and interpret abstention and slice-level results.

Build rubric-based judges, detect unstable preferences, and measure agreement without mistaking a plausible score for ground truth.

Build a matched-pair fairness audit for an LLM judge, measure routing gaps, and block release when evidence is too weak.

Build a structured grounding gate for incident updates, test its failure cases, and distinguish evidence support from consistency, freshness, and real-world truth.

Connect answer-quality checks to latency, cost, traces, and actionable alerts without confusing missing evidence with a healthy service.

Record the inputs, results, artifacts, and limits behind a candidate decision, then verify them with local MLflow and W&B examples.

Define a DSPy program and a metric, inspect how demonstrations are selected, and separate prompt search from held-out evaluation and deployment.

Turn an evaluated LLM change into an immutable release bundle, promote it through measured traffic, and roll back without losing lineage.

Test whether policy answers can be reused across paraphrases within release, access, and freshness boundaries; compare quality, cost, and tail latency before serving hits.

Build an auditable LLM cost ledger from usage traces, cache decisions, output contracts, offline batch work, and release budget gates.

Compile route requirements, reject incompatible fallbacks, and test shared deadlines and spending reservations in a local gateway lab.

Keep invoice facts, policy evidence, draft generation, credit authorization, and human handoff separate in a runnable support workflow.

Compare as-of arrival estimates and warning policies using delayed labels, meaningful baselines, and honest uncertainty.

Fit a small ranking model, expose misleading metrics, and audit eligibility, delayed labels, and click bias before planning an experiment.

Fit rolling demand forecasts, compare capacity signals with later errors, and catch misleading backtest evidence.

Test photo review routes, expose misleading quality scores, and plan a real-image classifier with case-level evaluation.

Build a point-in-time training and reload path, then test offline gates, simulated canary decisions, promotion, and rollback.

Build an approved-policy lookup, test citations and refusals, and trace source-bound reviews through a research-job simulation.

Build a document QA dashboard that exposes unsafe citations, checks comparable rows, and keeps display filters out of release gates.

Fit a ticket classifier, compare held-out baselines, and check labels, thresholds, scoring evidence, and agent intake.

Test a reward-shaping claim with paired trials, inspect regressions, and package the code, uncertainty, and evidence for review.

Build sentence embeddings with contrastive losses, audit negative labels, and measure retrieval recall, latency, and vector storage.

Compare vector scores, test shorter prefixes, and measure scalar, product, and binary quantization against retrieval requirements.

Build scaled dot-product attention from a token sequence: Q/K/V routing, variance scaling, masks, multi-head shapes, KV-cache cost, and FlashAttention.

Understand how Vision Transformers split images into patches, build visual tokens, train encoders, and connect to CLIP and multimodal LLMs.

Understand why transformers need position information, how sinusoidal encodings work, how RoPE and ALiBi encode relative position, and why long-context extrapolation needs careful evaluation.

Understand LayerNorm mechanics, Pre-LN versus Post-LN placement, RMSNorm simplification, gradient stability, and hybrid normalization layouts for deep transformers.

Learn how sparse autoencoders decompose transformer activations into candidate interpretable features, support circuit tracing, and enable controlled activation-steering experiments.

Compare decoding strategies for text generation: greedy, beam search, top-k, nucleus (top-p), temperature, repetition controls, and newer variants like min-p.

Learn how Kaplan, Chinchilla, and inference-aware fits split a training budget across parameters and tokens, and when a smaller over-trained model wins on lifetime cost.

Understand how web-scale pre-training data is extracted, filtered, deduplicated, mixed, tokenized, and packed into training-ready shards, including decontamination, late-stage annealing, and synthetic-data tradeoffs.

Build and train a tiny GPT end to end on Shakespeare: tokenize with GPT-style subwords, remap active token IDs, run causal self-attention, track validation loss, save a checkpoint, and sample text.

Read and modify JAX research code after the PyTorch GPT lab by making state, randomness, transformations, compilation, and timing explicit.

Learn when to keep the causal language-modeling objective and continue pretraining on domain text instead of jumping straight to SFT, and how to evaluate the trade-off against forgetting, cost, and downstream gain.

Build post-training synthetic data as a gated pipeline: Self-Instruct, Evol-Instruct, grounded execution, calibrated judges, preference pairs, diversity, decontamination, and versioned shards.

Run supervised fine-tuning as a real training system: choose the learning objective before the update surface, verify response-token loss and packing, track the real batch budget, save resumable checkpoints, and export on held-out behavior.

Explore disappearing gradients, asymmetric rounding, and loss scaling. Test why ordinary AMP keeps FP32 updates before comparing training speed and memory.

Master ZeRO stages, FSDP2 fully_shard architecture, 4D parallelism topology (DP, TP, PP, CP), and NCCL collective communication trade-offs.

Understand the mathematics of Low-Rank Adaptation (LoRA), modern adapter targeting strategies, and the real memory tradeoffs compared to full fine-tuning and QLoRA.

Recover training state after interruption, budget checkpoint time, preserve effective batch and scheduler progress, and choose an adaptation recipe that fits the data and memory.

Train reward models as a first-class post-training stage: validate chosen/rejected pairs and splits, fit a scalar reward head with Bradley-Terry loss, audit generalization, and decide when explicit rewards are worth the extra complexity.

Follow preference labels into PPO-style RLHF or DPO. Calculate KL-shaped rewards, clipped policy updates, and response-only DPO gradients, then check whether better training scores improve held-out behavior.

Trace Constitutional AI from critique and revision to AI preference labels, then build honest red-team evaluations that separate model failures, false refusals, and judge errors.

Understand RLVR, a post-training approach that uses programmatic verification instead of learned human-preference rewards to improve checked outcomes in math, code, and other contract-driven tasks.

Understand the main forms of knowledge distillation for LLMs, from logit matching and response-based supervision to on-policy KD. Learn when distillation helps, where student capacity becomes the bottleneck, and how to implement a correct teacher-student training loop.

Trace a typed decision from labeled state to option scores, compare Jev with inspectable Kev and SemIf methods, and learn the training and evaluation gates that make a decision model useful.

Learn model merging techniques, from simple weight averaging and task arithmetic to TIES-Merging and DARE, including practical guidance on tokenizer compatibility, mergekit workflows, and evaluation.

Trace graph hops, expose an IVF boundary miss, and test why compressed scores, filters, and shard tails can change nearest-neighbor results.

Compare query rewriting, HyDE, Self-RAG, and CRAG, then test retrieval coverage, support checks, fallback policy, and added cost on a docs assistant.

Build source-linked incident graphs, compare local retrieval with community-report search, and test where graph coverage, identity, and authorization can fail.

Stop a signing-key query from exposing a restricted runbook: authorize before export, isolate tenants, and audit the reject path.

Build reliable LLM interfaces with JSON mode, structured outputs, schema validation, and grammar-guided decoding.

Compare ReAct for tightly coupled tool use with Plan-and-Execute for longer workflows with explicit planning and replanning.

Build layered runtime guardrails for prompt injection, sensitive-data controls, structured outputs, policy enforcement, and safe tool use.

Build code agents that repair programs from runtime evidence while keeping untrusted execution separate from host authority and grading.

Build browser and desktop agents whose proposed clicks and keystrokes stay behind host policy, approval, verification, and sandbox controls.

Build approval gates, durable checkpoints, and guarded resumes for agent actions that change external state.

Turn coding tasks into bounded agent work with restricted execution, review branches, before-and-after evidence, and human-owned merge decisions.

Keep coding-agent context across sessions with scoped stores, sourced recall, and checkpoints, without letting a recalled note authorize a merge.

Recover from invalid proposals, lost replies, stalled plans, and dependency outages without duplicating actions or inventing success. Build and fault-test the runtime boundaries.

Learn Recursive Language Models (RLMs): keep long context in a programmable environment, delegate targeted sub-calls, and release the design only after measured quality, cost, and safety checks.

Decide when multiple agents earn their cost, then orchestrate them with typed shared state, parallel reads, a validated merge, and one approval-bound writer.

Build and test an agent runtime with fixture-based intake and evidence, bound tool calls, durable local approvals, and execution-derived evaluation rows.

Map prefill vs decode bottlenecks, measure TTFT and decode cadence, and size KV cache so concurrent sequences fit on one GPU.

Compare MHA, MQA, and GQA architectures, calculate their KV cache footprint, and reason about memory-limited serving tradeoffs.

Calculate KV cache capacity, trace paged block allocation, and separate memory packing from prefix reuse and scheduling tradeoffs.

Structure exact reusable prefixes, validate cache hits from usage fields, and enforce invalidation and tenant-isolation boundaries.

Understand how FlashAttention cuts auxiliary attention memory from O(n²) to O(n) with tiling and online softmax, and analyze its IO complexity.

Trace iteration-level slot reuse, budget prefill and decode work, and evaluate chunking or phase separation against TTFT, TPOT, and inter-token latency targets.

Size LLM serving from HBM bandwidth and KV residency: pick a throughput-latency-cost operating point, then compose batching, paging, speculation, and precision as capacity levers.

Learn tensor parallelism, pipeline parallelism, context parallelism, and how multi-GPU serving trades memory capacity for communication overhead.

Compare accelerator execution, memory, interconnect, and programming models through one LLM workload, then choose what must be remeasured when moving between NVIDIA, AMD, TPU, Trainium, and Apple silicon.

Build trustworthy GPU performance evidence: check kernel correctness, choose system or kernel profiling scope, control benchmark state, and preserve a reproducible receipt before claiming a speedup.

Optimize one CUDA matrix-transpose kernel through a repeatable evidence loop. Diagnose coalescing, shared-memory bank conflicts, occupancy limits, correctness failures, and the point where a reduction or scan is the right primitive.

Trace reduction, prefix scan and online softmax through concrete values, then check CUDA indexing and compare custom collectives with CUB.

Trace a GPU kernel from CUDA C++ or a tile language through compiler IR, PTX, cubin, and native instructions, then choose an authoring model by control, portability, and inspectable evidence.

Build one matrix multiplication through coalesced scalar CUDA, shared-memory tiling, register blocking, Tensor Core MMA, and the boundary where async copies and CUTLASS take over.

Build numerically sound FP16, BF16, TF32, FP8, and MXFP8 GPU paths by making scale, accumulation, layout, and kernel contracts explicit.

Master asynchronous CUDA submission with streams, events, graph capture, replay, updates, runtime dispatch, and correctness-first benchmark receipts.

Turn generated GPU code into a promotable library kernel through explicit operator contracts, hidden correctness tests, sanitizer gates, fair benchmarks, reproducible receipts, and controlled rollout.

Pack INT4 codes, follow GPTQ error compensation, and search AWQ channel scales. Budget GGUF tensors and test quality separately from storage and speed.

Build local model memory budgets, check GPU placement, distinguish offload from paging, choose a runtime, and verify latency and private-data boundaries.

Choose and adapt a small model for a device job: compare training signals and compact architectures, inspect runtime placement, and evaluate quality, memory, sustained speed, energy, privacy, and update recovery.

Propose tokens cheaply, verify with the target, and correct rejections without changing its distribution in exact arithmetic. Practice cache dependencies, tree masks, and performance decisions under load.

Master long-context LLM engineering: KV-cache math, prefill-vs-decode bottlenecks, RoPE scaling, lost-in-the-middle behavior, and long-context vs. RAG trade-offs.

Trace selected-expert computation, test routing and balancing assumptions, and account for stored weights, cache state, and dispatch from Mixtral to current hybrid MoE models.

Compute selective recurrences and prefix scans, compare Mamba-1/2/3, and test what fixed-state decoding saves, loses, and must restore when streams branch.

Choose between more samples, revision, and guided search. Test verifier failures, distinguish effort from hard limits, and account for reasoning tokens and shared cache state.

Follow a missing feature transform through release manifests, historical joins, canaries, and rollback. Test actual vector parity and reject stale controller decisions.

Serve one incident-summary request through continuous batching, paged KV, and an autoscaler driven by queue, cache, and TTFT pressure.

Diagnose one failing GPU replica, contain the smallest safe scope, preserve evidence, and re-admit hardware through explicit gates.

Follow an 8K prompt through rank collectives and KV handoff, calculate transfer and memory budgets, and test why expired buffers aren't immediately reusable.

Build a reproducible serving benchmark with a frozen arrival trace, explicit streaming timing boundaries, complete failure accounting, and SLO-qualified capacity estimates.

Take one docs-assistant prompt duel from a golden-set rubric to a live resolution-rate test with sticky routing and registered guardrails.

Design StreamShield's cascade: chat send decisions, upload holds, policy judges, appeals, and 10K RPS without one-model screening.

Design a real-time code completion path with context construction, measured serving latency, privacy controls, and stale-result suppression.

Design shared LLM serving with trusted tenant identity, atomic reservations, fair scheduling, scoped caches, and reconcilable usage records.

Design a permission-aware search pipeline with current evidence, hybrid ranking, auditable citations, checked streaming, and realistic latency and capacity boundaries.

Design a visual inspection and search product around CLIP, SigLIP, zero-shot prompts, visual token budgets, grounding, and generative VLM connectors.

Design a multimodal incident-evidence copilot while learning encoders, connectors, fusion, token budgets, training, grounding, and serving constraints.

Design a governed image-generation service while learning DDPM noising, stochastic sampling, latent diffusion, classifier-free guidance, DiT backbones, and text diffusion.

Design an incident-hotline voice agent: turn detection, streaming STT/LLM/TTS, native-audio trade-offs, WebRTC transport, and barge-in state.

Design a production reasoning agent that routes by difficulty, evaluates candidate work, requires evidence before release, and survives serving bottlenecks like key-value (KV) cache growth.

Build production-shaped Python systems under staged requirements: crawlers, TTL stores, schedulers, token buckets, ledgers, and thread-safe claim points.

Design AI lab systems with clear goals, scale math, APIs, data models, overload behavior, permissions, eval gates, and operational debugging paths.

Turn AI lab values into inspectable engineering stories: launch gates, incidents, disagreement, and ownership with metrics, not slogans.

Build a role-appropriate technical talk with explicit ownership, defensible comparisons, concrete failure cases, and honest limits on what the evidence proves.

Read vLLM as a living serving system: PagedAttention's memory idea, the V1 engine loop, block-pool caching, scheduling, kernels, APIs, and production tradeoffs.

Read SkyRL as replaceable RL interfaces: environments, generators, HTTP inference, trainers, weight sync, and async staleness control.

Read the Dao-AILab FlashAttention repo: exact tiled attention, online softmax, causal 2.1 alignment, FA2/FA3/FA4 packages, and when PyTorch SDPA is the better call.

Trace FlashInfer from irregular KV-cache layouts through load-balanced attention kernels, composable state, and production serving boundaries.

Read DeepGEMM as a GPU-kernel case study: tiled GEMMs, FP8/FP4 scaling, runtime JIT, the DeepSeek indexer, and Mega MoE overlap on a Flash-shaped expert layer.

Read NCCL as the communication engine beneath distributed AI: collective contracts, rings and trees, topology discovery, CUDA streams, transports, profiling, and hang diagnosis.

Read Megatron-LM and Megatron Core as a distributed training system: rank groups, parallel axes, optimizer sharding, MoE dispatch, low precision, and checkpoint operations.

Trace DeepSpeed from ZeRO ownership and dtype-aware memory accounting through gathered working sets, sharded Adam updates, offload, and checkpoint recovery.

Trace a real local Ray job through tasks, actors, object references, placement groups, and process failure, then connect those contracts to distributed AI libraries and serving.

Read MLflow as an evidence and lineage system for models and LLM applications: tracking, artifacts, traces, evaluation datasets, prompts, registries, storage, and governance.

Read PyTorch from storage and strides through dispatch, autograd, torch.compile, SDPA, FSDP2, DTensor, and distributed checkpoint, then debug the contracts that make LLM training work.

Read Hugging Face Transformers as a model-definition boundary: Hub revisions, AutoClass dispatch, PreTrainedModel lifecycle, device_map dispatch, tokenizers, multimodal processors, generation, caches, and serving integrations.

Read SGLang from a frontend program to a GPU step: RadixAttention, scheduling, constrained decoding, speculative execution, parallelism, and production boundaries.

Read slime as a SGLang-native RL post-training system: Ray placement, Megatron training, a token-level Sample contract, async rollouts, agent hooks, and weight-sync failure boundaries.

Trace DeepEP routing, gates, events, and logical bandwidth through pinned V2 kernels, then migrate to V2.5's EPBuffer, deferred epilogues, DeepJIT, and stricter runtime requirements.

Read Tinker as a hosted LoRA post-training service: local control loops, remote GPU workers, token-level RL contracts, pipelined clock cycles, checkpoint export, and the boundaries that separate an SDK from infrastructure such as DeepEP.

Read Light-PEFT as an academic early-pruning research release: frozen-backbone PEFT still pays forward cost, masks become physical structured pruning, and PEFT modules and ranks shrink before a longer fine-tuning run.