Course Series

Deep, structured series that take a topic from first principles to production — 126 series, 1172 lessons in total. Each one is a self-contained curriculum you can work through in order.

← Blog home · Browse by topic · Full archive

32 parts

Rust from the Ground Up

An original Rust curriculum, from first principles — Module 1 foundations (why Rust, Cargo, types/immutability, the ownership trio, structs/enums/pattern matching, error handling), Module 2 (collections, generics, traits, closures, iterators, smart pointers, modules), Module 3 (fearless concurrency with threads/Arc/Mutex/Send/Sync/channels, async/await, testing, ergonomic error handling with anyhow/thiserror, and macros), and Module 4 (advanced traits and types, unsafe Rust, FFI, closures/function pointers, building a real CLI application, the crate ecosystem and tooling, and performance/idioms). The Rust companion to the Go and Python curricula.

14 parts

AI Financial Engineering

AI Financial Engineering — the end-to-end discipline of building AI systems for finance, from data to production, where quant finance meets AI and being wrong costs real money. What AI financial engineering is (the synthesis of model-driven quant and data-driven AI; why finance makes it uniquely hard — real losses, mandatory explainability, auditability, adversarial non-stationary data, central human judgment), the data foundation (the treacherous financial data landscape; lookahead/survivorship bias and point-in-time correctness — where financial AI lives or dies), pricing and valuation engines (building the 'what is it worth?' core; AI as fast surrogate and as an extension into illiquid document-driven instruments), risk engines in production (VaR, stress testing, scenarios at scale; how AI accelerates and extends them, and the danger of making risk more confident and more wrong), machine learning in finance (an honest guide — where ML works (information, structure, credit, computation) and where it fails (market prediction), and the self-deceptions of backtest overfitting and leakage), forecasting markets (why financial series resist prediction — efficiency, noise, non-stationarity, fat tails, reflexivity — and forecasting volatility and distributions, not direction), NLP and LLMs on financial documents (reading filings, memos, indentures, and contracts at scale — the biggest new capability — with grounding, provenance, and hallucination defense), AI underwriting (turning deal materials into structured, pressure-tested, auditable judgment while keeping humans accountable), credit and position monitoring (continuous surveillance of covenants and thesis variance, with signal over noise), portfolio construction and aggregation (seeing the whole book clearly and surfacing hidden concentration), model risk, validation, and governance (inheriting SR 11-7 and handling AI's opacity, hallucination, and vendor risk; governance as the enabler of deployment), institutional memory (capturing judgment so it persists and compounds — perhaps the deepest value), productionizing financial AI (reliability, latency, security, and trust as the product), and the end-to-end stack (assembling it all, where value concentrates, and the principles that cohere the discipline). Educational — not financial advice. Grounded in Wikipedia (financial engineering, quantitative analysis, market data, alternative data, valuation, mathematical finance, value at risk, risk management, machine learning, time series, efficient-market hypothesis, NLP, large language models, underwriting, credit risk, loan covenant, modern portfolio theory, portfolio optimization, model risk, organizational memory, knowledge management, MLOps, site reliability engineering).

12 parts

Agentic Commerce

How AI agents pay: the emerging protocols (ACP, AP2, x402), agent identity and verifiable mandates, checkout and card-network flows, fraud and disputes, and how merchants become agent-ready.

12 parts

Agentic Software Engineering in Go

Agentic software engineering in Go — the discipline that replaces vibe coding with engineered AI-assisted development, built as working Go systems across twelve posts. The five pillars implemented end to end: context engineering (a curation engine that assembles architectural decision records, codebase conventions, and dependency constraints into every agent call, so identical prompts produce compliant code), specification engineering (machine-readable YAML specs with typed contracts, acceptance criteria, versioning, and spec-driven code generation replacing the English-prompt trap), AI-TDD verification loops (compile/test/lint/spec-conformance pipelines with structured failure feedback and bounded fix-retry), the complete harness (the pillars integrated into one configured, persistent, metered system — compared against ad-hoc workflows and traditional CI), and autonomy calibration (the AEMM maturity model and Elastic Loop formula computing per-task agent freedom from risk, context quality, confidence, and track record). Then the operational half: security and safety (input sanitization, prompt-injection defense, command sandboxing, RBAC, audit logging, incident response), the team operating model (git hooks, PR review automation, shared context repositories, onboarding), the daily developer workflow (spec authoring, prompt patterns, the ASF CLI), software factory orchestration (the Orchestrator–Worker–Validator triad with recovery, durability, and MCP integration), production operations (metrics, log correlation, tracing, A/B-tested continuous improvement), and a closing end-to-end case study taking an authentication service from YAML spec to production deployment. Grounded in Wikipedia (software engineering, TDD, software architecture, specifications, software verification, test harnesses, capability maturity models, prompt injection, sandboxing, multi-agent systems, orchestration, observability, A/B testing, continuous deployment).

12 parts

The AI Production Roadmap

Taking AI from prototype to durable production as a composed, governed system — strategy and ownership, governance, data foundations, building the system, evaluation, deployment, MLOps/LLMOps, security, observability, responsible AI, cost, and platformization.

12 parts

The Forward Deployed Consultant

The craft and business of forward-deployed consulting — a first-person, practitioner series on building a consulting practice around the forward deployed engineer model (embedding with a team to ship a real result on their real data, rather than handing over a deck or renting hours). What forward-deployed consulting is and how it differs from strategy consulting and staff augmentation; finding the first client (trust that already exists, not a funnel); scoping the first engagement to a bounded first win; pricing the outcome instead of hours (value-based pricing as a trust signal); the discovery phase (learning how the work really happens, what the data is really like, and what ‘good enough to trust’ means); earning trust in the first two weeks (small visible usefulness, credibility plus warmth, winning over the skeptic); saying no as the underrated consulting skill; building alongside the team rather than in a black box (knowledge transfer, pairing); the handoff (engineering your own obsolescence, handing over understanding not just artifacts); turning one win into a practice (referrals and repeat work that compound); staying independent and sustainable (avoiding burnout, financial and psychological independence); and the long game (reputation as the only durable asset, generosity as strategy, what stays when the technology changes). A companion to the technical [Forward Deployed Engineering] and [The AI Forward Deployed Engineer] series, focused on the practice itself and anchored in the multiplier mindset. Lightly grounded in references (Palantir, management consulting, value-based pricing, knowledge transfer, referral/word-of-mouth marketing, occupational burnout, reputation, Liz Wiseman’s Multipliers).

10 parts

Diffusion Models from First Principles

Diffusion models from first principles — how image and video generation actually works, from the problem diffusion solved to the systems generating media today. Why generating images is hard (generation is sampling from a learned distribution, not prediction; the thin data manifold; VAEs blur, GANs collapse, and the quality/diversity/stability trilemma diffusion escaped via iterative refinement), the forward process (a fixed Markov chain of Gaussian corruptions under a noise schedule, with a closed-form jump to any step and a known Gaussian endpoint), learning to denoise (small Gaussian steps reverse as Gaussians, so generation reduces to regression; DDPM's noise-prediction parameterization and the deliberately unweighted mean-squared-error loss; the four-line training loop and the thousand-evaluation sampling bill), the score-based view (the score as the gradient of log-probability pointing toward plausible images; Langevin dynamics; denoising and score matching as one computation; the forward SDE, reverse-time SDE, and the deterministic probability flow ODE), sampling faster (DDIM's deterministic walk — ~50 steps with zero retraining, invertible noise-space addresses; the sampler zoo as numerical ODE solving; the ~10-step curvature floor), latent diffusion (perceptual vs semantic information; the ~48× autoencoder compression behind Stable Diffusion; encoder/denoiser/decoder lifecycles; the autoencoder as quality ceiling), conditioning and classifier-free guidance (text encoders and cross-attention; why the honest conditional distribution follows prompts too loosely; CFG's condition-dropout training and extrapolated sampling, the guidance-scale knob, negative prompts), the U-Net to Diffusion Transformer migration (what the denoiser must be good at; skip connections and timestep embeddings; DiT's patchify-transform-unpatchify with adaptive-layer-norm conditioning, and the scaling economics that drove the switch), flow matching (generation as transport along a chosen velocity field; straight-line paths and the image-minus-noise regression; rectified flow and reflow toward one-step sampling; why Stable Diffusion 3 and Flux train this way), and distillation, consistency models, and video (progressive and adversarial distillation; consistency models' point-to-endpoint objective; video as the same stack over spacetime patches, where temporal coherence is attention across time). Grounded in Wikipedia (GAN, VAE, diffusion model, Gaussian noise, MSE, Langevin dynamics, SDE, numerical ODE methods, Stable Diffusion, latent space, text-to-image model, CLIP, U-Net, vision transformer, flow-based generative model, text-to-video model, knowledge distillation).

8 parts

Adopting AI in the Enterprise

Adopting AI in the enterprise — the organizational playbook for crossing the gap between an impressive pilot and AI woven into how a company actually operates. The adoption problem (pilots stall for organizational reasons — scoped to impress, value never defined, readiness skipped, nobody owning adoption; treat adoption as a repeatable compounding capability, not one-off projects; the lifecycle: identify → assess → orchestrate → scale → document → secure → adopt), finding high-value use cases (value × feasibility as a portfolio; the signatures of AI-suited problems and the honest anti-signatures; resisting AI theater; augmentation first; sequencing quick wins against foundational bets), AI readiness (four pillars — processes mapped as they actually run, data that's reachable/current/governed, systems that can be integrated with, culture that will actually use it; honest per-use-case assessment whose gap list becomes the roadmap), from task automation to agentic orchestration (tasks vs processes; agents automate the connective tissue and the routine majority; the earned-autonomy ladder — suggest, approve, review, bounded autonomy — with escalation designed first and every decision auditable), scaling from pilot to enterprise (platform proven by use case #3 shipping faster than #1, governance as the accelerator, hub-and-spokes enablement; scale by delivering), documentation and knowledge in the AI era (grounded AI makes the corpus the quality ceiling; writing to be retrieved; the living knowledge loop where AI's unanswered questions rank the backlog), preparing security teams (shadow AI as demand signal; the genuinely new surface — prompts as exfiltration, injection via content, agents as identities, fluent wrongness; the paved road and risk-tiered review), and driving adoption (name the replace-me fear, spread along trust networks, change the work and its incentives not just the tools, measure usage → penetration → outcomes → sentiment). Grounded in Wikipedia (digital transformation, diffusion of innovations, BPA/BPM, data governance, organizational culture, technology adoption life cycle, MLOps, knowledge management, RAG, shadow IT, prompt injection, change management) and Google's Rules of ML.

8 parts

Agent Memory Systems

Agent memory systems from first principles — how agents remember across sessions, learn from experience, and forget safely. Why agents forget (LLMs are stateless; the context window is working memory — bounded, ephemeral, unevenly attended — and memory is the system around the model: selection, organization, retrieval, updating/forgetting), the memory hierarchy (working/episodic/semantic/procedural — different jobs, storage, retrieval patterns, and lifecycles; most 'remembered wrong' bugs are type confusions), conversation memory and compaction (the buffer → sliding-window → selective-eviction → compaction ladder; preservation contracts, structured rolling summaries, boundary-triggered timing, and demote-don't-delete into episodic storage), retrieval memory (memory ≠ document RAG; relevance × recency × importance scoring with access reinforcement; write-side hygiene — self-contained memories, dedupe at the door, attached structure; budgeted injection with provenance labels), structured and graph memory (where similarity search breaks — aggregation, multi-hop, identity, current state; entity-centric records with resolved, superseding claims; knowledge-graph edges with temporal validity; the hybrid end state where structure answers precisely and episodes keep the receipts), memory as tools (the OS view — context as RAM, store as disk, the model participating in paging policy; file-based memory as the transparent, diff-reviewable baseline; consolidation and reflection as the highest-privilege writer, reviewed and evaluated like one), learning from experience (rules, playbooks, worked examples, failure memory; the act→attribute→reflect→encode→apply loop and its failure modes — misattribution, overgeneralization, rot, conflict; deploy-grade brakes on procedural writes), and memory in production (personal-data obligations, deletion that cascades along provenance, hard tenant isolation, memory writes as a prompt-injection surface, and layered evaluation ending in the memory-off ablation). Grounded in Wikipedia (working memory, LLM, episodic/semantic/procedural memory, short-term memory, automatic summarization, vector database, information retrieval, knowledge graph, ontology, virtual memory, memory consolidation, transfer learning, GDPR, data retention).

8 parts

Agent Skills

Agent Skills — designing, building, and deploying reusable agent skills (the SKILL.md pattern) that turn a general model into a reliable specialist at your specific work. The closed gap (a capable agent relearns everything every task; skills package instructions, knowledge, and procedure into self-contained, reusable, composable units loaded on demand — captured expertise made loadable), designing for the context window (the master constraint — context is finite AND precious because more context degrades focus; load only what's relevant, only when relevant, as compactly as possible; why skills beat big prompts), designing and building skills (information architecture under a context budget — scope to one coherent capability, a sharp trigger, clear prescriptive instructions, curated knowledge, deferred depth, iterate empirically and prune ruthlessly), patterns of work (composition for combinatorial leverage, chaining skills across a workflow, and the skill library as a curated compounding shared system), general business skills (capturing frequent convention-bound work — value in your specifics, not generalities), domain-specific skills (deep expertise demanding grounding, precise rules, verification, and the most rigor), skills in the wild (what succeeds and the operational failure modes — drift, overlap, trigger misfires, bloat, over-trust), and the skill reference (the anatomy of a skill definition, starter/domain/workflow/integration templates, and the synthesis). Grounded in Wikipedia (software agent, large language model, separation of concerns, modular programming, technical writing, workflow, business process automation, standard operating procedure, expert system, domain knowledge, best practice, software maintenance, Markdown).

8 parts

Agent2Agent Protocol from Scratch

The A2A protocol end to end — Agent Cards and discovery, the task lifecycle, the message/part/artifact content model, transports and methods, streaming and push notifications, security, and how A2A and MCP compose.

8 parts

Agentic RAG

Making retrieval reason — why naive RAG falls short, query transformation, routing and retrieval as a tool, self-correcting retrieval, multi-hop iteration, evaluation, and building an agentic RAG system that escalates cost only when a question needs it.

8 parts

AI Agent Design Patterns

A framework-agnostic guide to the recurring patterns for building LLM agents — what an agent is (the model directs the flow; agents vs workflows), the core reason-act-observe loop (ReAct), tool use, planning and decomposition, memory (short-term vs long-term), reflection and self-correction (Reflexion), multi-agent patterns, and building reliable agents (and when not to use agents at all).

8 parts

AI Cost Optimization

Controlling the cost of AI systems end to end — the token economy, model selection and routing, prompt and context optimization, caching, batching, RAG/fine-tuning/self-hosting trade-offs, and cost observability and AI FinOps.

8 parts

AI Evaluation and Benchmarking

How to measure LLM quality rigorously — why evaluation is the real bottleneck in shipping AI (turning "seems better" into a number), a taxonomy of metrics (exact/structural match, reference overlap like BLEU/ROUGE, semantic similarity, task-specific/functional), LLM-as-a-judge (pairwise vs pointwise, position/verbosity/self-preference biases, calibrating the judge against humans), building an eval harness (dataset, runner, scorers, report, golden sets, CI gating), how public benchmarks are designed and read critically (MMLU/HELM/BIG-bench, construct validity, saturation), contamination and Goodhart's law (held-out/private sets, dev/test splits), human evaluation and preference (inter-annotator agreement, arenas/Elo, RLHF), and evaluation in production (A/B tests, guardrail metrics, drift monitoring, the continuous loop).

8 parts

AI for the Energy Sector

How AI helps operate a decarbonizing electrical grid — why AI matters for the grid (rising complexity, real-time balancing), understanding the grid (generation/transmission/distribution, frequency, physical constraints), forecasting demand and variable renewable generation, balancing supply and demand (dispatch/optimization), the renewable integration challenge, demand-side flexibility (demand response, DERs, virtual power plants), grid reliability and assets (predictive maintenance, anomaly detection), and the future plus responsible AI for safety-critical infrastructure.

8 parts

AI Gateways and LLM Infrastructure

The control plane for model calls — why you need an AI gateway (the API-gateway pattern for LLMs: one choke point between apps and every provider), the unified API (one interface, gateway translates to each provider, decoupling apps from vendors so model-swapping is a config change), routing and load balancing (route by cost/capability/policy, spread load across providers and keys, LLM token-based limits), reliability (retries with backoff, transparent fallback across providers, circuit breakers, the gateway's own HA), caching (exact + semantic caching to cut cost and latency; when not to cache), rate limiting/quotas/budgets (enforced spend control and per-team chargeback), observability and governance (cost metering, tracing, guardrails, access control, audit — enforced centrally), and building/operating (build vs adopt vs buy, running it as critical infrastructure). Includes interactive archify architecture and request-flow diagrams. Grounded in LiteLLM, API-gateway/circuit-breaker patterns, OpenTelemetry.

8 parts

AI Governance in Practice

AI governance in practice — the operational, engineering-facing companion to AI Governance for Engineers (which covers the concepts): how to make governance actually run. The governance operating model (governance fails from an ownership gap, not missing principles; decision rights and accountability via the three lines of defense; named roles laddering to an executive owner; the mechanisms that give them teeth — an AI system registry, risk tiering, lifecycle gates), model risk management for AI (borrowing finance's proven MRM/SR 11-7 lifecycle — documented development, independent validation, risk-tiered approval, ongoing monitoring, revalidation/retirement — reframing each AI system as a managed risk position, and how AI stresses it with opacity, un-inspectable foundation models, open-ended generation, and scale), governing agentic AI (when the model can act, a wrong action escapes into the world; least privilege for tools/data, human-in-the-loop for consequential actions, bounded execution, agent identity, fail-safe defaults, action audit trails), governance as code (a policy in a PDF is advisory and fails at scale; make it imperative — version-controlled executable rules that run automatically and fail closed; a policy engine like OPA; what to encode as gates vs what needs human judgment), evaluation gates and evidence (can you stop a failing system, and can you prove the checks happened? gates that fail closed with teeth and legitimacy, and the automatic audit trail governance-as-code produces for regulators, auditors, and incidents), the EU AI Act in practice (a risk-based law — classify first, then high-risk obligations translate into concrete controls a mature program already runs; read the law as a specification, not theater; build to principles so you generalize to NIST RMF and future laws), monitoring and accountability in production (governance can't stop at deployment — drift, continuous bias, safety violations, with thresholds tied to action; durable owners, AI incident response, traceability, and redress for affected people), and standing up a governance function (from zero: visibility first — inventory, risk-tier, minimal owner-assigning policy — then controls highest-leverage-first in runnable layers, making governance an enabler that accelerates trustworthy AI). Grounded in Wikipedia (three lines of defence, regulation of artificial intelligence, model risk, algorithmic accountability, software agent, AI safety, infrastructure as code, audit trail, Artificial Intelligence Act, concept drift).

8 parts

AI Red Teaming

Red-teaming AI systems — adversarial testing, jailbreaks, attack taxonomies, and how to probe models and agents before attackers do.

8 parts

API Design

Designing APIs people love to use — resource modeling, versioning, pagination, errors, and the conventions that age well.

8 parts

API Security

Securing APIs end to end — authentication, authorization, rate limiting, input validation, and the OWASP API risks that matter most.

8 parts

Business Finance for Engineers

Financial literacy for technical people — why finance matters, the three statements (income statement/P&L, balance sheet, cash flow), the crucial profit-vs-cash distinction, unit economics (contribution margin, CAC/LTV), SaaS/recurring-revenue metrics (MRR/ARR, churn, NRR, Rule of 40), budgeting and forecasting, and reading financial health to make better decisions.

8 parts

C from the Ground Up

C for programmers who want to understand how computers actually work — why C and its four-stage compilation model (preprocess, compile, assemble, link; declarations vs definitions), types/variables/operators (fixed-width integers, signedness hazards, integer promotion, bitwise ops), control flow and functions (pass-by-value, the call stack, scope and lifetime), pointers (addresses, dereference, pointer arithmetic, NULL, pointer-to-pointer — the heart of C), arrays/strings/memory-layout (array-to-pointer decay, null-terminated strings, buffer overflows), dynamic memory management (stack vs heap, malloc/calloc/realloc/free, ownership, leaks/use-after-free/double-free, Valgrind), structs/unions/data-structures (typedef, padding, tagged unions, building a linked list), and the preprocessor, undefined behavior, and safe-C idioms. Rounds out the language-series set alongside Go, Python, Rust, and TypeScript.

8 parts

Caching Systems

How caching makes systems fast — why caching exists (locality, the memory-hierarchy principle), caching fundamentals (hits, misses, hit rate, what to cache), eviction policies (LRU/LFU/FIFO/TTL), the hard problem of cache invalidation (staleness, TTL vs explicit), caching patterns (cache-aside, write-through/back/around), distributed caching (Redis/Memcached, sharding, consistent hashing), web and CDN caching, and caching pitfalls (stampede, penetration, cold cache) and practice.

8 parts

Causal Inference for Engineers

Causal inference for engineers — the discipline of answering 'what happens if we act?', which prediction and correlation can't. Correlation is not causation (observing vs intervening; the three reasons correlation appears without causation — reverse causation, confounding, selection; why it's an engineering problem in A/B readouts, dashboards, and ML-driven decisions), potential outcomes (defining a causal effect as a counterfactual difference; the fundamental problem that you never observe both; targeting the average treatment effect by making groups comparable), confounding (a variable influencing both treatment and outcome — the central villain behind most spurious causal claims; confident wrong conclusions; the unmeasured-confounder nightmare; over-adjustment traps), randomized experiments (why randomization defeats all confounders at once including unknown ones; the A/B test as a genuine causal tool; the many ways real experiments fail — peeking, power, interference, broken randomization), causal graphs (DAGs that make assumptions explicit; chain/mediator, fork/confounder, collider; why controlling for everything is wrong and which variables to adjust for), observational methods (reconstructing comparable groups via adjustment, matching, and propensity scores; the unprovable 'no unmeasured confounding' assumption; sensitivity analysis), natural experiments (as-if-random variation from policies, lotteries, and cutoffs; instrumental variables, difference-in-differences, regression discontinuity), and causal inference in practice (a workflow for any causal question, how causal thinking fixes the costliest ML/analytics mistakes, and calibrated humility as the real rigor). Grounded in Wikipedia (causal inference, correlation does not imply causation, Rubin causal model, average treatment effect, confounding, randomized controlled trial, design of experiments, directed acyclic graph, propensity score matching, instrumental variables, difference in differences).

8 parts

Cellular Automata

Cellular automata from first principles — a foundational computer-science and complexity topic, the study of how complex global behavior emerges from simple local rules. What cellular automata are (a grid of cells, a few states, a neighborhood, one local uniform rule applied in parallel over discrete steps; the astonishing idea of emergence), elementary cellular automata (the simplest 1D two-state nearest-neighbor CAs, the 256 rules, Wolfram numbering, and the shock that Rule 30 is chaotic and Rule 110 complex — complexity among the very simplest rules), Conway's Game of Life (four rules, alive/dead cells, the menagerie of gliders, oscillators, guns, and methuselahs; the emblem of emergence), emergence and complexity classes (Wolfram's four classes, the 'edge of chaos' where complexity and computation live, and computational irreducibility — determinism does not imply predictability), computation and Turing completeness (Rule 110 and the Game of Life as universal computers built from emergent structures — gliders as signals, collisions as logic gates, stable patterns as memory — and undecidability), structures and self-replication (von Neumann's self-reproducing automaton, the universal constructor and the interpret-and-copy logic that anticipated DNA, Langton's loops, and artificial life), applications and modeling (fluid dynamics via lattice gas/Boltzmann, crystal growth, biological pattern formation, forest fires and epidemics, traffic — strengths and limits), and what cellular automata teach (complexity from simple rules, pervasive computation and the limits of prediction, and the computational-universe hypothesis). Grounded in Wikipedia (cellular automaton, emergence, elementary cellular automaton, Rule 30, Conway's Game of Life, A New Kind of Science, Turing completeness, Rule 110, von Neumann universal constructor, self-replication, lattice gas automaton, digital physics).

8 parts

CI/CD Pipelines from First Principles

CI/CD from first principles, tool-agnostic — what CI/CD is and why (integration hell, deployment fear, the pipeline, DORA), Continuous Integration in depth (a practice not a server: merge small/often, trunk-based, keep the mainline green), the build and test stages (test pyramid, deterministic/isolated tests, fail-fast staging, build-once-promote, caching/parallelism), Continuous Delivery vs Deployment (the human-gate distinction, environment promotion, choosing by fit), deployment strategies (blue-green, canary, rolling, feature flags), pipeline as code (declarative workflows/jobs/steps, GitHub Actions, DRY/pinning), security in the pipeline (DevSecOps: least-privilege credentials, secrets, SAST/SCA/DAST, SBOM/signing/SLSA supply-chain integrity), and operating/measuring pipelines (the pipeline as a product, fast recovery, observability, the four DORA metrics).

8 parts

Claude Code

Working effectively with Claude Code — the agentic, terminal-native coding tool — from mental model to hooks, skills, and real workflows.

8 parts

Code Review

The craft of code review — what to look for, how to give feedback, and the practices that make review a force multiplier, not a bottleneck.

8 parts

Coding Agents

Coding agents (SWE agents) from first principles — AI that independently does software tasks, one of the clearest practical AI successes. What a coding agent is (the shift from autocomplete to chat to agent; why code is a near-ideal agent domain because it's verifiable; the engineer's new role as director-reviewer), the agent loop for code (observe-decide-act-observe, closing the loop against code's concrete feedback — errors as rich signals — so the agent converges to working code; the loop is only as reliable as its feedback), grounding in the codebase (understanding a huge codebase through a small window via search, navigation, strategic reading, repo conventions, and semantic retrieval — most failures are comprehension failures), tools for coding agents (read/edit, shell, tests, search, version control — tool design determines quality, and safety is first-class: least privilege, sandboxing, confirmation, git as the undo button), planning and multi-step tasks (decompose, plan, track progress, manage context — the hierarchical structure that scales from edits to real engineering), verification and trust (verification drives self-correction and your trust; the layered toolkit of tests/type-checks/diff/human review; trust is earned through verification and the human stays accountable), evaluating coding agents (SWE-bench and measuring real capability by test-verified task resolution; the pitfalls of contamination, overfitting, weak tests, and cherry-picked demos), and coding agents in practice (where they shine vs struggle, working with them well, and the future of software engineering). Grounded in Wikipedia (software agent, pair programming, debugging, source code, information retrieval, command-line interface, version control, automated planning, decomposition, software testing, code review, benchmark).

8 parts

Computer Vision from First Principles

Computer vision from first principles — pixels to understanding, the foundations beneath the Multimodal AI series. Images as data (an image is just a grid of numbers; the semantic gap from pixels to meaning, made brutal by viewpoint/lighting/scale/occlusion/intra-class variation; why vision defeats hand-written rules and is a learning problem), classical computer vision (hand-engineered features — edges, corners, invariant descriptors like SIFT; still powering matching, stitching, and 3D/SLAM; the recognition ceiling that motivated deep learning), convolutional neural networks (convolution — a small learnable filter slid everywhere; local connectivity and parameter sharing giving translation invariance; stacking layers to build an edges→parts→objects hierarchy — the right inductive bias that cracked vision), CNN architectures (AlexNet launching deep learning, VGG's small-filters-deep, ResNet's skip connections making depth trainable and generalizing to transformers), object detection and segmentation (the task hierarchy beyond classification — bounding boxes, per-pixel semantic segmentation, instance segmentation; one-stage vs two-stage detectors, U-Net; powering self-driving and medical imaging), vision transformers (images as patch sequences; the inductive-bias-vs-data trade-off where ViTs win at scale; the unification of vision and language that enables multimodal AI), transfer learning and data (adapting pretrained models with a fraction of the data — feature extraction vs fine-tuning; labeling cost, representativeness, and augmentation as the real determinants), and computer vision in practice (approaching a problem, deployment realities — efficiency for real-time/edge, robustness to distribution shift, edge cases, monitoring — and the multimodal/foundation-model frontier). Grounded in Wikipedia (computer vision, digital image, feature detection, edge detection, convolutional neural network, residual neural network, object detection, image segmentation, vision transformer, transfer learning, data augmentation).

8 parts

Computer-Use / GUI Agents

Computer-use (GUI) agents from first principles — agents that operate software through its graphical interface the way a human does, a 2025-26 frontier capability distinct from API-and-tool agents. What they are (perceive by looking at the screen, act by simulating human input; the power to use any software including API-less apps; why the human interface is uniquely hard), how agents perceive the screen (vision-based multimodal interpretation vs structured accessibility/DOM data, and hybrid), how they act and the perceive-act loop (simulated input, intent-to-precise-action, closing the visual loop vs brittle RPA scripts), grounding in the UI (locating exactly where to click — coordinate vs element-based vs set-of-marks — and why mis-clicks are a top failure), reliability challenges (error accumulation over long tasks, brittleness, weak visual verification — why they're hard to trust and how to work within the limits), safety and bounded execution (broad power plus imperfect reliability plus prompt-injection exposure, bounded by least privilege, sandboxing, approval gates, and a kill switch), building computer-use agents (the architecture and the evolution from brittle scripted RPA to intelligent adaptive automation), and in practice (where they fit — API-less, bounded, supervised — the honest limits, responsible deployment, and the trajectory). Grounded in Wikipedia (graphical user interface, robotic process automation, computer vision, computer accessibility, software agent, test automation, object detection, reliability engineering, sandbox, prompt injection).

8 parts

Context Engineering

The discipline of curating everything a model sees at inference — the token budget, system prompts, retrieval, memory and history, tools and structured data, compaction and long context, and assembling it into a context pipeline.

8 parts

CrewAI, Concept by Concept

Building role-based multi-agent systems with CrewAI — agents (role, goal, backstory), tasks, crews and process, tools, event-driven Flows, memory and collaboration, and running CrewAI reliably and affordably in production.

8 parts

Cryptography Engineering

Applied cryptography for engineers who use it rather than invent it — the four guarantees (confidentiality, integrity, authenticity, non-repudiation), symmetric encryption and AEAD, hashing/MACs/password storage, public-key crypto and key exchange, signatures and PKI, TLS, key management, and the misuse pitfalls (randomness, timing, nonce reuse) that silently break sound primitives.

8 parts

Data Engineering

How raw data becomes usable — what data engineering is (the plumbing beneath all data work), data pipelines and the ETL→ELT shift, where data lives (warehouses, lakes, lakehouses, OLTP vs OLAP), data modeling for analytics (dimensional/star schema), batch vs streaming processing, the modern data stack (cloud, ELT, transformation-in-the-warehouse), data quality and governance (catching silent failures), and data engineering in practice (DataOps, serving analytics and AI).

8 parts

Database Internals

How databases actually work under the SQL — storage engines (B-tree vs LSM), pages and the buffer pool, the write-ahead log, indexes, transactions and isolation, MVCC, and query planning.

8 parts

DevSecOps

Security woven into the delivery pipeline — supply-chain integrity, SAST/DAST, secrets, policy-as-code, and shifting security left.

8 parts

DSPy, Concept by Concept

Programming language models instead of prompting them — signatures, modules, composed programs, metrics and evaluation, optimizers that compile your prompts, and building RAG and agents in DSPy that improve themselves against a metric.

8 parts

eBPF from First Principles

eBPF from the ground up — what eBPF is and why it matters (run sandboxed programs safely inside the Linux kernel at runtime, no module or rebuild; kernel power without kernel danger), the kernel/user-space boundary (why extending the kernel used to mean dangerous modules or limited user space, and eBPF as the third option), how eBPF works (programs, hooks, maps, the load path: bytecode → verifier → JIT → attach), the verifier and safety (static analysis proving termination and memory safety before a program runs — the central innovation), eBPF for observability (trace anything the kernel sees, low overhead, no app changes; bcc/bpftrace), eBPF for networking (XDP fast-path packet processing, load balancing, Cilium), eBPF for security (kernel-vantage detection and enforcement, LSM, Falco), and the ecosystem/building with it (CO-RE compile-once-run-everywhere, libbpf, language SDKs, where it is heading). Includes an interactive archify architecture diagram. Grounded in ebpf.io, kernel BPF docs, Brendan Gregg, Cilium, Falco.

8 parts

Emotional Intelligence for Engineers & Leaders

A practical guide to emotional intelligence for technical people — what EQ is and why it's the ceiling on technical careers, self-awareness, self-regulation (responding vs reacting), motivation and resilience, empathy and active listening, difficult conversations and feedback, influence and social skill, and EQ in leadership and teams (psychological safety) — framed as a learnable skillset, not a fixed trait.

8 parts

Event-Driven Architecture with Kafka

Building event-driven systems on Apache Kafka — why EDA, the log abstraction, producers, consumers and consumer groups, delivery semantics and exactly-once, schemas and event design, the core patterns (event sourcing, CQRS, outbox, saga), and running Kafka in production.

8 parts

Explainable AI and Interpretability

Explainable AI and interpretability from first principles — opening the black box, complementing the AI governance and ML series. Why interpretability matters (the accuracy-vs-interpretability trade-off and the black-box problem; why 'accurate but unexplainable' fails — trust, debugging models right for the wrong reasons, fairness, accountability, regulation; global vs local, model-specific vs agnostic), intrinsic vs post-hoc (two paths — transparent-by-design glass-box models giving faithful explanations vs explaining a black box afterward with possibly-unfaithful methods; the argument to prefer intrinsic for high-stakes problems), feature importance (the workhorse global method; permutation importance over biased built-in importances; the traps — correlated features and importance-is-not-causation), LIME (local model-agnostic explanation by locally approximating the model with a simple one; intuitive but unstable and gameable), SHAP (the field's default — game-theoretic Shapley values giving fair, stable, principled attribution that unifies local and global; TreeSHAP's efficiency; still attribution not causation), counterfactual and example-based explanations (what would change the outcome — actionable recourse; and similar-case reasoning — matching how humans explain), interpreting deep networks and LLMs (saliency maps, attention-is-not-explanation, probing, and mechanistic interpretability's partial reverse-engineering — with the honesty that we largely can't yet explain frontier LLMs), and interpretability in practice (matching method to need, the traps causing false confidence, and the skepticism that separates understanding from a rubber stamp). Grounded in Wikipedia (explainable artificial intelligence, black box, decision tree learning, random forest, surrogate model, Shapley value, case-based reasoning, large language model, right to explanation).

8 parts

Financial Engineering from First Principles

Financial engineering from first principles — an educational tour of quantitative finance for engineers, built on three ideas an engineer will recognize: the time value of money, the trade-off between risk and return, and no-arbitrage (nothing here is financial advice). What financial engineering is (math + statistics + computation applied to money; the three foundational ideas; valuation, risk, and no-arbitrage pricing), the time value of money (present value, future value, discounting, and the discounted-cash-flow method that prices anything with a future payoff), bonds and the yield curve (discounting's simplest real use — fixed cash flows priced by present value; yield, the inverse price-yield relationship, duration and convexity as interest-rate risk, and the yield curve as the market's price of time), risk and return (return as a random variable, volatility and covariance, diversification as the near-free lunch, systematic vs. idiosyncratic risk, the efficient frontier, and CAPM pricing risk through beta), derivatives and no-arbitrage (forwards, futures, and options; payoff shapes; the replication argument that prices a forward as S(1+r) with no forecast, and put-call parity), option pricing (Black-Scholes by dynamic replication; risk-neutral valuation and why the underlying's expected return drops out; what the model assumes, the volatility smile, implied volatility, and the Greeks traders hedge), randomness (prices as stochastic processes — Brownian motion and geometric Brownian motion; Monte Carlo simulation as a universal pricing-and-risk engine and the computational core of quant finance), and risk management in practice (Value at Risk and its tail-hiding flaw, expected shortfall, fat tails, hedging with the Greeks, market microstructure as a systems problem, and the overriding lesson that models are approximations that will eventually be wrong — so respect the tails and stay humble). Grounded in Wikipedia (financial/mathematical finance, time value of money, discounted cash flow, bonds, yield curve, modern portfolio theory, CAPM, put-call parity, Black-Scholes, the Greeks, geometric Brownian motion, Monte Carlo methods in finance, value at risk).

8 parts

Fraud and Risk ML Systems

Fraud and risk ML systems — the decision systems between RegTech's regulatory layer and the fintech handbook's money rails. The fraud problem (five textbook inversions: an adversary that adapts to the model, tiny base rates with asymmetric error currencies, labels that arrive late and lie a little, decisions that censor their own training data, and a milliseconds budget in the authorization path — fraud systems as decision factories, not classifiers), rules and models (rules for minutes-fast reaction, exact policy, explainability, and blind spots — with lifecycle discipline; GBDTs as the tabular workhorse with deep models at the embedding edges; composition as versioned, golden-tested code), features and feature stores (velocities, histories, graph neighborhoods, derived scores — and point-in-time correctness against feature time-travel, solved by one event-time definition materialized offline and online with parity checks and freshness SLOs), scoring and thresholds (precision at review capacity and recall at FP budget on time-split segmented data; calibration maintained against drift; thresholds as cost derivations moving with amount, extended into the approve/friction/review/decline ladder), the label problem (maturity horizons, labels as state trajectories, provenance-weighted noise handling, and censoring confronted with bounded exploration booked as data acquisition), drift and adaptation (detection cascaded by speed, responses laddered by cost, validation staged around label delay), humans in the loop (friction as behavior-based separation, review queues as operations and labeling engines with a declared capacity split), and risk in production (staged degradation in the money path, explainability as three products, prevention measured against counterfactual holdouts, loss-rate SLOs). Grounded in Wikipedia (credit card fraud, CNP, anomaly detection, gradient boosting, feature engineering, precision/recall, ROC, chargeback, selection bias, concept drift, adversarial ML, 3-D Secure, active learning, XAI).

8 parts

Git Internals

How Git actually works, from the storage model up — the content-addressed object model (blob/tree/commit/tag named by content hash), refs/HEAD and history as a directed acyclic graph (branches are pointers, reachability is the organizing idea), the index as a real staging-area file (the three trees), merge vs rebase demystified (the merge base, three-way merge, replaying commits), packfiles and delta compression (why snapshot-per-commit stays small), the reflog as a safety net (unreachable is not deleted), remotes/refspecs/fetch/push (collaboration as the same model across repos), and rewriting history safely (the golden rule, force-with-lease, revert for public history).

8 parts

Go-to-Market Strategy

A practical, engineer's guide to bringing a product to market and turning it into customers — what GTM is and why it matters as much as the product, knowing your market (segmentation, ICP, beachhead), positioning and messaging, GTM motions (product-led vs sales-led vs channel), pricing and packaging, channels and demand generation, launch and adoption (crossing the chasm), and measuring GTM (funnel metrics, CAC/LTV, retention).

8 parts

GPU Programming for AI Inference

GPU programming for AI inference — the hardware-and-kernel layer beneath the LLM Inference and Serving series: not how to run an inference server, but how the silicon actually executes a model and where the real bottlenecks live. Why GPUs power AI (neural nets are matrix multiplication — massively parallel; SMs, CUDA cores, tensor cores; the governing intuition that compute is cheap and data movement expensive, so peak FLOPS is a near-fiction), the memory hierarchy (registers → shared memory/L1 → L2 → HBM; capacity vs bandwidth limits; why LLM token generation is memory-bandwidth-bound — each token reads the whole model from HBM — which is why batching and quantization work), the roofline model (arithmetic intensity = FLOPs per byte; the compute-bound flat ceiling vs the memory-bound slant; prefill is compute-bound, decode is memory-bound, and batching raises intensity toward the compute ceiling), the CUDA execution model (threads/warps/blocks/grids, SIMT and branch divergence, latency hiding through warp oversubscription, and occupancy as the tuning tension), numeric precision (FP32/FP16/BF16/INT8-INT4; range vs precision; why fewer bits is a double win of less HBM traffic and faster tensor-core math; quantization and why LLMs tolerate it), the attention bottleneck and FlashAttention (naive attention materializes an N×N matrix in HBM — memory-bound and quadratic; FlashAttention tiles into shared memory, uses an online softmax, and fuses the kernel to never touch HBM — the archetype of inference optimization), memory management and the KV cache (it often exceeds the model weights; naive contiguous allocation wrecks concurrency with fragmentation; PagedAttention applies operating-system paging to fix it), and profiling and the optimization workflow (measure, don't guess: baseline → profile → find the dominant limit → apply the matching lever → repeat; when to stop, leaning on optimized libraries/serving engines, and the durable mental model). Grounded in Wikipedia (GPU, GPGPU, HBM, memory hierarchy, roofline model, FLOPS, CUDA, SIMT, FP16, bfloat16, transformer/attention, memory paging, profiling).

8 parts

Graph Neural Networks from First Principles

Graph neural networks from first principles — deep learning for relational data, complementing the Ontologies and Knowledge Graphs series. Why graphs need their own deep learning (standard nets assume a grid or sequence; graphs have no fixed size, no node ordering, and structure that is the information; the permutation-invariance and variable-structure requirements), node embeddings and graph tasks (embeddings fusing a node's features with its structural position; the three levels — node classification, edge-level link prediction, graph-level classification; the decisive transductive vs inductive distinction), message passing (the one mechanism behind every GNN — each node aggregates from neighbors and updates; stacking layers as k-hop receptive field, convolution generalized to graphs; over-smoothing and over-squashing), graph convolutional networks (the GCN baseline — degree-normalized averaging, semi-supervised node classification via label propagation under homophily, and the limits that motivate successors), GraphSAGE (inductive learning via a reusable neighbor-aggregation function plus neighbor sampling — the ideas that scale GNNs to billion-node industrial graphs and handle new nodes), graph attention networks (learned data-dependent neighbor weights — the transformer's attention adapted to graphs, with interpretability), training and scaling GNNs (why independence breaks, mini-batching and leakage-aware evaluation, sampling and partitioning, and the graph-specific failure modes), and applications and when to use GNNs (drug discovery, recommendation, fraud detection, knowledge graphs — and the honest baseline check for when a GNN is worth its cost). Grounded in Wikipedia (graph neural network, graph abstract data type, feature learning, convolutional neural network, attention, graph partition, knowledge graph).

8 parts

gRPC and Protocol Buffers

gRPC from the ground up — why RPC and gRPC (operation-centric calls, HTTP/2 + protobuf + codegen, when to use it over REST), Protocol Buffers as the contract and wire format (the .proto schema, tag-based binary encoding, field-number discipline and safe schema evolution), the four RPC types (unary, server/client/bidirectional streaming and when to use each), code generation and stubs (protoc, the generated client/server boundary, type safety across the network), deadlines/metadata/interceptors (deadline propagation, the metadata side-channel, cross-cutting middleware), error handling (the status-code model, rich error details, retryable vs terminal), streaming and backpressure (flows vs values, HTTP/2 flow control, writing streams that scale), and gRPC in production (request-level load balancing, TLS/auth, gRPC-Web and REST gateways, observability, evolving the contract safely).

8 parts

Guardrails and Prompt Injection Defense

How to build LLM applications that stay safe despite prompt injection — the defensive companion to red-teaming. Why prompt injection is unsolved (instructions and data share one channel; contain, don't prevent), a taxonomy of attacks (direct vs indirect injection, jailbreaks, the confused-deputy problem), input defenses and their hard limits (structural validation helps; filtering can't — indirect injection bypasses it), prompt hardening (delimiting, spotlighting, instruction hierarchy — probabilistic, not a fence), architecture and least privilege (the load-bearing defense: scoped tools, no privilege inheritance, human-in-the-loop, the dual-LLM pattern), treating model output as untrusted (XSS/SQLi/SSRF/exfiltration via output, context-specific encoding, structured output), guardrails in practice (moderation, injection classifiers, PII detection, layered defense in depth, fail-safe), and evaluating/operating guardrails (red-teaming your own system, production monitoring, NIST AI RMF, the honest state of the art). Grounded in the OWASP LLM Top 10, indirect-injection research, and the dual-LLM pattern.

8 parts

Hiring & People for Engineers and Leaders

A practical guide to hiring and people for engineers and technical leaders — why people are everything (the highest-leverage area), the hiring process (a funnel), interviewing and assessment (structured, bias-aware), onboarding (the neglected step), feedback and performance (growth over judgment, continuous over annual), growth and career development (linked to retention), retention and engagement (why people leave and stay), and building a great team (culture, diversity, people-first leadership).

8 parts

Kubernetes from First Principles

Kubernetes learned from the ground up — the problem it solves (declarative desired state + reconciliation), containers (namespaces/cgroups/images), pods, controllers, services and networking, configuration and state, scheduling and resources, and operators and production.

8 parts

LangChain, Concept by Concept

The broad, standardizing LLM toolkit concept by concept — what LangChain is (and how it relates to LangGraph), models/prompts/parsers, LCEL and Runnables, chains, retrieval and RAG, tools and agents, memory and state, and production with LangSmith.

8 parts

Legal & IP Basics for Engineers and Founders

An educational (not legal advice) guide to legal and intellectual-property basics for engineers and founders — why legal literacy matters (and when to get a lawyer), business entities (LLC/corporation, limited liability), the four IP types, copyright and software (code ownership, work-for-hire), patents/trademarks/trade secrets, software licensing and open source (permissive vs copyleft), contracts and agreements (NDAs, IP assignment, terms of service), and privacy/compliance (GDPR).

8 parts

LlamaIndex, Concept by Concept

LlamaIndex explained one concept at a time — documents and nodes, indexes and embeddings, retrievers, query engines, chat, agents, and workflows — for building data-centric LLM applications from prototype to production.

8 parts

LLM Inference and Serving

How large language models actually run in production — prefill vs decode, the KV cache, continuous batching, quantization, speculative decoding, serving engines (vLLM/PagedAttention), multi-GPU scaling, and tuning latency, throughput, and cost.

8 parts

LLMOps in Practice

LLMOps in practice — the hands-on operational discipline for running LLM-powered applications in production, the operational companion to The AI Production Roadmap. What LLMOps is (MLOps adapted for foundation models you didn't train, where behavior comes from prompting/retrieval/orchestration; the five properties that force a different playbook — opaque external models that change under you, prompt-defined behavior, fuzzy correctness, non-determinism, and new failures/token-costs), the LLMOps lifecycle (develop → evaluate → deploy → observe → improve as a loop the app lives inside; evaluation as a first-class stage appearing twice; production feedback flowing backward so the loop has memory; the loop turning whether you act or not), prompt and version management (the prompt is the source code; version the whole configuration — template + model + parameters + context strategy; decouple prompts from code; route every change through review, eval, rollout, rollback), eval-driven development (the curated eval set as the core asset; scoring open-ended output with deterministic checks, reference metrics, LLM-as-judge, and human review; gating every change and comparing B vs A; avoiding overfitting to the set), online evaluation and feedback (the offline–online gap; deploying to measure via canary, A/B, and shadow testing; explicit vs implicit feedback; the feedback pipeline that turns production behavior into improvement), guardrails and safety in production (the new failure modes — hallucination, prompt injection, data leakage, harmful output; layered fail-closed guardrails at input, output, and action; humans in the loop; red-teaming; guardrails as part of the lifecycle), observability and tracing (why ordinary monitoring isn't enough; tracing as the spine — spans capturing the rendered prompt, retrieved context, tool calls, raw output, tokens/latency/cost; aggregated into metrics, quality trends, drift detection, and cost attribution), and operating in production (cost and latency as first-class constraints — model routing, token hygiene, caching, batching, streaming, the cost–latency–quality triangle; preparing for incidents as certainties — provider failures, instant rollback, blameless postmortems; and the closing idea that operating is continuous improvement — a tightening loop, because an LLM app is never done). Grounded in Wikipedia (MLOps, large language model, CI/CD, version control, configuration management, evaluation of machine translation, test-driven development, A/B testing, RLHF, prompt injection, AI safety, observability, concept drift, site reliability engineering, incident management).

8 parts

Machine Learning from First Principles

Machine learning from first principles — the classical-ML floor beneath this blog's LLM and AI content, for engineers who never built it. What ML is (learning rules from examples instead of writing them; model, features, training, generalization; supervised/unsupervised/reinforcement/self-supervised paradigms), data and features (why they, not the model, decide outcomes — quantity, quality, representativeness as the root of bias; feature engineering as the model's vocabulary; the data-centric lesson), regression and linear models (linear and logistic regression; the universal loop of model-loss-gradient-descent that scales to LLMs; the learning rate; sigmoid to softmax), trees and ensembles (decision trees, random forests, gradient boosting, and why boosted trees still beat neural nets on tabular data), overfitting and generalization (ML's central problem; the bias-variance trade-off; the train/test split, leakage and contamination; regularization as Occam's razor), evaluating models (why accuracy lies on imbalanced data; the confusion matrix, precision/recall/F1, regression metrics, segment-level evaluation for fairness, and metrics as proxies — Goodhart's law), unsupervised learning (clustering, dimensionality reduction as the root of embeddings, anomaly detection, and evaluating without labels), and the ML workflow (framing, data prep, baselines, honest iteration, deployment and concept drift — the bridge to MLOps/LLMOps, and why classical ML isn't obsolete). Grounded in Wikipedia (machine learning, supervised learning, feature engineering, linear/logistic regression, decision trees, random forest, overfitting, bias-variance, precision and recall, cross-validation, cluster analysis, dimensionality reduction).

8 parts

Marketing for Technical Products

Marketing for engineers and technical founders — what marketing honestly is (and why the engineer's disdain is costly), brand and positioning, product marketing (the product-market bridge), content marketing and SEO, demand generation and the funnel, developer marketing (marketing to engineers), growth and growth loops, and measuring marketing (attribution, CAC/LTV, brand vs performance).

8 parts

Mixture of Experts and Modern LLM Architecture

How frontier LLMs are actually built — the shift from dense to sparse (compute-per-token welded to parameter count in dense models; conditional computation decouples capacity from per-token compute), the transformer backbone recapped (attention mixes information across tokens, the FFN block MoE replaces), Mixture of Experts core idea (many expert FFNs + a router picking top-k per token; total vs active parameters), routing and load balancing (expert collapse, the auxiliary load-balancing loss, expert capacity and token dropping, expert-choice routing), training and serving MoE (the compute-saved-memory-not trade, expert parallelism, all-to-all communication), the long-context problem (attention's quadratic compute vs the KV cache's linear memory), efficient attention (GQA/MQA shrink the KV cache, FlashAttention for fast exact attention, sliding-window/sparse to break the quadratic), and the anatomy of a modern frontier LLM plus where architecture is heading. Grounded in the MoE/Switch/Mixtral papers, Attention Is All You Need, FlashAttention, and GQA.

8 parts

Multimodal AI

How AI works across modalities — what multimodal AI is (beyond text, the shared-representation idea), how models see (CNNs to Vision Transformers), connecting modalities with CLIP and shared embedding spaces, vision-language models (LLMs that see), image generation with diffusion, audio and speech (recognition and synthesis), video and beyond (the temporal frontier), and building with multimodal AI toward the any-to-any future.

8 parts

Observability Engineering

Understanding systems you can't see inside — observability vs monitoring, the three pillars (metrics, logs, traces), OpenTelemetry, SLIs/SLOs/error budgets, alerting that respects on-call, and building the practice.

8 parts

On-Device AI with Gemma and Flutter

Building private, offline-capable AI that runs entirely on the user's phone — the case for on-device AI, edge constraints, quantization, the on-device runtime, running Gemma with flutter_gemma, on-device RAG, privacy-by-architecture, and shipping.

8 parts

Ontologies and Knowledge Graphs

Ontologies and knowledge graphs from first principles — for engineers who keep hearing the terms next to RAG and LLMs and want to actually understand them. What an ontology is (a formal, machine-readable description of a domain's things and relationships; the ladder from schema to taxonomy to ontology; classes, individuals, properties, axioms; why it gives LLMs a verifiable source of truth), RDF and OWL (all knowledge as triples so a triple set is a graph; URIs as global names; OWL's logic — inverse/transitive properties, cardinality, class expressions — grounded in description logic so a reasoner derives unstated facts and catches contradictions), knowledge graphs (the ontology populated; RDF vs labeled property graphs; why graphs win for connected problems — first-class relationships, flexing schema, meaning in structure), querying with SPARQL (pattern matching not joining; path expressions for arbitrary-depth connection SQL can't express; inference-aware queries over the reasoned graph; Cypher for property graphs), building knowledge graphs and entity resolution (construction is the hard 80%; the ingest-extract-map-resolve-load pipeline; entity resolution as make-or-break — under-merging fragments, over-merging asserts false links; deterministic/fuzzy/ML/graph-context matching; connectivity amplifies errors so provenance matters), GraphRAG (plain vector RAG retrieves disconnected chunks and misses relationships; GraphRAG retrieves a subgraph by traversing the graph so multi-hop answers are walked not guessed — typed, verifiable, citable; when to use it and why hybrid wins), the semantic layer (the enterprise ontology made operational — define entities, relationships, and metrics once so dashboards, analysts, and AI agents inherit the same definitions; why 'revenue' means three things; why AI made it urgent), and operating knowledge graphs in practice (a system you run not a project you finish — governing the ontology as it evolves, keeping the populated graph correct, and the honest build-or-not decision). Grounded in Wikipedia (ontology, taxonomy, RDF, OWL, knowledge graph, graph database, SPARQL, Cypher, record linkage, named-entity recognition, retrieval-augmented generation, Semantic Web, data virtualization, data governance).

8 parts

Operating Systems for Engineers

The OS concepts that matter to engineers building on top of it — what an OS does (resource management + abstraction), processes, threads and concurrency, CPU scheduling, virtual memory, the memory hierarchy, I/O models, and why OS knowledge turns production mysteries into diagnosable problems.

8 parts

Operations & Org Design

How a company runs and structures itself to work effectively, especially at scale — what operations is (the invisible enabler), processes and systems (good process vs bureaucracy), organizational structure (functional/divisional/matrix tradeoffs), org design and Conway's law (org structure shapes what you build), scaling teams and communication overhead, decision-making (decision rights, centralized vs distributed, quality vs speed), organizational culture, and operational excellence.

8 parts

Platform Engineering

The DevOps-to-platform-engineering arc — from DevOps and its cognitive-load problem through CI/CD, infrastructure as code, and GitOps, to internal developer platforms, golden paths and developer experience, reliability, and building and adopting a platform as a product.

8 parts

Privacy-Preserving Machine Learning

Privacy-preserving machine learning — the techniques for learning from sensitive data without exposing it, the engineering end of AI privacy. Why privacy in ML (ML wants more/centralized data, privacy wants less/minimized; why anonymization fails to re-identification and securing data doesn't secure the model; privacy ≠ security ≠ anonymity), how models leak data (memorization; membership inference, model inversion, training-data extraction, model stealing — many via black-box API access, so the model is itself sensitive data), differential privacy (a mathematical guarantee — the output is essentially the same with or without any individual; calibrated noise, the privacy budget ε, the privacy-utility trade-off; the gold standard used by the US Census, Apple, Google), differential privacy in practice (DP-SGD — per-example gradient clipping, noise, and privacy accounting put a provable guarantee inside a model; the knobs and the honest costs including a privacy-fairness tension), federated learning (train where data lives and share only updates — data minimization by architecture; but updates leak, so combine with DP and secure aggregation), secure computation and homomorphic encryption (computing on data that stays encrypted — private inference and secret-sharing/secure aggregation — the strongest and most expensive tools), synthetic data and anonymization (safe-to-share data and its traps — fragile anonymization, memorizing generators, and differentially private synthetic data), and privacy-preserving ML in practice (start with the threat model, compose techniques for defense in depth, anchor on differential privacy's provable guarantee, and price the trade-offs). Grounded in Wikipedia (information privacy, data re-identification, differential privacy, stochastic gradient descent, federated learning, homomorphic encryption, secure multi-party computation, synthetic data, data anonymization).

8 parts

Product Management for Engineers

A practical guide to product management for engineers — what PM actually is (owning the why and what, not the how; myths dispelled), understanding the problem (discovery, problems over solutions), prioritization (the core skill of saying no), product strategy and vision, working with engineering and design (the product trio), metrics and data (measuring real value, data vs judgment), shipping and iterating (MVP, product-market fit), and PM in practice and as a career (including product-minded engineering).

8 parts

Pydantic AI, Concept by Concept

The type-safe Python agent framework from the Pydantic team, concept by concept — agents, structured outputs, tools, dependency injection, messages and streaming, testing and evals, and production.

8 parts

Reasoning Models & Test-Time Compute

How modern reasoning models work and how to use them — thinking before answering, chain-of-thought and self-consistency, test-time compute as a new scaling axis, training via RL on verifiable rewards, inference-time techniques (best-of-N, verifiers, search), the economics of thinking tokens, prompting and usage differences, and the limits (faithfulness, diminishing returns, evaluation) and frontier.

8 parts

Recommender Systems from the Ground Up

Recommender systems from the ground up — the recommendation problem (match people to items from a huge catalog, personally and in real time, from sparse noisy interaction data; explicit vs implicit feedback; scale, personalization, cold start, latency), collaborative filtering (recommend from the behavior of similar users/items using only the interaction matrix; user-based vs item-based; similarity measures; serendipity, sparsity, and cold-start limits), content-based filtering and cold start (recommend by item features; handles new items and niche users; the three faces of cold start and the toolkit — content features, onboarding, popular fallbacks, exploration; why hybrids win), matrix factorization and embeddings (latent factors, the dot-product model, the Netflix Prize; users and items as embeddings in a shared space — the seed of the modern field), the two-stage architecture (retrieve-then-rank: candidate generation narrows millions to hundreds via embedding ANN search, then a precise ranker orders them, then filtering/shaping — the same pattern as search and RAG), deep-learning recommenders (two-tower retrieval and rich neural ranking with cross-features, sequences, and multi-objective), evaluating recommenders (ranking metrics like NDCG/Precision@K, online A/B testing as ground truth, the offline-online gap and exposure bias, feedback loops), and production recommenders (millisecond serving, freshness, cold start and the long tail, filter bubbles and responsible recommendation, and a practical build path). Includes an interactive archify pipeline diagram. Grounded in Wikipedia, Google's ML recommendation course, and the Netflix Prize.

8 parts

RegTech: Compliance as Engineering

Building regulatory compliance as software — compliance as an engineering discipline, KYC and identity verification, AML transaction monitoring, sanctions screening, immutable audit trails, data privacy, regulatory reporting, and the integrated compliance platform.

8 parts

Reinforcement Learning from First Principles

Reinforcement learning from first principles — the third ML paradigm and the backbone of RLHF, built from the ground up. What RL is (learning to act by interacting with an environment to maximize cumulative reward — no answer key; the agent-environment-reward loop, the policy, delayed reward and credit assignment, exploration vs exploitation), Markov decision processes (the formal frame — states, actions, transitions, reward, discount; the Markov property; reward design and reward hacking as RL's decisive difficulty), value functions and the Bellman equation (estimating long-term value; V and Q functions; the recursive Bellman relation that solves credit assignment; planning vs learning), Q-learning and temporal-difference learning (learning value from experience, model-free, bootstrapping; off-policy learning, ε-greedy, and why the Q-table can't scale), deep reinforcement learning (neural function approximation; DQN from pixels, AlphaGo; instability and the fixes — experience replay, target networks; sample-inefficiency), policy gradients and actor-critic (learning the policy directly for continuous and stochastic control; high variance; actor-critic and PPO — the bridge to RLHF), RLHF (you can't write a reward for 'helpful, honest, harmless', so learn one from human preferences and optimize with PPO; the three-stage pipeline; the KL constraint against reward hacking; limits like sycophancy), and when to use RL (where it shines — games, control, alignment — and where a simpler method is the honest choice). Grounded in Wikipedia (reinforcement learning, multi-armed bandit, Markov decision process, Bellman equation, dynamic programming, Q-learning, temporal difference learning, deep reinforcement learning, proximal policy optimization, RLHF).

8 parts

Sales & PreSales for Engineers

Sales for technical people who dislike selling — reframing sales as honestly helping customers solve problems, the sales process and pipeline, discovery and qualification, the presales/sales-engineer role, demos and proofs of concept, objections and negotiation, consultative and solution selling, and how sales connects to product and the whole business.

8 parts

Search and Information Retrieval

Search and information retrieval from first principles — the classical-retrieval twin of the Vector Search Internals series, and the foundation under RAG. The retrieval problem (finding relevant information in billions of documents in milliseconds; the two problems of matching and ranking; why scanning fails; the offline-index/online-retrieve pipeline RAG reuses), the inverted index (the word→documents structure that makes search fast; postings lists, intersecting them, and web-scale sharding), text analysis (tokenization, normalization, stemming vs lemmatization, stop words, synonyms — the preprocessing that quietly decides quality), ranking with TF-IDF and BM25 (the math of relevance — frequent-in-document, rare-across-documents; BM25's saturation and length normalization; the baseline hard to beat; its lexical vocabulary-gap ceiling), evaluating search (why precision/recall ignore order; rank-aware metrics precision@k, MRR, NDCG; offline test collections and online A/B tests — the same metrics that evaluate RAG retrieval), learning to rank (combining hundreds of signals via ML — pointwise/pairwise/listwise, gradient-boosted rankers — and the bridge to neural ranking and embedding retrieval), semantic and hybrid search (matching meaning via embeddings and nearest-neighbor search; why semantic is weak at exact matches; why hybrid keyword+vector retrieval wins and powers RAG), and building a search system in practice (the anatomy, buy-vs-build, continuous relevance measurement, and why the retriever caps a RAG system). Grounded in Wikipedia (information retrieval, full-text search, inverted index, search engine indexing, stemming, lexical analysis, tf-idf, Okapi BM25, evaluation measures, discounted cumulative gain, learning to rank, nearest neighbor search, vector database).

8 parts

Self-Evolving Agents

Agents that improve themselves — memory and reflection, self-refining prompts, tool and skill acquisition, self-critique loops, population methods, and the evaluation and guardrails that keep evolution safe.

8 parts

Self-Evolving Agents: The Frontier

The research frontier of agents that evolve their own design — automated design of agentic systems, evolutionary and population search, self-play and co-evolution, reflective optimizers, meta-agents and self-reference, evaluating open-ended improvement, and the real limits and risks.

8 parts

Self-Evolving AI: A Taxonomy

The organizing map for self-evolving AI — the series that sits above this blog's two mechanism-level self-evolving-agents series and answers three questions for any system wearing the label: what evolves, what feedback drives it, and where does the loop close? The anatomy (model, harness, artifact) and the three loci of evolution: artifact evolution in depth (the generate–evaluate–refine loop as evolutionary computation with an LLM mutation operator; the verifier spectrum from exact checkers through measured execution and test suites to proxy scores and LLM judges, with each tier's signature failure and the pressure-budget rule), harness evolution located rather than re-taught (context, capability, and structure sublayers; the four structural reasons scaffolding dominates production; the elicit-never-exceed ceiling and its symptoms), and model evolution without gold answers (consensus as pseudo-truth, self-play as curriculum, verifier reward, environment signal — and the shared circularity of training on model-shaped data, contained by anchors, held-out evaluation, and deploy-grade gating; test-time training as weights-deep adaptation at cache-entry blast radius; continual learning, catastrophic interference, and the replay/regularization/isolation triad under the stability–plasticity dilemma). Then the two cross-cutting axes: feedback (the five-type strength ladder, Goodhart thresholds, and the cascade architecture with inter-stage agreement as the drift alarm) and loop closure (within-task to online-continuous, with gating rising to match blast radius) — closing on composed stacks, three-axis governance, and delivered artifacts as the only ungameable success metric. Grounded in Wikipedia (recursive self-improvement, software agents, genetic programming, evolutionary computation, automated theorem proving, software testing, self-modifying code, semi-supervised learning, reinforcement learning, catastrophic interference, online machine learning, Goodhart's law, feedback, scientific method).

8 parts

smolagents, Concept by Concept

Hugging Face's minimal, code-first agent library concept by concept — what smolagents is, code agents (actions as code), why code actions win, secure sandboxed execution, tools, models, the agent loop and multi-agent systems, and when to use it.

8 parts

Software Supply Chain Security

Defending the software supply chain (DevSecOps) — the new attack frontier (you ship your dependencies' code and the build that assembled it; SolarWinds/Log4Shell/registry attacks; shift from implicit trust to explicit verification), the anatomy of attacks (typosquatting, dependency confusion, compromised packages/builds, maintainer social engineering), dependency security (pinning/lockfiles, SCA scanning, update discipline, minimizing deps), SBOM (a complete inventory to answer "are we affected?" in minutes; SPDX/CycloneDX), provenance and attestation (in-toto, SLSA levels, verifiable build metadata), signing and verification (Sigstore keyless signing, transparency logs, verify-before-use), securing the build (isolation, hermetic and reproducible builds, unforgeable platform-generated provenance), and building a program (highest-leverage-first roadmap, enforce in pipeline, continuous scanning, governance). Grounded in CISA/SBOM, SLSA, Sigstore, OpenSSF.

8 parts

Startup Funding & Fundraising

A practical guide to startup funding for technical founders — why and how companies raise, the funding stages (bootstrapping through Series C), equity/cap tables/dilution, valuation (pre- vs post-money), early instruments (SAFEs and convertible notes), term sheets and key terms (liquidation preferences, control), alternatives to VC (bootstrapping, revenue-based financing, venture debt, grants), and the fundraising process and investor relations.

8 parts

Stream Processing from First Principles

Stream processing from first principles — computing on unbounded data in motion, the companion to the Event-Driven Architecture with Kafka series. What stream processing is (batch vs stream; unboundedness as the source of all difficulty; when latency justifies streaming over simpler batch), events/streams/time (the core dataflow model and the crucial event-time vs processing-time distinction), watermarks (reasoning about late, out-of-order events; the completeness-vs-latency tradeoff made explicit), windowing (turning the infinite stream into finite answers — tumbling, sliding, session windows; triggers), state and stateful processing (why remembering across events is streaming's hardest problem — bounding, speed, keyed partitioning, surviving failure), fault tolerance and exactly-once (at-most/at-least/exactly-once guarantees; checkpointing, replayable sources, and transactional sinks), stream processing systems (Flink, Spark Structured Streaming, Kafka Streams, cloud services, and the Beam/Dataflow model; how to choose; streaming SQL), and stream processing in practice (designing pipelines, the operational realities of a forever-running stateful service, and reaching for streaming only when latency justifies it). Grounded in Wikipedia (stream processing, batch processing, event, event-driven architecture, complex event processing, state, Apache Flink, Apache Kafka).

8 parts

The AI Cost Optimization Playbook

A detailed, vendor-grounded playbook for cutting AI and cloud cost — the four governing frameworks, the ranked inference levers (caching, batching, token hygiene, model selection, effort tuning, budgets, commitments), cloud fundamentals, measurement and unit economics, and developer-tooling spend. Every figure is the vendor's own directional number — verify on your workload.

8 parts

The AI Forward Deployed Engineer

The technical playbook for deploying AI/LLM systems inside a customer's environment — the AI-specific companion to the foundational Forward Deployed Engineering series. The rise of the AI FDE (the Palantir-born role exploded in the AI era because frontier models widened the demo-to-value gap; a model is a capability, not a solution; the FDE does the hard 80% — grounding, evaluation, integration, trust), scoping an AI use case (fit vs value, resisting AI theater, when AI is/isn't the right tool, augmentation over automation, picking a measurable wedge), from demo to pilot (the AI demo is a trap dressed as a triumph — cherry-picked inputs with failures edited out; use it to win belief then cross the chasm from a prompt to a system), grounding AI in the customer's data (retrieval-augmented generation reference architecture: ingest/clean/chunk/embed into a permissioned vector store, then retrieve/rerank/ground via a gateway with citations; messy+permissioned+incomplete data; bad answers are usually retrieval failures — with an interactive archify architecture diagram), evaluation and trust (you can't ship AI you can't measure; the customer's own eval set as crown jewel; offline+online; safe failure via abstention/citations/human-in-the-loop; trust is demonstrated not given), integrating AI into real workflows (value happens in the workflow not the model; UX of uncertainty; calibrated reliance; autonomy spectrum assistive→augmented→autonomous; change management), productionizing and handover (cost as a first-class constraint, latency, drift, observability, the AI gateway; making yourself unnecessary; transferring the eval discipline and runbook, not just code; permanent human-in-the-loop where stakes demand), and from bespoke AI to product (bespoke-first is right for AI; the rule of repetition; extract the recurring substrate — grounding pipeline, eval harness, gateway/observability, guardrail/UX patterns — into a platform; the flywheel and the AI FDE career arc). Grounded in Wikipedia (Palantir, RAG, human-in-the-loop, MLOps, concept drift, change management, TCO, solution architecture), the RAG paper (Lewis et al. 2005.11401), and Google's Rules of ML.

8 parts

Time-Series Forecasting from First Principles

Time-series forecasting from first principles — predicting the future from the past, the ML specialization the foundations series set aside. What makes time series special (data ordered in time breaks ML's i.i.d. assumption — order matters, observations are autocorrelated, the data is non-stationary; why dependence makes forecasting possible yet hard), components and decomposition (trend + seasonality + noise, additive vs multiplicative; pulling them apart to see predictability and guide modeling), classical methods (exponential smoothing / Holt-Winters as weighted memory, and ARIMA modeling autocorrelation directly — still state-of-the-art for much real forecasting, strong on limited data, the humbling M-competition result), evaluation and backtesting (why random train/test splits are catastrophic — future leakage; walk-forward validation respecting time order; always comparing against naive baselines — evaluation matters more than the model), machine learning for forecasting (reframing as supervised learning via lag/rolling/calendar/driver features and gradient-boosted trees; global models across many series; the traps of feature leakage, multi-step forecasting, and trees that can't extrapolate trend), deep learning for time series (RNNs/LSTMs, temporal CNNs, transformers, and time-series foundation models — where they shine and the honest reality that simple methods often beat them on individual series), probabilistic forecasting (predicting the distribution not a point — prediction intervals, quantiles, calibration, and uncertainty growing with the horizon), and forecasting in practice (the complexity ladder from naive baselines up, shipping with monitoring and retraining for drift and shocks, and the hard-won lessons — start simple, respect baselines, forecast uncertainty, stay humble). Grounded in Wikipedia (time series, forecasting, decomposition of time series, seasonality, ARIMA, exponential smoothing, backtesting, gradient boosting, long short-term memory, prediction interval).

8 parts

TypeScript from the Ground Up

TypeScript for engineers who already program — why put types on JavaScript (a structural type checker that erases to plain JS at build time), the structural type system (structural vs nominal, inference, interface vs type, literal types, any/unknown/never), unions and narrowing (discriminated unions, control-flow narrowing, exhaustiveness with never, custom type guards), generics (type variables, constraints, keyof, default parameters), utility and mapped types (Partial/Pick/Omit/Record, keyof/indexed access, mapped/conditional/template-literal types — computing types from types), typing async code and the event loop (Promise<T>, async/await, Promise.all, unknown errors), modules/config/tooling (ES modules, tsconfig, strict mode, declaration files, transpile vs type-check), and idiomatic TypeScript at scale (annotate boundaries, avoid any, make impossible states impossible, migration). Completes the language-series set alongside Go, Python, and Rust.

8 parts

Usage-Based Billing and Monetization Engineering

Usage-based billing and monetization engineering — the revenue-side system above the fintech handbook's money rails: deciding how much money should move, for whom, when, and proving it was right. Why billing is an engineering problem (correctness-critical and time-dominated; overcharge burns trust publicly, undercharge leaks silently, double-charge is a distributed-systems bug, price drift makes no copy authoritative — and the AI era makes usage pricing the default), pricing models in code (flat/per-seat/graduated-vs-volume tiers/usage/hybrids as one abstraction: price = versioned data; immutable versions pinned by subscriptions; no amounts in application code), metering (emit→ingest→aggregate→rate with invoice-grade obligations: deterministic source-minted idempotency keys, event-time aggregation with grace windows, compensating events, and the two-meter pattern — streaming approximate for product, batch exact for the invoice), the subscription state machine (explicit lifecycle states, four questions per edge, proration policies, scheduled transitions as first-class records), invoicing and collection (immutable re-derivable invoices, credit notes not edits, and dunning as failure engineering — hard vs soft declines, deliberate retry schedules, notification as machinery), entitlements (features/grants/resolution decoupling capability from payment; plans as versioned grant bundles; quotas enforced against the streaming meter), testing billing (injected clocks driving month-long lifecycles in milliseconds, golden invoices, re-derivation audits, property tests on the arithmetic), and revenue integrity (billing↔processor↔settlement reconciliation with owned exception queues, revenue recognition from emitted service periods, and MRR with movements as versioned derivations). Grounded in Wikipedia (subscription model, SaaS, pricing, price discrimination, stream processing, idempotence, FSMs, pro rata, invoice, dunning, access control, feature toggles, software testing, discrete-event simulation, revenue recognition, reconciliation).

8 parts

Vector Search Internals

How approximate nearest-neighbor search actually works — the recall/latency/memory triangle, distance metrics, brute force, IVF, HNSW, vector quantization, filtering and hybrid search, and choosing and operating an index in production.

8 parts

Voice and Conversational AI

Building real-time voice agents from the ground up — the anatomy of a voice agent (the cascaded pipeline: microphone → VAD → ASR → LLM → TTS → speaker, looping each turn), speech-to-text (Whisper-style ASR, streaming vs batch, endpointing), the LLM turn (time-to-first-token, speech-friendly concise output, conversation state under latency pressure), text-to-speech (streaming synthesis, text normalization, voice choice and ethics), latency (the make-or-break constraint and how streaming everything collapses additive delay), turn-taking and barge-in (endpointing, interruption, echo cancellation, cancelling in-flight work), speech-to-speech and the new realtime architectures (cascade vs end-to-end multimodal tradeoffs), and building/productionizing (telephony, robustness, holistic evaluation, deployment). Includes interactive archify pipeline and conversation-turn diagrams. Grounded in Whisper, VAD/turn-taking, and realtime-voice references.

8 parts

Web Identity: OAuth, OIDC, and SAML

How web identity actually works — authentication vs authorization, OAuth 2.0 and its flows, tokens and JWTs, OpenID Connect, SAML enterprise SSO, sessions and single sign-on, and securing identity in practice.

8 parts

Webhooks and Event Delivery from First Principles

Webhooks and event delivery from first principles — the engineering discipline for the callbacks the SaaS economy synchronizes on, for both receivers and providers. Why webhooks are hard (the real contract: at-least-once, unordered, bounded retries, latency-sensitive, point-in-time payloads — loose by necessity; webhooks as state synchronization over an unreliable channel), delivery semantics (the two-generals shape of a POST; exactly-once delivery as myth, exactly-once effect as receiver-built; backoff, jitter, bounded horizons, per-endpoint isolation, ack-on-durable-acceptance), idempotent consumption (atomic event-ID claims, idempotent effects via same-transaction record-and-effect, version-gated applies, fetch-on-event, bounded parking, per-resource serialization), security (HMAC over raw bytes with constant-time comparison and secret rotation, signed-timestamp replay windows, fail-closed — and the provider side as SSRF-by-design: resolve-validate-pin, egress isolation, bounded responses), the durable intake architecture (thin verifying endpoint → queue → idempotent workers, DLQs that are monitored/diagnosable/replayable, poison-event quarantine), thin vs fat events (stale-by-construction fat payloads vs doorbell-and-fetch convergence; fat for facts, thin for state; events plus reconciliation polling), building the provider platform (outbox capture, per-endpoint filtered fan-out, actuarial endpoint health, suspension that warns and retains, delivery logs and bulk redelivery), and reconciliation and durable sync (modified-since sweeps counting missed deliveries, deletion detection, rehearsed backfill — events for latency, reconciliation for truth, replay for recovery). Grounded in Wikipedia (webhook, EDA, exponential backoff, two generals, idempotence, race conditions, HMAC, SSRF, message queues, DLQs, pub-sub, polling, rate limiting, multitenancy, CDC, eventual consistency).

7 parts

AI Architecture Decisions

Honest decision guides for the AI architecture choices that matter — the meta-framework, agent frameworks, model platforms, RAG vs fine-tuning vs long-context, MCP vs A2A, managed vs self-hosted, and vector storage — framed by durable trade-offs, not hype.

7 parts

Testing at Scale

Testing at scale — operating test suites in the hundreds of thousands across monorepos and hundreds of engineers, where the problems are throughput, signal, and economics. Why suites collapse (four compounding curves: superlinear growth against all-tests-every-change, flake arithmetic destroying signal, shared environments as queues and swamps, data rot — reframed by tests as purchases of information and the suite as a managed portfolio), selective test execution (reverse transitive closures via build graphs, extracted dependencies, or coverage maps; annotated invisible edges; the post-merge safety net whose misses are selection bugs; escape rate as the integrity metric), flakiness (statistically detected flake scores, mechanical quarantine with fix-or-delete SLAs, the root-cause taxonomy — synchronization, isolation, external dependencies, resources — and burn-in plus lint preventing re-infection), test environments (the staging singleton's structural failure; ephemeral environments declared, purpose-scoped, seeded, isolated, created in minutes, reaped by TTL; paired honestly with progressive delivery), simulating time (injected clocks and time's many disguises, discrete-event execution, one-clock slices across services, simulation as a product feature, calendar edges as shared fixtures), test data engineering (fixtures for golden cases, real-path factories, statistics-driven synthesis, the anonymization trap, and versioned owned seed specs updated with migrations), and CI at monorepo scale (content-addressed caching on hermetic inputs, duration-balanced sharding against the slowest-shard tail, merge queues testing against main-plus-queue — operated as a product with SLOs). Grounded in Wikipedia (software testing, CI, regression testing, dependency graphs, race conditions, test automation, sandboxes, deployment environments, discrete-event simulation, system time, test data, anonymization, monorepo, memoization).

7 parts

Zero-Downtime Data Migrations

Zero-downtime data migrations — the operational discipline of changing data under a running system, the practice layer above Database Internals. Why migrations break things (the five-shape taxonomy: lock queueing, resource starvation, long-transaction side effects, code-schema mismatch across rolling deploys, semantic drift — and the three vows: no data-proportional locks, reversibility until a deliberate point of no return, proof over belief), expand/contract (the grammar of all zero-downtime schema change: add alongside, migrate in compatible single-step deploys, contract late — with the per-engine fine print: concurrent index builds, declare-then-validate constraints, lock timeouts as seatbelt), backfills at scale (keyset-walked time-sized batches, throttling as a control loop yielding to replication lag, transactional checkpoints, idempotent absolute writes, the transform as reviewed code), dual-writes and shadow reads (the measurement layer: named source of truth, outbox/CDC upgrades, async sampled comparison with noise filtering, diff sweeps for cold data, idempotent repair, and the agreement rate that gates cutover), cutover and rollback (flag-controlled percentage ramps through real peaks, cohort-sticky routing, reverse dual-writes keeping rollback a flag-flip, declared windows and dated demolition), cross-store migrations (CDC as backbone — snapshot-then-stream convergence, the transform as risk concentrate, intended-equivalence verification, lag-gated cutover, pre-built reverse pipelines, and stalling as the dominant failure), and migrations as a capability (linters mechanizing the taxonomy, declarative harnesses, a control plane with ladder-climbing automation). Grounded in Wikipedia (schema migration, downtime, database schema, backward compatibility, batch processing, data migration, replication, data consistency, feature toggles, rollback, CDC, ETL, FSMs, lint).

6 parts

AI-Era Technical Sales

Winning AI deals — the AI-era technical go-to-market and pre-sales craft, for engineers and technical founders. A companion that patches the classic sales-engineering playbook (see the Sales for Engineers series) for AI, where the product is probabilistic and the buyer is managing fear. Covers why selling AI is different (probabilistic behavior, demo-hidden difficulty, a fearful buyer; the sale’s center of gravity shifts from demo to production), AI discovery as selling into fear (the four fears — hallucination, cost, security, lock-in — qualifying hard, quantifying value), why a great AI demo doesn’t close (the demo trap; reframing the demo to earn a scoped proof on real data), the POC as where AI deals die (scoping task/bar/data/day-after before the trial), the technical win (documented evidence on real data against an agreed bar, proving value not accuracy, evaluation and guardrails), and the evolution from sales engineer to forward deployed engineer (the technical-GTM spectrum, why AI made the FDE mandatory, scoping and productizing). Credits John Care’s Mastering Technical Sales as the foundational reference and cross-links the Forward Deployed Engineering, AI Forward Deployed Engineer, Forward Deployment Stack, and Forward Deployed Consultant series. Grounded in Wikipedia (sales engineering, complex sales, value proposition, sales process engineering, pre-sales, solution selling, proof of concept, technology adoption life cycle, return on investment, CRM).

6 parts

API Versioning and Evolution

API versioning and evolution — the discipline of changing an interface thousands of strangers depend on, the sequel to API Design. Why APIs rot (breaking defined operationally — any plausible client stops working; Hyrum's Law and the contract defined by client code; tolerant vs strict readers and the declared additive-is-safe convention; rot as nameable forces), versioning schemes (path, header, and per-resource schemes relocate the number while granularity, default policy, and lifetime decide the outcome; account-pinned dated versions as the convergent answer for continuous evolution, with the provider carrying the burden), compatibility layers (the transform chain: a latest-only core wrapped in small pure per-version gates — request-forward, response-backward — fixture-tested per version, with the hard species named and versions retired by deleting gates), specs and SDKs (one machine-readable source of truth with bidirectional conformance tests and spec-diff breaking-change detection; generated SDKs owning the mechanical 80% with tolerant-reader behaviors built in; fenced hand-written islands), deprecation (deprecated-but-functional with machine-readable marking, minimum support windows, brownouts, account-level telemetry burndowns, migration tooling absorbing the asymmetry, and slip policies protecting sunset credibility), and designing for evolution (objects and envelopes over bare scalars, open sets with catch-all semantics, expansion over proliferation, the corrected robustness principle — precise acceptance, tolerant reading — evolution reviews, and honest beta ladders). Grounded in Wikipedia (API, backward compatibility, software versioning, HTTP, adapter pattern, middleware, OpenAPI, IDLs, deprecation, product lifecycle, robustness principle, extensibility).

6 parts

Developer Productivity Engineering

Developer productivity engineering — treating the engineering organization itself as the system to optimize: the codebase-tooling half of the platform story. The discipline (inner/outer/org loops and their compounding economics; measurement that targets workflows and investments — latency distributions, friction events, serious surveys — never individuals; tooling as a product with users and adoption curves), codemods at scale (AST-based transforms — semantic targeting, idempotency, format preservation, type-informed when rewrites need meaning; honest residue detection; ownership-sharded PR fleets, transform-level review, lint rules closing the door; reversibility at codebase scale as the product), gradual typing migrations (the worked org-loop campaign: strictness maps, explicit boundaries with counted escape hatches, trunk-first sequencing, inference-powered fleets, CI ratchets making typedness monotonic, and the political craft — editor experience, centralized toil, declared victory), upgrades as a service (high-commonality low-context toil centralized: one version policy, read-once/codemod-once pipelines, eager continuous steps, inward compatibility shims, exception registries, and the security window as the funding argument), build systems (hermeticity as the one property from which sound caching, correct selection, remote execution, and supply-chain attestability all follow — fast and secure as the same investment; adoption as a campaign; per-target budgets and counted escape hatches), and paved roads (the coherent supported default — scaffolded-on at birth, integrated across the lifecycle, won by product craft, measured by adoption, engineered against rot, prohibition, and irrelevance — because developer platforms compound or decay). Grounded in Wikipedia (productivity, monorepo, ASTs, refactoring, gradual typing, type systems, technical debt, software maintenance, build automation, reproducible builds, DevOps, standardization).

6 parts

The Forward Deployed Field Guide

A field guide and ontology of the forward-deployed-engineering (FDE) discipline, organized into six themes — the map that points to the deeper series. (1) Understanding customers & driving AI adoption (workflow mapping, AI readiness, adoption as a people problem, calibrated trust, workflow-native agents, AI maturity). (2) Building agents & AI systems (agents and orchestration, MCP and connectors, context engineering, data and grounding, cost and latency; MCP as a standard, agent memory, cost/latency engineering). (3) Finding the right problem & proving value (discovery, use-case selection, scope, prototypes and acceptance, value; eval-driven scoping, the POC as the crux). (4) Shipping AI: production, security & reliability (deployment, evaluation, AI security, sovereignty and compliance, reliability, handover; agent security, operationalized governance, sovereign AI, evals as infrastructure). (5) The FDE craft: people, practice & influence (stakeholders, the role and spectrum, careers, hiring, mentoring, community). (6) From field lessons to better products (lessons, reuse, patterns, product feedback; the field-to-product flywheel). Cross-links the Forward Deployed Engineering, AI Forward Deployed Engineer, Forward Deployment Stack, Forward Deployed Consultant, and AI-Era Technical Sales series plus the AI engineering, security, and governance series. Grounded in Wikipedia (technology adoption life cycle, change management, software agent, retrieval-augmented generation, proof of concept, minimum viable product, MLOps, prompt injection, sales engineering, mentorship, product management, software design pattern).