The complete
handbook library.
Full-length technical handbooks on agentic AI, LLM systems, and building in public. Free to read. Take what you need.
The Prompting Handbook.
A friendly, hands-on field guide for everyday humans — learn the CRISP framework, spot bad prompts, practice with real recipes, play a drag-and-drop game, and test yourself with a quiz. No code required.
The Agentic AI Interview Handbook.
Twenty topics every senior AI engineer should be able to reason about live — from eval pipelines to reliability patterns for generative systems.
The Senior AI Engineer Interview Handbook.
60 questions across architecture, production incidents, agentic systems, RAG, evals, cost, safety, and leadership — what staff-level AI interviewers actually probe for.
50 Angular Interview Questions.
A visual handbook covering components, change detection, RxJS, signals, routing, forms, performance, and testing — what interviewers actually probe for in senior Angular roles.
50 Python Interview Questions.
Fundamentals to advanced: data structures, OOP, iterators & generators, the GIL, asyncio, memory, testing, and the standard library — a visual walk through everything a Python interview touches.
51 LLM Evals Interview Questions.
Golden sets, LLM-as-judge, regression testing, offline vs online evals, RAG evals, agent evals, red-teaming, and observability — demystified for interviews and production.
The Agent Evaluations Handbook.
A self-contained handbook on evaluating AI agents — theory, interactive widgets, and practical guidance. Trajectory evals, tool-use scoring, LLM-as-judge, observability, and reliability for PMs, engineers, and founders.
The System Design Fundamentals Handbook.
The load-bearing ideas behind every distributed system — the CAP theorem and consistency models, concurrency and locking, partitioning and replication, and consensus and coordination — each tied to a real worked design you can study interactively.
CAP Theorem & Consistency Models.
What a distributed system can promise when the network splits — CP vs AP, why "CA" is a myth, PACELC, and the full spectrum from linearizable to eventual consistency. Part of System Design Fundamentals.
Concurrency, Locks & Isolation Levels.
How overlapping operations stay correct — race conditions, optimistic vs pessimistic locking, the four isolation levels and their anomalies, MVCC, and distributed locks with fencing tokens. Part of System Design Fundamentals.
Partitioning, Sharding & Replication.
How one dataset becomes many — range vs hash partitioning, consistent hashing and virtual nodes, hot partitions, replication topologies, replication lag, and quorums. Part of System Design Fundamentals.
Consensus, Transactions & Coordination.
How nodes that can crash still agree on one truth — majority quorums, Raft and Paxos, leader election, two-phase commit vs the saga pattern, and idempotency for exactly-once effects. Part of System Design Fundamentals.
Claude Skills: A Builder's Manual.
Everything learned from building Skills in production, distilled into something you can read in a sitting.
Building in Public, For Engineers Who Hate Marketing.
A systems-approach to content, distribution, and open source for people who would rather be coding.
MCP Servers from Scratch.
A practical walkthrough from zero to a shipped Model Context Protocol server, including the ugly parts.
The Agent Patterns Handbook.
The design patterns behind every LLM agent — the ReAct Thought–Action–Observation loop, tool/function calling, plan-and-execute, reflection, memory, multi-agent orchestration, and the failure modes (loops, hallucinated tools, recovery, human-in-the-loop) that break agents in production.
The LLM Serving Handbook.
How to serve large language models fast and cheap — prefill vs decode, the KV cache, continuous batching and PagedAttention (vLLM), quantization, speculative decoding, and the latency-vs-throughput tradeoffs that decide your inference bill.
The Transformers Handbook.
The architecture behind every LLM, built up from scratch — tokens and embeddings, positional encoding, self-attention (query/key/value), multi-head attention, the transformer block (FFN, residuals, layer norm), and how a decoder-only model generates text autoregressively.
The RAG Handbook.
Retrieval-augmented generation end to end — why LLMs need it, chunking, embeddings and vector search, hybrid retrieval, two-stage reranking, grounded generation with citations, and how to evaluate a RAG system so a quietly-drifting index never fools you.
The Fine-Tuning Handbook.
When to fine-tune vs RAG vs prompting, full fine-tuning vs parameter-efficient methods, how LoRA and QLoRA make it cheap enough for a single GPU, why the data matters more than the method, catastrophic forgetting, and how to evaluate and decide.
The Vector Databases Handbook.
How vector search actually works — why brute-force kNN doesn't scale, distance metrics, approximate nearest neighbor, the HNSW, IVF and product-quantization indexes and their recall/latency/memory tradeoffs, metadata filtering, updates, scaling, and when you need a dedicated vector DB vs pgvector.
The Kafka Handbook.
Apache Kafka as a distributed append-only log, not a queue — topics, partitions and offsets, producers, consumers and consumer groups, per-key ordering, replication and ISR, delivery semantics (at-least-once and exactly-once), retention vs log compaction, and when Kafka beats a message queue.
The Redis Handbook.
Redis as an in-memory data-structure server, not just a cache — the core structures (strings, hashes, lists, sets, sorted sets), why single-threaded is fast, RDB vs AOF persistence, eviction and TTL, the classic patterns (cache, rate limiter, leaderboard, session, queue, pub/sub), high availability with replication, Sentinel and Cluster, and when it's the wrong tool.
The SQL Handbook.
What the database does underneath your SELECT — the relational model and keys, joins (inner/left/right/full), indexes and B-trees, the query planner and reading EXPLAIN, transactions and ACID, isolation levels and the anomalies they prevent, normalization vs denormalization, and the pitfalls (N+1, missing indexes, SELECT *).
The Kubernetes Handbook.
The one idea under all the YAML — declare desired state, and a control loop makes reality match. Covers the orchestration problem, pods, deployments and replicasets, services and networking, the reconciliation loop and self-healing, the scheduler, config/secrets and health probes, autoscaling, and when you actually need Kubernetes.
The Observability Handbook.
Seeing inside production — monitoring vs observability, the three pillars (metrics, logs, traces) and what each answers, structured logging, metric types and the cardinality trap, distributed tracing, the golden signals and SLIs/SLOs/error budgets, alerting on symptoms not causes, and correlating all three during an incident.
The React Interview Handbook.
What senior React interviews actually probe — components and JSX, props vs state, the render cycle with the virtual DOM and reconciliation, hooks and the rules of hooks, why components re-render and when memoization helps (and hurts), keys and lists, controlled inputs, and context vs prop drilling.
The Networking Handbook.
How a request actually travels — the layered model, IP addressing and routing, TCP vs UDP, the TCP handshake and head-of-line blocking, DNS resolution and caching, HTTP/1.1 vs HTTP/2 vs HTTP/3 (QUIC), TLS/HTTPS, and why round-trip latency, not bandwidth, dominates.
The Diffusion Models Handbook.
How AI images are really made — generation as iterative denoising, the forward noising and reverse denoising processes, the elegant noise-prediction training objective, sampling and the steps-vs-speed dial, conditioning and classifier-free guidance, latent diffusion (Stable Diffusion), and why diffusion beat GANs and VAEs.
The Reinforcement Learning Handbook.
Learning to act by trial and error — the agent-environment loop, cumulative reward and discounting, exploration vs exploitation, value functions and Q-learning, policy gradient methods (REINFORCE/PPO), why RL is unstable and reward hacking happens, model-free vs model-based, and how RLHF turned LLMs into assistants.
The Behavioral Interview Handbook.
The round that decides your level — why behavioral interviews matter and what they signal, the STAR method with a worked example, building a flexible story bank, leadership and ownership, conflict, failure, ambiguity and prioritization, thoughtful questions to ask, and the red flags that sink good candidates.
The Model Context Protocol (MCP) Handbook.
The open standard connecting AI agents to the outside world — why M×N bespoke integrations collapse to M+N, the host/client/server roles over JSON-RPC, the three primitives (tools, resources, prompts), the connect→discover→call session lifecycle, when MCP earns its keep, and the security sharp edges (a server's output is untrusted input).
The Loop Engineering Handbook.
Stop prompting your agents — design the system that prompts them for you. The inner vs outer loop, the four loop types (heartbeat, cron, hook, goal), the six building blocks (automations, worktrees, skills, MCP connectors, subagents, external memory), stopping conditions and the verification split, state across runs, cost engineering, and the six failure modes that burn tokens at 3am.
Handbooks — frequently asked questions
Are the handbooks free to read?
Yes. Every handbook is free, full-length, and self-contained — no paywall, no sign-up, and no email required to read any of them.
Who writes these handbooks?
They are written by Saurabh Singh, a senior AI engineer, based on real production experience building agentic AI systems, evals, and large-scale services — not generic content.
What topics do the handbooks cover?
They span agentic AI and LLM engineering (prompting, RAG, evals, agent evaluation), AI-engineering interview prep, system-design fundamentals, and language-specific interview guides for Angular and Python.
Are these handbooks good for interview preparation?
Yes. Several are built specifically around what interviewers probe for at senior and staff level — the LLM, Senior AI Engineer, Angular, and Python handbooks are structured as the exact questions and reasoning those interviews test.
How long does each handbook take to read?
Most take between 40 and 75 minutes, shown as an estimated read time on each card. They are designed to be read in one focused sitting, with interactive widgets and quizzes to reinforce the material.
Something missing?
If there's a topic you'd like covered, send it through. Genuine requests shape what gets written next.