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.

Rebuild the access-request scorer in Python: inspect one JSONL row, validate fields, print the 0.667 receipt, keep a 2/3 count floor, and cover those contracts with pytest.

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.

Learn to count retrieval work, express growth with Big-O, pick scans, heaps, binary search, and prefix trees, and enforce a latency budget with runnable Python.

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.

Name the [4, 2] latency gradient as a vector, then grow it into row matrices, token tensors, dot products, and shape contracts you can check by hand.

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.

Turn 16 abusive flags out of 100 reviews into a rate, a Wilson interval, and a sampling-bias check, then refuse to treat a four-point calibration gap as proof.

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.

Trace a CodeAssist timeout-risk network from one neuron to a batched NumPy forward pass, then diagnose activation collapse, silent transposes, feature scale, and sigmoid overflow.

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

Follow a decode-latency model through a training loop, reverse-mode autograd, dense/ReLU/max-pool backward rules, mini-batches, validation, and PyTorch.

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 function returns the through masked attention, a decoder block, and next-token logits with readable NumPy and PyTorch code.

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 and test grounded prompts with clear roles, few-shot examples, structured outputs, evidence checks, and failure-focused evaluation.

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

Ship one traceable rotation-decision workflow: validated input, model boundary, stored status, clear UI states, failure tests, and deploy checks.

Follow one key-rotation assistant from pre-training through post-training, retrieval, a caller gateway, serving, evaluation, and the cheapest correct fix.

Fit key-rotation assistant latency by hand, implement least squares and gradient descent in NumPy, then test failure cases and held-out behavior.

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.

Measure empirical risk, selection bias, finite-class generalization bounds, sample complexity, and the limits of benchmark-driven model search.

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 scratch, calculate soft component responsibilities, trace expectation-maximization, and diagnose collapsed or misleading latent groups.

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

Turn retrieved API-key rotation evidence into controlled text by implementing stable softmax, sampling filters, constrained decoding, beam search, and decoder receipts.

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.

Build a PyTorch classifier from raw logits through autograd, validation, and reloadable checkpoints.

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 a boosted SLA-risk baseline from tabular features, evaluate slices, and package deployment evidence.

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.

Use Sutton's Bitter Lesson to compare rules, learning, and search, then allocate training FLOPs without treating compute as a slogan.

Build a small subword tokenizer, compare BPE, WordPiece, and SentencePiece, then audit fertility, camelCase splits, and Unicode policy.

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 the stateless MCP protocol, build a working stdio integration, and enforce version, authorization, and trust boundaries.

Move past fitting tokens into the window and learn context engineering: curate a high-signal working set, package reusable Agent Skills, and build resumable harnesses with durable checkpoints.

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.

Build a trustworthy human-feedback data flywheel: redact traces, write rubrics, measure agreement, select useful examples, prevent leakage, and promote versioned datasets.

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.

Turn a permission-safe hybrid candidate list into precise context using cross-encoder reasoning, ordering metrics, latency gates, and traceable evidence selection.

Evaluate a permission-safe RAG answer with claim-level faithfulness, citation support, first-failure attribution, and slice-aware release gates before automating softer judgments.

Add calibrated soft judgments to a RAG evaluation trace without letting an LLM override deterministic evidence gates.

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

Build a claim-level grounding gate for incident updates that verifies evidence, catches confident fabrication, abstains safely, and records release traces.

Turn claim-level answer traces into production metrics, actionable alerts, privacy-safe debugging records, and reproducible incident evidence.

Turn a live LLM regression into a reproducible candidate decision by logging inputs, metrics, artifacts, and promotion evidence.

Search DSPy instructions and few-shot demos on frozen deploy-answerer cases, then promote only a compiled artifact that beats the baseline on held-out gates.

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

Reuse stable policy answers across paraphrased questions without crossing release, access, or freshness boundaries; then prove the cache is both safe and worth serving.

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

Turn an audited cost contract into a model gateway that preserves data, schema, review, and budget requirements across routing and fallback.

Assemble a stateful support agent that grounds replies, gates credit actions, preserves gateway policy, and hands difficult cases to humans.

Ship an as-of arrival estimate and delay-warning service with honest historical uncertainty, versioned policy gates, baseline evidence, and monitored fallback.

Ship a marketplace ranking candidate with eligible retrieval, separate recall and NDCG gates, replayable exposure rows, and an A/B-ready rollback receipt.

Ship a demand forecast and capacity-alert artifact with rolling backtests, alert review, and retraining policy.

Ship a damaged-package photo triage service with quality checks, slice evaluation, serving bundles, and review monitoring.

Turn four shipped models into one receipt-bound promotion path: offline gates, canary windows, alias movement, and rollback.

Ship a policy-evidence service with controlled admission, cited answers, abstention, replayable eval rows, and source-bound semantic adjudication.

Build a release dashboard for document QA that turns replayable evidence rows into exact-coverage gates, uncertainty checks, and inspectable decisions.

Train and gate an access-ticket encoder that exports exact-receipt evidence and safe intake decisions to a production agent.

Turn one research paper into a falsifiable, public-safe ML study with paired experiments, uncertainty, reproducible artifacts, and a defensible report.

Learn how contrastive losses train sentence embeddings, why hard negatives matter, and how retrieval systems combine bi-encoders, rerankers, and dimension tradeoffs.

Learn vector scoring contracts, evaluate Matryoshka widths, and measure scalar, product, and binary quantization before deploying compressed retrieval.

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.

Choose FP16 or BF16 for an SFT run by measuring range, update resolution, memory, and held-out policy quality instead of assuming faster math is an upgrade.

Understand ZeRO stages, current FSDP2 fully_shard guidance, mixed-precision recipes that don't share one byte count, and when native PyTorch or DeepSpeed is the right choice.

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

Treat a training job as a resumable system: distinguish continue vs initialize vs export, save sharded state that can survive preemption, keep global batch and learning-rate scaling honest, and choose full SFT, LoRA, QLoRA, continued pretraining, or distillation from data, domain shift, and GPU budget.

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.

Turn a reward model into an aligned policy: run PPO-style RLHF with a KL budget, or skip the extra judge and train DPO on the same preference pairs, then catch reward hacking and likelihood displacement.

Understand how Constitutional AI reduces reliance on repeated human preference labeling through AI critique and ranking, and how automated red teaming stress-tests those safeguards.

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.

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.

Skip most of a 100-million-vector runbook index with HNSW, IVF, or PQ, then release from a measured Recall@5 versus latency curve.

Repair one messy docs-assistant search with rewrite, HyDE, Self-RAG, or CRAG, then release only the cheapest route that beats labeled evidence hits.

Answer one inference-api SLO question and one corpus-wide theme question from the same incident graph, then pay for reports only when vector top-k fails.

Stop one signing-key query from retrieving a restricted runbook: authorize in the trusted index, 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 test candidate patches inside bounded sandboxes with runtime evidence and defense-in-depth controls.

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.

Add validation checks, retries, checkpointed recovery, state reconciliation, loop breakers, and graceful degradation when LLM agents hallucinate, stall, or drift from their tools.

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.

Assemble classifier intake, cited policy evidence, approval-gated actions, and episode release tests into a production agent.

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.

Understand how LLM schedulers use continuous batching, chunked prefill, and prefill-decode disaggregation to improve throughput without violating TTFT, TPOT, or 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: prove 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.

Build reduction, prefix scan, arg reduction, and stable online softmax from one tensor, then decide when a tuned CUB primitive should replace custom CUDA.

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.

Make asynchronous CUDA submission measurable 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.

Understand how GPTQ, AWQ, and GGUF trade off accuracy, memory footprint, and portability when serving LLMs on GPUs or local hardware.

Plan local LLM deployment with model size, quantization, pruning and sparsity trade-offs, Docker packaging, runtime choice, and hardware budgets.

Specialize a small language model for a device job: distill from a teacher, pick compact architectures, compile for on-device runtimes, and ship only if quality, heat, battery, and privacy gates pass.

Reduce LLM inter-token latency by pairing cheap drafting with target-model verification. Learn the rejection-sampling proof, speedup model, method choices, and production rollout gates.

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 top-k MoE routing by hand, separate active FLOPs from full expert residency, and measure dense-vs-sparse serving from Mixtral through GLM-5.2 and DeepSeek V4 Flash.

Master linear-time sequence modeling: from S4 and HiPPO to Mamba's selective recurrence, Mamba-2's SSD framework, Mamba-3's inference-first refinements, and modern hybrid Transformer-SSM designs.

Understand how reasoning models trade extra inference compute for better answers, and what that means for search, verifiers, KV cache pressure, and routing.

Version prompts, features, and model aliases as one GitOps release tuple, catch embedding skew with a feature store, and roll back from live eval and latency signals.

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 one 8K-prompt request through routing, prefill, KV transfer, and decode while designing explicit admission, identity, retry, security, and SLO contracts.

Build a reproducible LLM serving benchmark from one versioned request trace, then find a stable release point using latency, fluidity, quality, and SLO-qualified goodput.

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 a shared LLM platform with tenant-scoped state, quota enforcement, adapter routing, KV accounting, and measured GPU utilization.

Design CodeAtlas search around one parser-v2 query: freshness routing, hybrid retrieval, evidence packing, citation checks, and streaming synthesis.

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.

Turn one production project into a 15-minute talk that defends architecture, tradeoffs, rollout, and metrics, then survives internals and failure-mode questions.

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.

Read DeepSpeed from its engine boundary through ZeRO state ownership, layer-time gathers, CPU and NVMe offload, pipeline limits, checkpoint recovery, governance, and source code.

Read Ray as a distributed execution substrate for LLM data, training, reinforcement learning, tuning, and serving: tasks, actors, objects, scheduling, ownership, and failure recovery.

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.

Read DeepEP from a four-token routing ledger through V2's ElasticBuffer, NCCL Gin, NVLink and RDMA topology, FP8 dispatch, and the archived V1 boundary.

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.