# Vibe Engines

> Free, interactive learning for AI and backend engineers — by Saurabh Singh,
> a senior AI engineer building in the open. Full-length technical handbooks,
> step-by-step system-design walkthroughs, and browser-based developer tools,
> all free, all without sign-up.

## What this site is

Vibe Engines is an open educational resource for software engineers, AI/LLM
builders, and people preparing for senior and staff engineering interviews. Its
three pillars are:

- **Learning Paths** (18) — goal-oriented, ordered courses that thread content
  across formats (become an AI engineer, pass the system-design interview, crack the
  coding interview, …). The best starting point for a specific goal: /learn.
- **Topics** (14) — cross-format hubs (RAG, LLM engineering, agents, AI evaluation,
  distributed systems, caching, algorithms, interview prep, …). Each hub aggregates
  every handbook, system design, challenge, lab and tool on that subject — the best
  entry point for following one subject across formats: /topics.
- **Handbooks** (160) — full-length, interactive guides on agentic AI, LLM evals,
  RAG, system-design fundamentals, and language interview prep (Angular, Python).
- **System Design Walkthroughs** (62) — each builds a real large-scale system
  (Uber, WhatsApp, a key-value store, a payment system, …) one concept at a time
  through an interactive diagram, foregrounding the trade-offs interviewers probe.
- **AI System Design Walkthroughs** (61) — the same interactive treatment for AI/LLM
  architectures (conversational AI, RAG, agents, inference serving, vector databases,
  semantic search), foregrounding the trade-offs behind shipping LLM systems: /ai-system-design.
- **Free Developer Tools** (54) — browser-based, no-signup visualizers and
  calculators (consistent-hashing ring, capacity estimator, quorum explorer, RAG
  chunking playground, LLM cost planner, and more).
- **Algorithms, Played** (98) — classic algorithms taught as playable games:
  you drive the problem and lose on instinct, then meet the algorithm that solves
  it, with full theory, a worked trace and a quiz.
- **Labs** (51) — AI and engineering concepts (gradient descent, …) taught as
  playable games: you drive the idea, fail on instinct, then meet the method that
  works, with full theory, a worked trace and a quiz.
- **Coding Challenges** (68) — interview-style problems you solve in the
  browser in Python or TypeScript, spanning DSA and AI engineering (softmax, cosine
  similarity, top-k retrieval, token-F1), with hidden tests and instant feedback.

Everything runs client-side and is free. Author: Saurabh Singh (Senior AI Engineer).
Contact: singh71297@hotmail.com. Primary topics: agentic AI, LLM systems, RAG,
AI evaluations, distributed systems, and system design.

## Key facts

- 160 technical handbooks, 62 system-design walkthroughs, 61 AI system-design
  walkthroughs, 25 roadmap(s), 54 free tools, 98 algorithm game(s), 51 interactive lab(s),
  68 coding challenge(s), 108 paper breakdown(s), 8 video course(s).
- All content is free, self-contained, and requires no account.
- Canonical handbook/roadmap/system-design pages live at /handbook/<slug>,
  /roadmap/<slug>, and /systemdesign/<slug>; AI system designs at /ai-system-design/<slug>;
  tools at /tools/<slug>; algorithm games at /algorithm/<slug>.
- License: free to read and cite; AI training/index use permitted with attribution
  (linking back to the canonical URL). See /terms for full terms.

## Actions — do a task in the browser (no signup)

Each free tool performs one concrete task. Map a user intent to the tool that
does it, then send the user (or act) at the URL:
- Watch keys rebalance on the hash ring as nodes come and go → https://vibeengines.com/tools/consistent-hashing
- Back-of-the-envelope math for system design, with the reasoning shown → https://vibeengines.com/tools/capacity-estimator
- Paste a document, pick a strategy, see the actual chunks and tokens → https://vibeengines.com/tools/rag-chunking
- Model an agent’s context window and see where the tokens (and dollars) go → https://vibeengines.com/tools/context-cost-planner
- Set N, R and W and instantly see your consistency–availability trade-off → https://vibeengines.com/tools/quorum-explorer
- Compose services in series and parallel to find your real uptime → https://vibeengines.com/tools/availability-calculator
- Design an eval rubric and generate the judge prompt for it → https://vibeengines.com/tools/llm-judge-builder
- Build a function-calling tool definition visually, get valid JSON out → https://vibeengines.com/tools/tool-schema-designer
- Paste your numbers and see p50, p90, p95 and p99 — the tail, not the average → https://vibeengines.com/tools/percentile-calculator
- Enter your token usage and see the monthly bill across every major model → https://vibeengines.com/tools/model-pricing-comparator
- Pick your item count and false-positive rate — get bits, memory and hash count → https://vibeengines.com/tools/bloom-filter-sizing
- Fire requests at a rate limiter and watch tokens drain, refill and throttle → https://vibeengines.com/tools/token-bucket-simulator
- See your prompt fill the context window — and where it overflows → https://vibeengines.com/tools/context-window-visualizer
- Paste text, get tokens — plus what it costs and how much window it eats → https://vibeengines.com/tools/token-counter
- Will that model fit on your GPU? Weights + KV cache + overhead, computed → https://vibeengines.com/tools/gpu-vram-calculator
- What will that fine-tune actually cost? GPUs, hours, dollars — before you rent anything → https://vibeengines.com/tools/fine-tuning-cost-estimator
- The memory that actually caps your concurrency — per token, per sequence, per batch → https://vibeengines.com/tools/kv-cache-calculator
- Price your RAG index before you build it: embedding spend, vector storage, query costs → https://vibeengines.com/tools/embedding-cost-calculator
- Where does the second go? Build the request waterfall and find the TTFT bottleneck → https://vibeengines.com/tools/latency-budget-builder
- How fast are you spending the error budget — and when does the pager fire? → https://vibeengines.com/tools/slo-burn-calculator
- Every model that matters, one sortable table — priced at YOUR input:output ratio → https://vibeengines.com/tools/model-comparison
- How much compute, time and money to train a model of N params on D tokens → https://vibeengines.com/tools/training-compute-calculator
- Concurrency = throughput × latency. Give any two, get the third → https://vibeengines.com/tools/littles-law-calculator
- Model prompt-cache hit rate, the write premium, and your real $/request → https://vibeengines.com/tools/prompt-caching-calculator
- Paste a JSON Web Token, read its header, claims and expiry — offline → https://vibeengines.com/tools/jwt-decoder
- Type an IPv4 CIDR block, get the network, broadcast, range and host count → https://vibeengines.com/tools/cidr-calculator
- Epoch ↔ human date, in seconds or milliseconds, UTC and local → https://vibeengines.com/tools/unix-time-converter
- Generate v4 UUIDs and ULIDs in bulk — cryptographically random, in-browser → https://vibeengines.com/tools/uuid-ulid-generator
- Write a pattern, paste text, see every match and capture group live → https://vibeengines.com/tools/regex-tester
- Encode or decode Base64, Base64URL and percent-encoding — UTF-8 safe → https://vibeengines.com/tools/base64-url-tools
- Click permissions to get the octal, or type octal to see the rwx → https://vibeengines.com/tools/chmod-calculator
- See a password’s entropy in bits and how long it would take to crack → https://vibeengines.com/tools/password-entropy
- Write a cron expression, read it in plain English, see the next run times → https://vibeengines.com/tools/cron-builder
- Paste a one-line query, get readable, indented SQL → https://vibeengines.com/tools/sql-formatter
- Paste CSV or TSV, get a clean, aligned Markdown table → https://vibeengines.com/tools/md-table-generator
- Compare two blocks of text and see exactly what changed, line by line → https://vibeengines.com/tools/diff-checker
- Enter two variants’ conversions and see if the difference is real → https://vibeengines.com/tools/ab-significance-calculator
- Size a topic’s partitions from your throughput and consumer targets → https://vibeengines.com/tools/kafka-partition-calculator
- Size a DB connection pool from QPS and latency — and check the DB’s limit → https://vibeengines.com/tools/connection-pool-sizer
- Estimate how much disk a B-tree index will take before you create it → https://vibeengines.com/tools/db-index-size-estimator
- Validate and pretty-print JSON — or diff two JSON documents by value → https://vibeengines.com/tools/json-format-diff
- See what a cache buys you: latency saved and backend load removed → https://vibeengines.com/tools/cache-roi-calculator
- Project how big your data gets — and when you’ll run out of disk → https://vibeengines.com/tools/storage-growth-forecaster
- Turn a target rate and burst into concrete token-bucket parameters → https://vibeengines.com/tools/rate-limit-designer
- See why an agent’s cost grows faster than its number of steps → https://vibeengines.com/tools/agent-loop-cost-estimator
- How many shards you need from data size, QPS and per-shard limits → https://vibeengines.com/tools/sharding-planner
- See what vector dimensions cost in memory before you pick them → https://vibeengines.com/tools/embedding-dim-tradeoff
- The latency numbers every engineer should know — scaled to human time → https://vibeengines.com/tools/latency-numbers-interactive
- Compare cloud GPU hourly rates and estimate a job’s compute cost → https://vibeengines.com/tools/gpu-rental-prices
- Given an NPU’s TOPS and RAM, see which local models fit and how fast they prefill → https://vibeengines.com/tools/npu-model-fit-calculator
- Project the METR doubling curve: when do agents reliably handle day- and week-long tasks? → https://vibeengines.com/tools/agent-time-horizon-explorer
- Paste a SKILL.md and score it against a Claude-Skills quality rubric — before an agent has to use it → https://vibeengines.com/tools/skill-linter
- What applies on 2 Aug 2026 vs later — mapped to the engineering artifacts you actually have to ship → https://vibeengines.com/tools/eu-ai-act-timeline
- Indicative 2026 AI-engineering comp bands by role, level and company tier → https://vibeengines.com/tools/ai-salary-explorer

Other interactive actions: solve a coding problem → /challenge · run an algorithm
or lab step-by-step → /algorithm, /lab · walk a system design → /systemdesign,
/ai-system-design · look up a term → /glossary.

## Learning Paths (start here)
- [Become an AI Engineer](https://vibeengines.com/learn/ai-engineer): From prompting to retrieval to agents to evaluation and serving — the full arc of shipping LLM-powered features, threaded through handbooks, system designs, runnable challenges and tools.
- [Ace the AI Engineer Interview](https://vibeengines.com/learn/ai-interview): The AI interview handbooks paired with the runnable challenges behind the questions — so you can explain softmax, embeddings and evals and then implement them on the spot.
- [Ship an AI Product](https://vibeengines.com/learn/ai-startup): The build → ship → grow arc for a one-person AI startup: the on-site lessons for the engineering, woven together with open-source tools — Inkwell, VolfPack, PromptPlay — for prototyping, finding your first users, and marketing a launch without a team.
- [Master LLM Evaluation](https://vibeengines.com/learn/llm-evals): Shipping an LLM feature is easy; knowing whether it is good is the hard part. Build the vocabulary of evals, design a judge rubric, implement a metric by hand, then evaluate agents and a real production system.
- [ML Engineering Foundations](https://vibeengines.com/learn/ml-foundations): The core math and primitives behind modern ML, made runnable: feel how models learn, implement the functions every model relies on, then assemble them into a recommender and a retrieval pipeline.
- [Pass the System Design Interview](https://vibeengines.com/learn/system-design-interview): Build the vocabulary and the trade-off intuition first, practice the back-of-envelope numbers, then rehearse a dozen canonical designs from a URL shortener to a payment system.
- [Level Up as a Backend Engineer](https://vibeengines.com/learn/backend-engineer): The distributed-systems fundamentals, then the systems that put them to work — a key-value store, a cache, a message queue, an ID generator — with tools to build the intuition.
- [Reliability & Scale (SRE)](https://vibeengines.com/learn/reliability-sre): The reliability engineer’s toolkit: turn nines into real downtime, size capacity before it bites, then study the patterns — quorums, rate limiting, caching, queues — that absorb load and keep services alive under pressure.
- [Crack the Coding Interview](https://vibeengines.com/learn/coding-interview): Follow the DSA roadmap, play the patterns as interactive games, then prove you can implement them by solving the matching challenges in your browser.
- [Advanced Algorithms & Data Structures](https://vibeengines.com/learn/advanced-dsa): The specialized machinery behind real systems — range-query trees, string automata, network flow, and probabilistic sketches — each played as an interactive visualization, in a coherent order.
- [Master Context Engineering](https://vibeengines.com/learn/context-engineer): The discipline that replaced prompt-tweaking, learned end to end: tokens and budgets, the four operations (write, select, compress, isolate), compaction and memory, cache-aware prompts — threaded through the handbook, labs, tools, papers and system designs.
- [Become a Forward Deployed Engineer](https://vibeengines.com/learn/forward-deployed-engineer): The complete FDE track, in order: understand the role, learn to discover and scope, prototype fast, integrate with real systems, deploy in the customer’s world, demo, harden, and hand off — threaded through deep handbooks and hands-on Python/TypeScript challenges you actually solve.
- [Build an LLM From Scratch](https://vibeengines.com/learn/llm-from-scratch): No black boxes. Start at raw bytes and end at an aligned assistant — tokenization, embeddings, attention, the full forward pass, the training loss, and RLHF — each idea paired with a runnable challenge or lab that makes you build the piece by hand.
- [System Design in 30 Days](https://vibeengines.com/learn/system-design-in-30-days): A structured month through the canonical system designs — from a URL shortener to Uber — each built on the fundamentals it needs: capacity math, caching, partitioning, consistency. Design the system, then implement the primitive underneath it.
- [The 4-Week Interview Sprint](https://vibeengines.com/learn/4-week-interview-sprint): A dense, ordered sprint: week one drills the coding patterns, week two the harder graph and DP problems, week three switches to system design, and week four handles the behavioral round, resume and offer. Every coding step is runnable.
- [Distributed Systems Deep Dive](https://vibeengines.com/learn/distributed-systems-deep-dive): The hard core of distributed systems, threaded from the CAP theorem through Raft, quorums, vector clocks and CRDTs to real designs. Each protocol is paired with a simulator to drive it and a challenge to implement one step of it yourself.
- [The Papers Bootcamp](https://vibeengines.com/learn/papers-bootcamp): The papers that built modern AI, sequenced so each one earns the next — from word2vec and the Transformer through scaling laws, RLHF, chain-of-thought, RAG, LoRA and MoE, out to vision and diffusion. Every entry is a plain-English breakdown, not the raw PDF.
- [AI for Product Managers](https://vibeengines.com/learn/ai-for-pms): A concept-first path for product managers: the AI stack, the build decisions (RAG vs fine-tuning, big vs small model), the cost and quality levers, and the risk surface — paired with interactive calculators so you can pressure-test a plan in a meeting, not just nod along.

## Browse by Topic (cross-format hubs)
- [RAG & Retrieval](https://vibeengines.com/topic/rag-retrieval): Retrieval-augmented generation end to end — chunking, embeddings, similarity search and ranking — across a system design, a hands-on tool, and runnable challenges.
- [LLM Engineering](https://vibeengines.com/topic/llm-engineering): Building with large language models — prompting, decoding, inference serving and cost — from the handbooks down to the softmax that powers every token.
- [AI Agents & Tools](https://vibeengines.com/topic/ai-agents): Agentic systems — tool calling, orchestration and the interfaces that let models act — with the agent system design, the agentic interview handbook, and a tool-schema designer.
- [AI Evaluation](https://vibeengines.com/topic/ai-evaluation): How you know an AI system actually works — LLM-as-judge, agent evals, and metrics like token-F1 — the half of AI engineering that separates demos from production.
- [ML Foundations](https://vibeengines.com/topic/ml-foundations): The math under the models — gradient descent, softmax, embeddings, similarity and ranking — taught as playable labs and runnable challenges.
- [Distributed Systems](https://vibeengines.com/topic/distributed-systems): Consistency, consensus, replication and coordination — the CAP-theorem-shaped trade-offs at the heart of every large-scale system, with handbooks, system designs and interactive tools.
- [Databases & Storage](https://vibeengines.com/topic/databases-storage): Storing data at scale — transactions, isolation, indexing, ledgers and sync — from the concurrency handbook to systems like Dropbox, a payment ledger and a key-value store.
- [Caching & Performance](https://vibeengines.com/topic/caching-performance): Making systems fast — caching strategies, CDNs, rate limiting and low-latency design — with a capacity estimator and the systems that live or die on cache hit rates.
- [Real-time & Messaging](https://vibeengines.com/topic/realtime-messaging): Pushing data the moment it changes — WebSockets, fan-out, streaming and message queues — across chat, feeds, notifications and collaborative editing.
- [Algorithms & DSA](https://vibeengines.com/topic/algorithms-dsa): Data structures and algorithms taught as playable games and runnable challenges — graphs, sorting, search and dynamic programming, the half of every interview loop you can practice.
- [AI for Professionals](https://vibeengines.com/topic/ai-for-professionals): AI for people whose job is not software — lawyers, doctors, engineers of the physical world. Workflow recipes, the safety rules that actually matter, and zero code.
- [Interview Prep](https://vibeengines.com/topic/interview-prep): Everything pointed at the interview loop — AI and system-design handbooks, language Q&A, the DSA roadmap and runnable coding challenges in one place.
- [Forward Deployed Engineering](https://vibeengines.com/topic/forward-deployed-engineering): The trending customer-facing engineering role: discover the problem on site, prototype fast, integrate with the customer’s systems, deploy in their environment, demo, harden, and hand off — everything for becoming a Forward Deployed Engineer.
- [Developer Utilities](https://vibeengines.com/topic/developer-utilities): The fast, offline, no-sign-up utilities you reach for daily — decode a JWT, plan a subnet, convert an epoch, generate an ID. Everything runs in your browser; nothing is sent anywhere.

## Handbooks
- [The Prompting Handbook](https://vibeengines.com/handbook/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](https://vibeengines.com/handbook/llm-interview): 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](https://vibeengines.com/handbook/senior-ai-engineer): 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](https://vibeengines.com/handbook/angular-interview): 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](https://vibeengines.com/handbook/python-interview): 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](https://vibeengines.com/handbook/llm-evals-interview): 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](https://vibeengines.com/handbook/agent-evals): 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](https://vibeengines.com/handbook/system-design-fundamentals): 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](https://vibeengines.com/handbook/cap-theorem): 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](https://vibeengines.com/handbook/concurrency-and-locking): 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](https://vibeengines.com/handbook/partitioning-and-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](https://vibeengines.com/handbook/consensus-and-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.
- [The Agent Patterns Handbook](https://vibeengines.com/handbook/agent-patterns): 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](https://vibeengines.com/handbook/llm-serving): 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](https://vibeengines.com/handbook/transformers): 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](https://vibeengines.com/handbook/rag): 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](https://vibeengines.com/handbook/fine-tuning): 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](https://vibeengines.com/handbook/vector-databases): 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](https://vibeengines.com/handbook/kafka): 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](https://vibeengines.com/handbook/redis): 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](https://vibeengines.com/handbook/sql): 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](https://vibeengines.com/handbook/kubernetes): 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](https://vibeengines.com/handbook/observability): 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](https://vibeengines.com/handbook/react-interview): 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](https://vibeengines.com/handbook/networking): 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](https://vibeengines.com/handbook/diffusion-models): 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](https://vibeengines.com/handbook/reinforcement-learning): 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](https://vibeengines.com/handbook/behavioral-interview): 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](https://vibeengines.com/handbook/mcp): 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](https://vibeengines.com/handbook/loop-engineering): 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.
- [The Context Engineering Handbook](https://vibeengines.com/handbook/context-engineering): The discipline that replaced prompt-tweaking: curating everything the model sees under a finite attention budget. The anatomy of a production context window, the three taxes on an overstuffed one (context rot, cost, behavioral drift), the four operations (write, select, compress, isolate), agent-specific patterns like compaction and just-in-time retrieval, six production habits, and where it sits in the prompt → context → loop → harness stack.
- [The Agent Skills Handbook](https://vibeengines.com/handbook/agent-skills): Packaged, on-demand expertise for AI agents: what a skill folder actually is (SKILL.md + scripts + resources), progressive disclosure and why the system prompt couldn't do it, the skills vs tools vs MCP vs fine-tuning decision table, six habits of skills that actually trigger, and why third-party skills are supply-chain dependencies to review like code.
- [The Agentic Coding Handbook](https://vibeengines.com/handbook/agentic-coding): Working with coding agents — Claude Code, Cursor and their cousins — without drowning in AI slop. The loop + tools + context anatomy, the CLAUDE.md instruction file (your highest-leverage artifact), the plan-then-verify workflow, skills/subagents/hooks, the vibe-coding review dial, the security sharp edges (injection, secrets, dangerous commands), and the team norms that keep quality from eroding.
- [The On-Device AI Handbook](https://vibeengines.com/handbook/on-device-ai): Small models, everywhere: why 1–14B models got frontier-adjacent (distillation + textbook data), the napkin law of local inference (tokens/sec ≈ bandwidth ÷ bytes), quantization and the llama.cpp / GGUF / Ollama / MLX stack, the honest local-vs-cloud decision table, four hybrid patterns that ship, and the evals craft of choosing a small model that actually fits the device.
- [The AI Security Handbook](https://vibeengines.com/handbook/ai-security): Your app now reads the internet and believes it. Why prompt injection is a design problem filters cannot solve, the lethal trifecta (private data + untrusted content + exfiltration), defense in depth from least privilege to output validation, where PII actually leaks (logs, embeddings, weights), MCP/model supply-chain trust, and the red-team eval suite that gates CI.
- [The Git Internals Handbook](https://vibeengines.com/handbook/git-internals): Learn the model and the commands become obvious. Git as a content-addressed database: blobs, trees and commits; branches as 41-byte files; the three trees behind add/commit/reset; what merge and rebase mechanically do (and why rewriting shared history is a law, not a preference); the reflog recovery recipe; packfiles.
- [The Docker Handbook](https://vibeengines.com/handbook/docker): A container is a lie told by the kernel — namespaces (what a process sees) plus cgroups (what it uses), not a VM. Image layers and the cache-ordering rule that halves build times, multi-stage Dockerfiles that ship small, volumes vs bind mounts, name-based networking, Compose, and the handoff to Kubernetes.
- [The PostgreSQL Internals Handbook](https://vibeengines.com/handbook/postgres-internals): UPDATE never updates, and a janitor keeps it working. Heap pages and tuples, MVCC's row versions (xmin/xmax visibility arithmetic), VACUUM, bloat and the wraparound scare, B-trees, HOT updates and index-only scans, the WAL's three superpowers (recovery, replication, PITR), reading the planner honestly, and why PgBouncer is infrastructure.
- [The GPU Fundamentals Handbook](https://vibeengines.com/handbook/gpu-fundamentals): The bottleneck is never where you think. SIMT and warps, the memory hierarchy from registers to HBM, arithmetic intensity and the roofline (compute-bound vs bandwidth-bound), where LLM workloads actually land, why FlashAttention was inevitable, the kernel stack from CUDA to Triton to torch.compile, and the multi-GPU interconnect story.
- [The API Design Handbook](https://vibeengines.com/handbook/api-design): An API is a promise you keep for years. Choosing REST vs gRPC vs GraphQL honestly, resource-modeling REST so consumers can guess it, contract-first gRPC and protobuf evolution, the retry-safe semantics that survive real networks (idempotency keys, cursor pagination, structured errors), versioning without breaking clients, and why agent tool schemas are the newest API surface.
- [The Distributed Training Handbook](https://vibeengines.com/handbook/distributed-training): When the model doesn't fit, split it four ways. What actually eats training memory, data parallelism and all-reduce, ZeRO/FSDP sharding stages, tensor parallelism inside a layer, pipeline parallelism across layers (and the bubble micro-batching hides), 3D parallelism, the communication-overlap that decides MFU, and the memory tricks (mixed precision, gradient accumulation, activation checkpointing) you reach for first.
- [RAG vs Fine-Tuning](https://vibeengines.com/handbook/rag-vs-fine-tuning): The most common wrong turn in AI engineering — reaching for fine-tuning when you needed retrieval, or vice versa. The one distinction that decides it (knowledge vs behavior), a head-to-head table, when to use each, and why the strongest systems combine them: fine-tune for behavior, RAG for knowledge.
- [Kafka vs RabbitMQ](https://vibeengines.com/handbook/kafka-vs-rabbitmq): They both "move messages", which is exactly why teams pick the wrong one. Kafka is a durable, replayable log where consumers track their own offset; RabbitMQ is a smart broker that routes each message and deletes it on ack. The remember-vs-forget core difference, throughput and ordering trade-offs, and how to choose.
- [Redis vs Memcached](https://vibeengines.com/handbook/redis-vs-memcached): Both put data in RAM by a key, so they look interchangeable — but Memcached does one thing (a lean multithreaded cache) while Redis is a data-structure server with persistence, replication and pub/sub. The one-job-vs-many split, a feature table, and why most teams now default to Redis.
- [SQL vs NoSQL](https://vibeengines.com/handbook/sql-vs-nosql): Framed as a war, it’s really a menu. Relational databases give you schema, joins and ACID; NoSQL is an umbrella of document/key-value/wide-column/graph stores that drop some of that for flexibility and horizontal scale. The relationships-vs-scale core difference, the CAP trade-off, and why to start relational.
- [PostgreSQL vs MySQL](https://vibeengines.com/handbook/postgres-vs-mysql): Both are excellent free relational databases you can build a company on, so the choice is about character, not capability: Postgres prizes correctness, rich types and advanced features; MySQL prizes simplicity and read-heavy speed. The real differences, when each wins, and why Postgres became the modern default.
- [gRPC vs REST](https://vibeengines.com/handbook/grpc-vs-rest): Both let services talk, and you often want both. REST over HTTP/JSON is universal, cacheable and debuggable — the right skin for public APIs; gRPC uses typed protobuf over HTTP/2 for fast, streaming service-to-service calls. The audience-decides rule, a trade-off table, and the REST-at-the-edge, gRPC-inside pattern.
- [MCP vs Function Calling](https://vibeengines.com/handbook/mcp-vs-function-calling): Pitted against each other, but they live at different layers — like comparing USB-C to sending data. Function calling is the model capability to emit a structured tool request; MCP is the open standard for discovering and connecting to tool servers. How MCP uses function calling, and when each matters.
- [50 System Design Interview Questions](https://vibeengines.com/handbook/system-design-interview): The questions that actually come up in senior and staff loops, each with a concise, defensible answer you can say out loud: scaling and estimation, load balancing, caching, databases and sharding, CAP and consistency, message queues, reliability, and the classic design scenarios like URL shorteners and news feeds. Mark what you master as you go.
- [AI for Lawyers](https://vibeengines.com/handbook/ai-for-lawyers): The practical middle ground for legal professionals: where AI genuinely helps (first drafts, brief summaries, review triage), the three non-negotiable rules — confidentiality, verify every citation, you sign it you own it — five workflow recipes with exact prompts, a spot-the-danger judgment exercise, and the five questions to ask any AI vendor. No coding required.
- [AI for Doctors](https://vibeengines.com/handbook/ai-for-doctors): The practical middle ground for clinicians: where AI genuinely helps (notes from dictation, discharge instructions, prior auths, literature summaries), the three non-negotiable rules — PHI needs a BAA, verify everything clinical, the chart is yours — five workflow recipes with exact prompts, a spot-the-danger judgment exercise, and the six questions to ask any clinical AI vendor. No coding required.
- [AI for Civil Engineers](https://vibeengines.com/handbook/ai-for-civil-engineers): The practical middle ground for civil and structural engineers: where AI genuinely helps (observation reports, RFI responses, meeting minutes, plain-language explanations), the three non-negotiable rules — the adopted code is the authority, calculations get checked independently, your stamp is yours — five workflow recipes with exact prompts, a spot-the-danger judgment exercise, and the vendor questions that matter. No coding required.
- [The Embeddings Handbook](https://vibeengines.com/handbook/embeddings): Meaning as geometry: how text and images become vectors so that similar meaning lands nearby, why cosine similarity measures direction not length, how L2-normalization makes the dot product equal cosine (so vector databases just take dot products), the curse of dimensionality, and how it all powers semantic search and RAG — with worked math and runnable code.
- [The AI Cost Engineering Handbook](https://vibeengines.com/handbook/ai-cost-engineering): AI spend is a sum over tokens: input-tokens × input-price + output-tokens × output-price, per million. Why output tokens dominate the bill (usually ~5× input), how prompt caching pays off from the very first reuse, and the full lever set — shorter outputs, caching, model routing, batching, context trimming — that cuts spend without cutting quality. With worked math and a runnable cost calculator.
- [The Structured Outputs Handbook](https://vibeengines.com/handbook/structured-outputs): How LLMs return guaranteed-valid JSON for function calling and tool use. Why prompting for JSON is unreliable, how constrained decoding masks illegal tokens to −∞ so output is valid by construction (not by hope), the spectrum from JSON mode to full schema enforcement, and the trade-offs — including why "valid" is not "correct". With worked math and runnable code.
- [The Model Routing Handbook](https://vibeengines.com/handbook/model-routing): Send each request to the cheapest model that can handle it. How a cheap-smart cascade works, why you pay the cheap model on everything so the escalation rate is the key lever, the break-even math (r* = 1 − c_cheap/c_big), predictive routers vs cascades, and the confidently-wrong pitfall. With worked math and a runnable cost model.
- [The Agent Memory Handbook](https://vibeengines.com/handbook/agent-memory): A finite context window forces a memory strategy. Short-term (context) vs long-term (external store), how eviction (FIFO) and summarization (compression) keep a growing conversation in the token budget, and how retrieval recalls a fact long after it scrolled out of context — the memory-as-OS idea. With worked budget math and runnable code.
- [The Guardrails Engineering Handbook](https://vibeengines.com/handbook/guardrails-engineering): The input and output filters that keep an LLM system safe. Why no single filter is enough, how layering independent guardrails drives the combined miss rate down multiplicatively (defense in depth: ∏ miss_i), why false positives compound the other way (1 − ∏(1−fp_i)), the independence caveat, and where to place each layer. With worked math and runnable code.
- [The Synthetic Data Handbook](https://vibeengines.com/handbook/synthetic-data): Using LLMs to generate training and eval data. Why quality filtering beats raw volume (effective size = generated × pass rate), what model collapse is and why recursive training on unfiltered self-generated data shrinks diversity (Var_k = s^k · Var_0 → 0), and a safe generate-filter-mix pipeline. With worked math and runnable code.
- [The Harness Engineering Handbook](https://vibeengines.com/handbook/harness-engineering): The loop that wraps a model into an autonomous agent — plan, act, observe — and why its most important property is bounds. A stuck agent with no hard stop loops forever, burning money, so the harness enforces max steps AND a cost budget. Geometric success math (P(done ≤ k) = 1 − (1−p)^k, E[steps] = 1/p) and a bounded loop you can run — with worked math and runnable code.
- [The LLM Observability Handbook](https://vibeengines.com/handbook/llm-observability): Tracing an AI request as a tree of spans. Why total latency is the critical path — the max end time, not the sum of durations, because parallel spans overlap — while cost is the sum across every span, how to find the bottleneck span, and what to log for every LLM call (including percentiles over averages). With worked math and runnable code.
- [The Prompt Caching Handbook](https://vibeengines.com/handbook/prompt-caching): How prompt caching actually works. Why caches key on the exact prefix and break at the first differing token, why cache-aware ordering (fixed content first, variable last) is the single biggest lever on hit rate, how TTL and cache breakpoints work, and the invisible mistakes (a timestamp up top, non-deterministic serialization) that silently kill caching. With worked math and runnable code.
- [The Evals in CI Handbook](https://vibeengines.com/handbook/evals-in-ci): Turn LLM quality into a regression gate, like unit tests for code. A golden set scored on every change, and why the gate needs both an aggregate threshold AND per-case no-regression — because a healthy average can hide a broken case (mean stays up while one case collapses). How to wire it into the PR pipeline, handle non-determinism with a tolerance band, and avoid a flaky gate. With worked math and runnable code.
- [The Sandboxing Handbook](https://vibeengines.com/handbook/sandboxing): Safely running untrusted or agent-generated code. Why deny-by-default beats a block-list (you can't enumerate all evil, so enumerate the little good), how least-privilege allowlists shrink the escape surface, why resource caps are needed on top of policy, and the layers of isolation from seccomp to microVMs. With worked policy math and runnable code.
- [The Local LLM Stack Handbook](https://vibeengines.com/handbook/local-llm-stack): Running LLMs locally with ollama and llama.cpp. The one equation that decides what fits — weight memory = params × bits per weight ÷ 8 — how quantization shrinks a 7B model from 14GB (fp16) to 3.5GB (4-bit) to fit a consumer GPU, why 4-bit is the sweet spot, and the local stack (GGUF, ollama, llama.cpp). With worked memory math and a runnable fits-in-VRAM calculator.
- [The PII in LLM Pipelines Handbook](https://vibeengines.com/handbook/pii-in-llm-pipelines): Handling personal data safely with the redact-before-send pattern: detect PII, replace each value with a stable placeholder before the model sees it, restore the real values in the response — so personal data never crosses the trust boundary to the provider. The leak invariant, consistent placeholders, detection limits, and defense in depth (minimization, BAA/DPA, local models). With worked math and runnable code.
- [The Multi-Agent Orchestration Handbook](https://vibeengines.com/handbook/multi-agent-orchestration): Coordinating multiple LLM agents on one task — and when not to. Why coordination overhead grows quadratically (N(N−1)/2 pairs) while useful work divides only linearly, so past an optimal team size more agents make a system slower, pricier, and less reliable, how to find where the U-curve turns, and the patterns (orchestrator-workers, handoff, routing) that keep coordination near-linear. With worked math and a runnable optimal-team-size calculator.
- [The Data Engineering for AI Handbook](https://vibeengines.com/handbook/data-engineering-for-ai): The pipeline that turns raw documents into usable data for RAG and training — ingest, chunk, deduplicate, quality-filter. How overlapping chunking works, why deduplication restores diversity, and why the usable dataset is a compounding fraction of the raw pile (raw × dedup-rate × quality-rate) — because quality beats quantity for both retrieval and training. With worked yield math and a runnable pipeline.
- [The Browser & Computer-Use Agents Handbook](https://vibeengines.com/handbook/browser-computer-use-agents): LLM agents that operate a UI like a human — no API required. The observe-act-verify loop, why grounding (identifying which element to click on a cluttered, shifting page) is the dominant source of failure, and why grounding errors compound: task success is per-step accuracy to the power of the number of steps (0.9¹⁰ ≈ 35%), so long UI tasks are brittle. Plus the prompt-injection surface. With worked math and runnable code.
- [The A2A Agent Interop Handbook](https://vibeengines.com/handbook/a2a-agent-interop): Letting heterogeneous agents from different teams work together. The two agreements A2A needs: capability discovery (agents advertise their skills so others can find and route to them) and a shared message schema (so one agent's output chains into another's input). Why both are required — a capable partner you can't talk to is useless — plus schema drift, capability lies, and how A2A relates to MCP. With worked math and runnable code.
- [The WebSockets & Real-Time Handbook](https://vibeengines.com/handbook/websockets-realtime): Why "live" is hard on a protocol that can't push. Polling makes you wait on average half the interval to learn of an event (a 10s poll = ~5s staleness) and wastes a request every time nothing changed — and shrinking the interval only multiplies the waste. A WebSocket keeps one persistent full-duplex line open so the server pushes the instant something happens: latency ≈ one network hop, zero empty requests. The poll-vs-push latency math, when to use SSE instead, and the stateful-scaling pitfalls. With worked math and runnable code.
- [The Voice AI Real-Time Agents Handbook](https://vibeengines.com/handbook/voice-ai-realtime-agents): Why a voice agent is a stopwatch, not a chat box. It's a three-stage pipeline — speech-to-text → LLM → text-to-speech — and the user waits for all three, so end-to-end latency is the sum of the stages. Human turn-taking breaks down past ~800ms, so the whole game is keeping that sum under the conversational budget: find the bottleneck (usually the LLM), shave the slowest stage first, cut network hops, and stream so the stages overlap. Plus endpointing, interruption handling, and why time-to-first-audio beats the naive sum. With worked math and runnable code.
- [The Caching Patterns Handbook](https://vibeengines.com/handbook/caching-patterns): Why the fastest query is the one you never run. A cache serves requests from a fast store and falls back to a slow source on a miss, so average latency is a hit-rate-weighted blend of the two paths — h·t_cache + (1−h)·t_source, dominated by the miss term. That makes hit rate the one number that decides a cache's value. The patterns (cache-aside, write-through, write-back), the eviction policy, and the two famously hard problems — invalidation/staleness and the cache stampede — that turn a speedup into an outage if you get them wrong. With worked math and runnable code.
- [Cryptography for Engineers](https://vibeengines.com/handbook/cryptography-for-engineers): Encryption from XOR up. The one-time pad — XOR each byte with a random, message-length, single-use key — is the only provably unbreakable cipher, and its three rules teach the whole subject. XOR is its own inverse (a⊕k⊕k=a), so decrypt is the same op; a zero key is the identity (why keys must be random); and the fatal mistake: reuse the key on two messages and c₁⊕c₂=p₁⊕p₂ — the key cancels and secrecy dies (the VENONA blunder). Scales to symmetric (AES) + public-key + nonces + TLS, and the engineer's rules: never roll your own, never reuse a nonce, secure randomness, hash passwords slowly. With worked math and runnable code.
- [The OAuth & Auth Deep Dive](https://vibeengines.com/handbook/oauth-auth-deep): How "Sign in with Google" lets an app act for you without ever seeing your password. OAuth swaps your credentials for a scoped, revocable token, delivered via a short-lived authorization code that's worthless on its own — turning it into a token needs a back-channel exchange the browser can't make. Two parameters guard the flow: state (a random value echoed back, blocking forged/CSRF responses) and PKCE (challenge = SHA-256(verifier), so a stolen code can't be redeemed without the secret). Plus authentication vs authorization, OIDC/ID tokens, and the traps (implicit flow, unvalidated tokens, wide scopes, token leaks). With worked math and runnable code.
- [The Operating Systems Fundamentals Handbook](https://vibeengines.com/handbook/os-fundamentals): How your machine runs hundreds of programs on a few cores and a fixed slab of RAM — by sharing what isn't enough. Two tricks carry the weight: round-robin scheduling slices CPU time into quanta so no process starves (paying for fairness in context-switch overhead), and virtual memory pages hot data into physical frames, faulting to disk on a miss and evicting the least-recently-used page (LRU) — so more frames means fewer faults. Plus the vocabulary (process/thread/context switch/system call/page fault/kernel vs user mode) and the traps (thrashing, over-threading, the million-to-one memory hierarchy). With worked math and a runnable scheduler + pager simulation.
- [The Linux Internals Handbook](https://vibeengines.com/handbook/linux-internals): Linux runs the world on one idea: everything is a file. A document, the keyboard, a socket, another program's output — all reached through a small integer (a file descriptor) with the same four calls: open, read, write, close. The descriptor table allocates the lowest free integer (0/1/2 = stdin/stdout/stderr), which is exactly how the shell redirects output; a pipe is a kernel FIFO whose two ends wire a | b so one tool's output becomes another's input; and fork/exec split process creation from program loading, opening the window where descriptors get wired. Plus the traps (fd leaks → EMFILE, pipe backpressure/deadlock, zombie processes). With worked math and a runnable fd-table + pipe.
- [The Compilers Basics Handbook](https://vibeengines.com/handbook/compilers-basics): How a flat string like "2 + 3 * 4" becomes the meaning 14 (not 20). A compiler works in stages: tokenize the text into atoms, parse the tokens by precedence, then evaluate. Built around a tiny arithmetic pipeline — tokenize → shunting-yard → RPN eval — where the single precedence comparison is exactly where "*" is encoded to bind tighter than "+", and parentheses override it. Then scale the same skeleton to real languages (AST, semantic analysis, optimization, IR/codegen, LLVM) and dodge the traps (parsing nested grammars with regexes, conflating stages, ignoring error positions). With worked math and a runnable end-to-end calculator.
- [The Browser Internals Handbook](https://vibeengines.com/handbook/browser-internals): How a browser turns a tree of tags and a pile of CSS into a scrolling, animating picture at 60fps. The render pipeline — parse → style → layout → paint → composite — is ordered and dependent, so the cost of a visual change is how far back it reaches. Layout (reflow) is the expensive stage because boxes are interdependent (cost grows with node count); geometric changes (width, top, adding a node) force it, paint-only changes (color) skip it, and transform/opacity stay on the composite-only fast path. Plus layout thrashing (interleaved read/write forces a sync reflow each time — batch them), and virtualizing giant DOM trees. With worked math and a runnable reflow calculator.
- [The Rust Handbook](https://vibeengines.com/handbook/rust): Rust refuses the old memory trade-off (safe-but-slow GC vs fast-but-dangerous manual free) with one idea: ownership. Every value has exactly one owner, freed when the owner's scope ends — no garbage collector, no manual free, never freed twice. Assigning or passing a value moves it (invalidating the original, so no double-free/use-after-move); to share you borrow under one rule — any number of shared references XOR exactly one mutable — which makes data races impossible; and clone() deep-copies when you truly need two. All checked at compile time, so safety costs nothing at runtime. Plus the guarantees table and the traps (cloning to silence the checker, fighting instead of listening, reaching for unsafe/Rc/RefCell too early). With worked rules and a runnable borrow-checker model.
- [The Go Handbook](https://vibeengines.com/handbook/go): Go makes concurrency approachable with one motto: don't communicate by sharing memory; share memory by communicating. Instead of threads poking at locked shared state, cheap goroutines (start with "go f()", run hundreds of thousands, multiplexed onto a few OS threads) pass data through channels — typed pipes that carry the synchronization. The whole model hinges on one rule: when does an operation block? An unbuffered channel (cap 0) blocks a send until a receiver is ready (a rendezvous); a buffered channel (cap N) blocks only when full/empty; and a blocked op with no partner is a deadlock (which Go's runtime detects and panics on). Plus goroutine leaks and when a mutex is still the right tool. With worked rules and a runnable channel model.
- [The TypeScript Handbook](https://vibeengines.com/handbook/typescript): Why TypeScript surprises people from Java/C#: its type system is structural, not nominal — it matches by an object's shape, not a declared name. A value is assignable to a type if it has every property the type requires with a matching type ("if it walks like a duck…"), so a wider object (extra props) fits a narrower target but a missing property never does. Object literals get one extra rule — the excess-property check — that flags undeclared props to catch typos (which is why extracting to a variable can make a type error vanish). Plus structural vs nominal trade-offs, branded types, and the traps (any disables checking; types are erased so validate external data at the boundary). With worked math and a runnable assignability checker.
- [The React Handbook](https://vibeengines.com/handbook/react): React lets you write UI declaratively — return a description of what it should look like — and makes it fast with reconciliation: it builds a lightweight virtual DOM, diffs it against the previous tree, and applies only the minimal real-DOM changes. For lists it matches items by key: a key in both old and new means reuse the element in place (keep its DOM node + state), a new key mounts, a gone key unmounts — so a pure reorder with stable keys costs zero. The famous bug: using the array index as a key breaks on reorder/insert, because an index is a position not an identity, so React reuses the wrong element and state leaks to the wrong row. Plus unnecessary re-renders, memo/useMemo/useCallback, and why the virtual DOM isn't automatically fast. With worked math and a runnable reconciler.
- [The Salary Negotiation Handbook](https://vibeengines.com/handbook/salary-negotiation): The expected-value case for always countering an offer. A polite counter is accepted with some probability p and otherwise the employer just holds the original (they essentially never rescind over a reasonable ask), so EV = p·counter + (1−p)·original beats accepting for any p>0 — heads you win, tails you break even. Your BATNA (best alternative) is your real leverage and your accept-floor; improve it before the conversation with competing offers. And a base bump compounds — its lifetime value is a geometric series, ≈$55k for a $10k raise over 5 years at 5%, not $50k. Plus how to actually do it (research, let them anchor, counter in writing, negotiate the whole package and level) and the traps. With worked math and a runnable EV calculator.
- [The Code Review Culture Handbook](https://vibeengines.com/handbook/code-review-culture): The quantitative case for code review plus the human norms that make it pay off. A defect costs ~1× to fix in review, ~10× in test, ~100× in production — so review, the earliest human checkpoint, catches bugs at the cheapest stage and returns many times the reviewer's time (net = bugs-caught × the prod-vs-review gap − review cost). But the ROI is only realized when the culture is right: small PRs (a giant diff gets a rubber-stamp = negative value), automated style so humans never nit it, prompt reviews, blocking-vs-nit clarity, and the golden rule — critique the code, not the coder. Plus how to give/receive feedback and the traps. With worked math (defect-cost curve + review ROI) and a runnable calculator.
- [The EU AI Act Handbook](https://vibeengines.com/handbook/eu-ai-act): The world's first comprehensive AI law, made legible for engineers. The key idea: it regulates AI by the risk of the use case, not the technology — the same model is unregulated in a spam filter and heavily regulated in a hiring tool. Every system sorts into one of four tiers: unacceptable (banned — social scoring, manipulation, most real-time public biometric ID), high-risk (hiring, credit, medical, education, law enforcement… → risk management, data governance, human oversight, conformity assessment, registration), limited-risk (transparency — chatbots disclose they're AI, deepfakes labelled), and minimal-risk (no obligations — the vast majority). Because tiering is a concrete rule, classification is deterministic. Plus the GPAI/foundation-model layer, what engineers should actually do, and the traps (optimistic self-classification, retrofitting compliance). With a worked classification model and runnable code.
- [The AI Product Engineering Handbook](https://vibeengines.com/handbook/ai-product-engineering): A demo isn't a product. Getting an impressive LLM demo takes an afternoon; turning it into something you can charge for at scale is the brutal last mile where most AI features die. Product engineering rests on two numbers a demo never shows: unit economics (every request costs tokens — cost = in·p_in + out·p_out per million, which sets your gross margin and whether you're profitable) and the eval gate (ship a change only if its measured quality clears a bar AND its margin clears a bar — blocking cheap-but-wrong and great-but-unprofitable alike). Plus the reliability stack (evals, structured outputs, retries/fallbacks, caching, guardrails, observability) that keeps a flaky, pricey, non-deterministic model dependable in production. With worked math and a runnable cost/margin/ship-decision calculator.
- [The Resume & Portfolio Handbook](https://vibeengines.com/handbook/resume-portfolio): Your resume has two readers and the first isn't human. Most applications hit an ATS (applicant tracking system) that scores keyword coverage against the job — coverage = |resume ∩ required| / |required| — and auto-filters anything below a threshold, so a qualified engineer gets rejected on missing keywords. Step one: clear the machine by tailoring keywords in the posting's own words (for skills you have) in a clean single-column format that parses. Step two: win the human with quantified-impact bullets — a bullet with a number ("reduced latency 40%") beats a vague responsibility ("worked on the backend"). Plus what an engineer's portfolio needs (a few working, well-documented projects, curated not exhaustive) and the traps. With worked math (ATS coverage + gate, bullet impact) and a runnable resume scorer.
- [The Staff Engineer Behaviors Handbook](https://vibeengines.com/handbook/staff-engineer-behaviors): The hardest promotion in engineering — senior to staff — trips people up because they aim at the wrong target: writing more/better code, when the level is a change in the unit of impact. Senior is measured by own output; staff+ by leverage — the output you create in others (an architecture that unblocks three teams, a standard that speeds everyone, a mentee who levels up). Total impact = own_output + Σ multipliers, a team-wide boost is worth team_size × per_person_boost, and staff-level is the threshold where leverage dominates personal output. Covers Larson's four archetypes (tech lead / architect / solver / right hand), glue work and why it's under-credited, how to operate (work on what matters, write relentlessly, influence without authority, multiply others, stay technically credible), and the traps (hero IC, architecture astronaut, invisible glue). With a worked leverage model and runnable code.
- [AI for Accountants](https://vibeengines.com/handbook/ai-for-accountants): The practical middle ground for accounting and tax professionals: where AI genuinely helps (first drafts, document summaries, reconciliation triage, plain-language client explanations), the three non-negotiable rules — client-data confidentiality (incl. IRC §7216), verify every number and authority, you sign it you own it — five workflow recipes with exact prompts, a spot-the-danger judgment exercise, and the five questions to ask any AI vendor. No coding required.
- [AI for Teachers](https://vibeengines.com/handbook/ai-for-teachers): The practical middle ground for educators: where AI genuinely helps (lesson plans, differentiating materials into reading levels, first-draft feedback and rubrics, quiz generation, parent emails), the three non-negotiable rules — student-data privacy (FERPA), verify every fact and answer key, you are still the teacher — five workflow recipes with exact prompts, how to handle AI in students' own work (detectors are unreliable), and the questions to ask any AI vendor. No coding required.
- [AI for Architects](https://vibeengines.com/handbook/ai-for-architects): The practical middle ground for architectural practice: where AI genuinely helps (concept ideation, first-draft narratives and specs, document summaries, research starting points, early renderings), the three non-negotiable rules — you stamp it you own it, verify every code/zoning/structural claim against the adopted code, protect confidential client and site data — five workflow recipes with exact prompts, a spot-the-danger judgment exercise, and the questions to ask any AI vendor. No coding required.
- [AI for Real Estate](https://vibeengines.com/handbook/ai-for-real-estate): The practical middle ground for agents and brokers: where AI genuinely helps (listing descriptions, client follow-ups, market-data summaries, process explanations, social content), the three non-negotiable rules — fair-housing compliance (AI easily generates illegal steering language), verify every fact and number, you are not giving legal/tax/appraisal advice — five workflow recipes with exact prompts, a spot-the-danger judgment exercise, and the questions to ask any AI vendor. No coding required.
- [AI for Marketers](https://vibeengines.com/handbook/ai-for-marketers): The practical middle ground for marketers: where AI genuinely helps (first-draft copy, ideation, repurposing one asset into many formats, briefs, research/analytics summaries), the three non-negotiable rules — never publish fabricated claims/stats/testimonials (FTC false-advertising risk), stay on-brand and recognizably human, verify facts and respect IP — five workflow recipes with exact prompts, a spot-the-danger judgment exercise, and the questions to ask any AI vendor. No coding required.
- [AI for HR](https://vibeengines.com/handbook/ai-for-hr): The practical middle ground for HR and recruiting: where AI genuinely helps (job descriptions, first-draft policies, structured interview guides, internal comms, anonymized feedback summaries), the three non-negotiable rules — AI never makes a consequential decision about a person (a human decides), actively guard against discrimination/bias (EEOC + NYC Local Law 144 + EU AI Act high-risk), protect sensitive candidate/employee data — five workflow recipes with exact prompts, a spot-the-danger judgment exercise, and the questions to ask any AI vendor. No coding required.
- [AI for Financial Analysts](https://vibeengines.com/handbook/ai-for-financial-analysts): The practical middle ground for financial analysis: where AI genuinely helps (summarizing filings and transcripts, first-draft memos and commentary, structuring/stress-testing model logic, first-pass qualitative research), the three non-negotiable rules — verify every number/calculation/source (models miscalculate and fabricate figures), MNPI and confidential data never touch an unapproved tool (information barriers, securities law), the analysis and recommendation and accountability are yours — five workflow recipes with exact prompts, a spot-the-danger judgment exercise, and the questions to ask any AI vendor. No coding required.
- [AI for Journalists](https://vibeengines.com/handbook/ai-for-journalists): The practical middle ground for reporters and editors: where AI genuinely helps (transcription, document/report summaries, headline and structure ideas, research starting points, plain-language explainers), the three non-negotiable rules — verify everything and never publish an unverified fact or quote (models fabricate quotes and sources), protect your sources and confidential material, be transparent and never pass AI text off as reporting (plagiarism/attribution) — five workflow recipes with exact prompts, a spot-the-danger judgment exercise, and the questions to ask any AI vendor. No coding required.
- [AI for Product Managers](https://vibeengines.com/handbook/ai-for-product-managers): The practical middle ground for PMs: where AI genuinely helps (PRD/spec drafts, synthesizing research you actually gathered, competitive-scan starting points, pressure-testing your reasoning, stakeholder comms), the three non-negotiable rules — never let AI fabricate user data/metrics/findings (it invents plausible insights representing nobody), prioritization and product judgment stay human, protect confidential roadmap and customer data — five workflow recipes with exact prompts, a spot-the-danger judgment exercise, and the questions to ask any AI vendor. No coding required.
- [AI for Sales](https://vibeengines.com/handbook/ai-for-sales): The practical middle ground for sales reps: where AI genuinely helps (personalized outreach from real research, follow-ups, call summaries from your notes, objection prep, CRM drafts), the three non-negotiable rules — never make a false product claim or over-promise (AI invents features/results = misrepresentation that breaks deals and trust), protect prospect data and follow call-recording/consent law, the relationship and discovery and close stay human — five workflow recipes with exact prompts, a spot-the-danger judgment exercise, and the questions to ask any AI vendor. No coding required.
- [RAG vs Long Context](https://vibeengines.com/handbook/rag-vs-long-context): A 1M-token window makes it tempting to skip retrieval entirely — but bigger context doesn’t mean the model reads it evenly, and it isn’t cheap. The "lost in the middle" attention problem, cost-at-scale math, and the retrieve-then-go-long pattern that combines both.
- [LoRA vs Full Fine-Tuning](https://vibeengines.com/handbook/lora-vs-full-fine-tuning): LoRA freezes the base model and trains a tiny low-rank adapter; full fine-tuning updates every weight. Why a low-rank update can work at all, memory and storage trade-offs, multi-task adapter serving, and when the extra cost of full fine-tuning is worth it.
- [MCP vs A2A](https://vibeengines.com/handbook/mcp-vs-a2a): Different layers, not rivals: MCP connects an agent to its own tools and data; A2A connects one autonomous agent to another. Why one protocol wasn’t enough for both jobs, and how a single agent uses both — MCP as its hands, A2A as its voice to peers.
- [Agents vs Workflows](https://vibeengines.com/handbook/agents-vs-workflows): Autonomy is a cost, not a default. Workflows hardcode the path in your own code; agents let the model decide its next step at runtime. Why it’s a spectrum, not a binary, and the decision rule for when unpredictability actually justifies an agent loop.
- [Embeddings vs Keyword Search](https://vibeengines.com/handbook/embeddings-vs-keyword-search): Embeddings match meaning even with zero shared words; keyword search (BM25) matches exact terms with a precision embeddings can’t guarantee. Why the two fail in genuinely complementary ways, and why hybrid search with fusion is the modern RAG default.
- [Kafka vs Kinesis](https://vibeengines.com/handbook/kafka-vs-kinesis): Same partitioned-log model underneath, different operational surface: Kafka is self-run and portable with a huge ecosystem; Kinesis is fully AWS-managed with a hard per-shard throughput ceiling. Retention, cost model, and the lock-in trade-off.
- [REST vs Webhooks vs SSE](https://vibeengines.com/handbook/rest-vs-webhooks-vs-sse): Three ways client and server move data, split by who exposes an endpoint and whether the connection stays open: REST pulls, webhooks flip who runs the server, SSE keeps one connection open for a live push. How real systems run all three at once.
- [Monolith vs Microservices](https://vibeengines.com/handbook/monolith-vs-microservices): Microservices don’t remove complexity, they relocate it from the codebase into the network. Why the real trigger to split is organizational (Conway’s Law), not code size, and why "monolith first" is the pattern behind most successful splits.
- [LLM vs SLM](https://vibeengines.com/handbook/llm-vs-slm): The choice is about deployment constraints, not just raw capability: LLMs run in the cloud with broad reasoning; SLMs run on-device with near-zero latency, cost, and full privacy. Why the capability gap is shrinking fast, and the model-routing pattern that uses both.
- [GPU vs TPU](https://vibeengines.com/handbook/gpu-vs-tpu): GPUs are flexible general-purpose processors with the CUDA ecosystem behind them; TPUs are ASICs purpose-built around the systolic array for matmul, on Google Cloud only. Why that specialization is efficient exactly where it fits, and a liability the moment it doesn’t.
- [Streaming vs Batch](https://vibeengines.com/handbook/streaming-vs-batch): Batch processes on a schedule; streaming reacts per-event. The real engineering cost of streaming isn’t speed, it’s correctness under disorder — event time vs processing time, watermarks, exactly-once semantics. The Lambda and Kappa architectures that combine both.
- [OLTP vs OLAP](https://vibeengines.com/handbook/oltp-vs-olap): One storage-layout decision explains the whole comparison: row-oriented OLTP makes fetching one record cheap, column-oriented OLAP makes aggregating one column across millions of rows cheap. Why you can’t run heavy analytics well on your production database.
- [Raft vs Paxos](https://vibeengines.com/handbook/raft-vs-paxos): Provably equivalent in power, radically different to implement: Raft bets on a strong leader to make consensus reasoning-friendly; Paxos’s more general, leaderless formulation is more flexible and notoriously hard to get right. Why etcd and Kubernetes chose Raft.
- [CP vs AP Databases](https://vibeengines.com/handbook/cp-vs-ap-databases): CAP theorem’s forced choice, precisely stated: CP systems refuse some requests to guarantee consistency during a partition; AP systems keep serving, possibly stale, data. Why this trade-off only bites during an actual partition, and how real systems pick per data type.
- [LLM API Pricing](https://vibeengines.com/handbook/llm-api-pricing): Every major provider’s API pricing in one comparable table, per million tokens — Anthropic Claude, OpenAI GPT, Google Gemini — pulled from official docs on 2026-07-21, not aggregators. Batch and prompt-caching discounts, a cross-provider tier map, and a fully worked chatbot cost example.
- [Tokenizer Efficiency Benchmark](https://vibeengines.com/handbook/tokenizer-efficiency-benchmark): An original, reproducible benchmark of 9 real tokenizers across English prose, code, and non-English text — measuring characters-per-token and encode speed, with a fidelity check that catches the trap where a lossy tokenizer looks “efficient” only because it silently drops characters it can’t represent.
- [The Forward Deployed Engineer: Role & Mindset](https://vibeengines.com/handbook/fde-role-and-mindset): The fastest-growing engineering title in AI, demystified: what an FDE actually does (owns the customer outcome, not the ticket), how it differs from a software engineer, solutions engineer, and consultant, the mindset shifts it demands, a week in the life, and how to break in.
- [Customer Discovery & Scoping for FDEs](https://vibeengines.com/handbook/customer-discovery-and-scoping): How FDEs find the real problem before building the wrong one: the wrong-problem tax, watching users instead of asking, the questions that surface truth, defining success as one number, scoping the smallest slice that proves value, and the red flags that mean a deployment will stall.
- [Customer Integration Patterns for FDEs](https://vibeengines.com/handbook/customer-integration-patterns): Integration is where POCs die. The FDE playbook: the five integration families (REST/GraphQL, webhooks, files/SFTP, database/CDC, queues), auth into customer systems (API keys, OAuth, mTLS), reliability at the edge (idempotency, retries with jitter, webhook verification, dead-letter), and mapping messy customer data.
- [Rapid Prototyping for FDEs](https://vibeengines.com/handbook/rapid-prototyping-for-fdes): How FDEs build a convincing prototype in days, not months: throwaway-first thinking, the smallest demoable vertical slice, choosing a boring fast stack, faking the non-core parts honestly (hardcode / stub / Wizard-of-Oz), demo-driven development, and knowing when to throw it away versus harden.
- [Deploying in Customer Environments](https://vibeengines.com/handbook/deploying-in-customer-environments): Ship where the customer can actually run it: the four deployment targets (your SaaS, the customer’s cloud/VPC, on-prem, and air-gapped), what changes as you move right — data egress, updates, model hosting, secrets, observability, and your own access — plus packaging portably and the air-gapped update path.
- [The Demo & Storytelling Playbook](https://vibeengines.com/handbook/demo-and-storytelling): A demo is a performance, not a code review. How FDEs prep (their data, rehearse, a fallback recording), structure the story (open with the problem, show-then-explain, land the "so what"), recover from a live failure without debugging on stage, read the audience (exec / IT / user), and follow up while it’s hot.
- [Security & Compliance for FDEs](https://vibeengines.com/handbook/security-and-compliance-for-fdes): Enough security to earn a customer’s "yes": what SOC 2, HIPAA, GDPR and PCI actually ask, how to handle data and secrets, what a security review checks, and the AI-specific risks (prompt injection, data leakage to model providers, PII in prompts) an FDE has to manage.
- [Solutions Engineering & Stakeholder Management](https://vibeengines.com/handbook/solutions-engineering-and-stakeholder-management): The non-code half of the FDE job: mapping the room (champion, blocker, decision-maker, user), managing scope creep with a visible later-list, saying no kindly, setting expectations and surfacing risk early, and multi-threading so one person can’t sink the deployment.
- [From POC to Production: Hardening](https://vibeengines.com/handbook/poc-to-production-hardening): The gap between "it demoed" and "people depend on it": how FDEs harden a proof of concept into a real system — reliability (sad-path handling, idempotency, backpressure, validation), observability (structured logs, metrics, health checks), security and config hygiene, and the harden-versus-rebuild decision.
- [Handoff & Enablement for FDEs](https://vibeengines.com/handbook/handoff-and-enablement): How FDEs hand off a deployment without becoming a permanent, unpaid support team: why the exit is the goal, what to hand off (runbook, docs, architecture, who-to-call), how to write a runbook that survives 2 a.m., enabling the customer’s team hands-on, and defining the exit up front.
- [Learning a Customer’s Domain Fast](https://vibeengines.com/handbook/learning-a-domain-fast): How FDEs get dangerous in a new field in a week: why domain fluency is a superpower, learning from the customer’s real data, running SME interviews that teach you (the naive-question license), building a glossary of their terms, finding the 80/20 of a domain, and how fluency compounds trust.
- [AI App Patterns for FDEs](https://vibeengines.com/handbook/ai-app-patterns-for-fdes): The AI toolkit a modern FDE deploys: RAG over the customer’s documents, agents that drive their workflows, and evals as the acceptance test — plus how to choose between prompting, RAG, agents, and fine-tuning, and how to ship AI honestly with a good-enough bar and a human in the loop.
- [Test-Time Compute & Reasoning Models](https://vibeengines.com/handbook/test-time-compute): Why letting a model think longer at inference — long chain-of-thought, sampling with self-consistency, best-of-N with a verifier, and search — can beat a much larger model on hard problems. How o1/o3- and DeepSeek R1-style reasoning models are trained to use a thinking budget, the train-time vs test-time scaling trade, and when spending the extra compute actually pays.
- [RL from Verifiable Rewards (RLVR)](https://vibeengines.com/handbook/rlvr-verifiable-rewards): The training technique behind modern reasoning models: reinforcement learning where the reward comes from a programmatic check (a unit test passing, a math answer matching) instead of a gameable learned reward model. How it differs from RLHF, the GRPO/PPO loop, why reasoning behaviors emerge in DeepSeek R1-Zero, and where verifiable rewards run out.
- [World Models](https://vibeengines.com/handbook/world-models): What it means for AI to learn a predictive model of an environment it can imagine inside — the basis of model-based RL, planning, and controllable simulation. The three families (latent control models like Dreamer, generative interactive video like Genie/Sora, and JEPA), how a latent world model learns and acts in imagination, and the debate over whether video generators really understand physics.
- [GraphQL vs REST](https://vibeengines.com/handbook/graphql-vs-rest): GraphQL vs REST, decided by who chooses the shape of the response: REST exposes many fixed resource URLs and the server decides what each returns; GraphQL exposes one endpoint and the client asks for exactly the fields it needs. Over- and under-fetching, HTTP caching vs the N+1 problem, versioning, and when each wins — plus why "REST services behind a GraphQL gateway" is so common.
- [MoE vs Dense Models](https://vibeengines.com/handbook/moe-vs-dense-models): Mixture of Experts vs dense LLMs, decided by which parameters fire per token: a dense model runs every parameter on every token; an MoE routes each token to a few expert sub-networks, holding far more total parameters but activating only a fraction. The compute win, the memory tax (all experts must sit in VRAM), load balancing, and when each wins.
- [Encoder vs Decoder Models](https://vibeengines.com/handbook/encoder-vs-decoder-models): Encoder vs decoder Transformers, decided by which way attention flows: an encoder reads the whole input at once (bidirectional) to build representations — great for classification, NER and embeddings (BERT); a decoder generates left to right (causal) — great for chat, code and agents (GPT). Encoder-decoder models like T5 do both. When to reach for each, and why real systems chain them.
- [Quantization vs Distillation](https://vibeengines.com/handbook/quantization-vs-distillation): Quantization vs distillation for shrinking LLMs, decided by what you change: quantization keeps the same model but stores its weights in fewer bits (FP16 → INT8/INT4); distillation trains a smaller student model to imitate a bigger teacher. One compresses the representation, the other the architecture — the quality-vs-size frontier of each, and why teams often distill then quantize.
- [Cross-Encoder vs Bi-Encoder](https://vibeengines.com/handbook/cross-encoder-vs-bi-encoder): Cross-encoder vs bi-encoder for semantic search, decided by when the query meets the document: a bi-encoder embeds query and document separately so document vectors precompute and scale to millions; a cross-encoder feeds them together for a far more accurate relevance score, but runs per pair at query time. Why production retrieval uses a bi-encoder to retrieve and a cross-encoder to rerank.
- [SQL vs Vector Database](https://vibeengines.com/handbook/sql-vs-vector-database): SQL vs vector databases, decided by the kind of question you ask: a relational database answers exact, structured queries over rows (WHERE price < 50); a vector database answers similarity queries over embeddings (find the items most like this). Exact filters vs approximate nearest neighbors, B-tree vs HNSW, pgvector, and why most real systems need both.
- [Batch vs Real-Time Inference](https://vibeengines.com/handbook/batch-vs-realtime-inference): Batch vs real-time (online) inference, decided by whether a human is waiting: batch processes many inputs together offline for maximum throughput and lowest cost per token; real-time answers one request at a time with low latency. GPU utilization, continuous batching, and why most AI products run both.
- [Orchestration vs Choreography](https://vibeengines.com/handbook/orchestration-vs-choreography): Orchestration vs choreography for coordinating microservices, decided by where control lives: orchestration puts one central coordinator in charge of a workflow; choreography lets services react to events with no central controller. Central visibility vs loose coupling, the saga pattern, and when to use each.
- [Optimistic vs Pessimistic Locking](https://vibeengines.com/handbook/optimistic-vs-pessimistic-locking): Optimistic vs pessimistic locking, decided by how likely two writers collide: pessimistic locks a row before editing so others wait; optimistic edits without a lock and checks a version on write, retrying on conflict. Contention, deadlocks, retry storms, and when each wins.
- [TCP vs UDP](https://vibeengines.com/handbook/tcp-vs-udp): TCP vs UDP, decided by whether every byte must arrive: TCP is connection-oriented and guarantees reliable, in-order delivery with flow and congestion control; UDP is connectionless and fires packets with no guarantees and almost no overhead. Head-of-line blocking, why real-time uses UDP, how QUIC/HTTP-3 gets both, and when each wins.
- [Process vs Thread](https://vibeengines.com/handbook/process-vs-thread): Process vs thread, decided by whether they share memory: a process is an independent program with its own isolated memory; a thread runs inside a process and shares its memory. Isolation and safety vs cheap, fast, shared-memory concurrency — creation and context-switch cost, crash blast radius, the Python GIL, and when to use each.
- [Mechanistic Interpretability](https://vibeengines.com/handbook/mech-interp-for-engineers): The engineer's guide to reading a model — interpretability as a debugger, not a séance. Why features live in superposition (not one per neuron), how sparse autoencoders pull monosemantic features back out, how attribution and circuit tracing find why a model did something (contribution of input i to output = the summed path weight W2·W1, validated causally by ablation), feature steering as a direct intervention, and an honest map of what you can debug today versus what is still research. Worked math plus a runnable 2-layer circuit tracer.
- [Agentic Payments](https://vibeengines.com/handbook/agentic-payments): How to let an agent pay without letting it drain your account. The x402 machine-native checkout (HTTP 402: server returns payment terms, agent pays and retries with proof), signed MANDATES that scope spending like OAuth scopes for money (AP2), and spend caps enforced BEFORE execution — authorize ⟺ amount ≤ per-txn AND spent+amount ≤ total AND merchant ∈ allowed. The runaway-agent threat and why the cap belongs in the payment layer, not the prompt. Worked math plus a runnable mandate-and-cap enforcer that stops a looping agent cold at its budget.
- [Diffusion LLMs](https://vibeengines.com/handbook/diffusion-llms): Text generation that isn't one token at a time. Why autoregressive decoding is latency-bound (N tokens = N sequential passes), how block diffusion denoises B tokens in K steps to emit B/K tokens per pass (⌈N/B⌉·K total passes, speedup B/K) for reported 1,000+ tokens/sec, the crucial image-vs-text split (continuous Gaussian noise over pixels vs a discrete masking corruption over tokens), and the speed-quality knob (fewer steps = faster but more parallel-commitment error). Worked math plus a runnable AR-vs-diffusion pass counter.
- [Agent Supply-Chain Security](https://vibeengines.com/handbook/agent-supply-chain-security): The other door into your agent — the one you open yourself. Every skill and MCP server you INSTALL is third-party code running with permissions, an install-time threat distinct from runtime prompt injection. Why compromise risk compounds with dependency count (1−(1−p)^N: 20 deps at 5% each ≈ 64%), how blast radius = the capabilities a compromised component holds and least-privilege (grant = needed ∩ offered) bounds it, and the two levers — vet to lower p, sandbox to bound damage. Worked math plus a runnable risk-and-blast-radius model.
- [RL Environments Engineering](https://vibeengines.com/handbook/rl-environments-engineering): The build side of verifiable rewards — the reasoning models everyone celebrates are taught by the ENVIRONMENT, not the algorithm. Why RL learns only from reward variance p(1−p) (zero signal when every attempt passes or fails, peak at a 50% pass rate) so tasks must sit in the difficulty band, why a gameable verifier corrupts training (precision = correct ÷ all rewarded; every false positive is a lie the model learns), and how to engineer difficulty curricula and verifier soundness. The theory of reward hacking lives in the verifiable-rewards handbook; this is how to build around it. Worked math plus a runnable learning-signal and verifier-precision model.
- [MCP Apps](https://vibeengines.com/handbook/mcp-apps): Interactive UIs inside Claude and ChatGPT — the first official UI extension to the Model Context Protocol. How a third-party UI runs as a SANDBOXED IFRAME (no ambient authority — can't touch the host DOM, storage, or network), why every capability call crosses a postMessage JSON-RPC bridge (method + params + id, response with the same id), and how the HOST MEDIATES each request against an allowlist (method ∈ allowlist ? execute : error −32601) so the app can only do what the host chose to expose. Sandbox + bridge + allowlist = the whole security model. Distinct from the MCP-server backend. Worked protocol plus a runnable host-mediation gatekeeper.
- [Self-Improving Agents](https://vibeengines.com/handbook/self-improving-agents): Agents that get better from their own production traces improve on exactly two axes, with opposite properties. MEMORY: store a solved trajectory/skill for exact recall — instant to add and forget, but no generalization (a notebook). WEIGHTS: fine-tune on FILTERED correct traces — generalizes to unseen similar tasks, but bakes in what you trained on and is hard to reverse (a habit). Why you filter traces before training (a loop trained on its own confident errors drifts or collapses — same what-you-reinforce-is-what-you-get rule as RL), and the safety rails that follow from permanence: filter first, prefer reversible, canary before rollout, watch for drift/gaming. Cites STaR, Voyager, Reflexion as the mechanism family. Worked math plus a runnable memory-vs-weights model.
- [Long-Horizon Agents](https://vibeengines.com/handbook/long-horizon-agents): Why a 10-step task the agent nails becomes a 100-step task it never finishes — reliability COMPOUNDS: a single run of k steps succeeds with probability p^k (95% per step, 100 steps = 0.6%). The fix is engineering, not a better model: CHECKPOINT progress so a failure doesn't restart from zero, and RESUME + retry the failed segment only — a c-step segment retried r times succeeds 1−(1−p^c)^r, so the whole task climbs to [1−(1−p^c)^r]^(k/c), turning that 0.6% into ~51% at the same per-step reliability. The METR time-horizon idea and how reliability engineering extends it. The pass@k-vs-pass^k measurement lives in the agent-evals handbook (linked, not re-derived). Worked math plus a runnable no-checkpoint-vs-checkpointed model.
- [AI-Assisted Interviews](https://vibeengines.com/handbook/ai-assisted-interviews): The 2026 technical-interview FORMAT (distinct from the content handbooks): AI is now allowed in the room, so the exam shifts from writing algorithms from memory to working WITH AI — code-comprehension rounds, AI-fluency rubrics, and frontier-lab eval-design rounds. The one equation behind the shift: when the AI is correct with probability p, a reviewing human's value is pure review skill — final = p·(1−p_falsepos) + (1−p)·p_catch — so a skilled reviewer lifts output above the AI alone while a careless one (breaks correct code, catches little) drags it BELOW raw AI (an unskilled AI user is net-negative). The new round types and how to prepare (read/audit/test, not just write). Worked math plus a runnable reviewer-value model.
- [Autoregressive vs Diffusion LLMs](https://vibeengines.com/handbook/autoregressive-vs-diffusion-llms): Autoregressive vs diffusion language models, decided by how text is generated: autoregressive models emit one token at a time left-to-right, each conditioned on all previous; diffusion LLMs refine every position in parallel over a fixed number of denoising steps. Decode latency, KV cache, revisability, the quality gap, and where block diffusion fits.
- [Agent Skills vs MCP](https://vibeengines.com/handbook/agent-skills-vs-mcp): Agent Skills vs the Model Context Protocol, decided by what each adds: a Skill is packaged knowledge and procedure loaded into the agent’s context to change how it behaves; MCP is a protocol that grants live tools and data over a wire at runtime. Portability, token cost, security surface, and why the two compose rather than compete.
- [Vibe Coding vs Spec-Driven Development](https://vibeengines.com/handbook/vibe-coding-vs-spec-driven-development): Vibe coding vs spec-driven development, two ways to build with AI: vibe coding is conversational and exploratory — prompt, run, keep what works; spec-driven development writes a precise spec first and has the agent implement against it with tests as the contract. The spec→plan→tasks→implement loop, where each breaks, and how to combine them.
- [Claude Code vs Codex vs Gemini CLI](https://vibeengines.com/handbook/claude-code-vs-codex-vs-gemini-cli): Three terminal-native agentic coding tools from Anthropic, OpenAI and Google that share one loop — read the repo, plan, edit files, run commands, iterate. How they differ on model, extensibility, openness and permissions, what the reported mid-2026 market numbers say (handled with care), and how to actually choose.
- [vLLM vs TGI vs SGLang](https://vibeengines.com/handbook/vllm-vs-tgi-vs-sglang): Three open-source LLM serving engines that all do continuous batching but differ in their signature KV-cache trick: vLLM’s PagedAttention (removes fragmentation), SGLang’s RadixAttention (shares repeated prefixes), and TGI’s production-hardened Hugging Face integration. Where each wins, why "fastest" is a workload question, and how to choose.
- [The AI-Era Backend Engineer](https://vibeengines.com/handbook/ai-era-backend-engineer): How the backend-engineer job changes in the AI era — and how to be the one who gets more valuable, not less. Boilerplate, CRUD and first-draft tests get cheap; system design, debugging, security judgment and production ownership become the moat. The new stack (reviewing AI code, spec-driven development, evals + cost/latency for LLM features), five AI-augmented workflows, a judgment exercise, and a 90-day plan.
- [The AI-Era Frontend Engineer](https://vibeengines.com/handbook/ai-era-frontend-engineer): How the frontend-engineer job changes in the AI era — and how to be the one who gets more valuable. Component scaffolding, CSS and markup get cheap; interaction and UX judgment, accessibility, performance and perceived latency, state architecture, and building AI-native interfaces (streaming, chat, copilot) become the moat. The new stack, five AI-augmented workflows, a judgment exercise, and a 90-day plan.
- [The AI-Era Product Manager](https://vibeengines.com/handbook/ai-era-product-manager): How the product-manager job changes in the AI era — and how to be the PM who gets more valuable. PRDs, research synthesis and comms get cheap; judgment, taste, user truth and accountability become the moat, plus a new stack: evals literacy, the unit economics of AI features, and agent/AI UX. Five AI-augmented workflows, a judgment exercise, and a 90-day plan. The career companion to AI for Product Managers (tool literacy).
- [The AI-Era DevOps Engineer](https://vibeengines.com/handbook/ai-era-devops-engineer): How the DevOps / platform-engineer job changes in the AI era. Pipeline YAML, Dockerfiles, boilerplate IaC and scripts get cheap; reliability, incident response, security, cost/FinOps and platform-as-product become the moat — plus a new stack: reviewing AI-generated infrastructure for blast radius, AIOps signal-vs-noise, and golden paths. Five AI-augmented workflows, a judgment exercise, and a 90-day plan.
- [The AI-Era Data Engineer](https://vibeengines.com/handbook/ai-era-data-engineer): How the data-engineer job changes in the AI era. SQL, pipeline glue and connector code get cheap; data modeling, quality and contracts, cost, lineage and the semantic layer become the moat — plus a new high-demand specialty: building the data pipelines that feed AI (RAG ingestion, embeddings, eval datasets). Five AI-augmented workflows, a judgment exercise, and a 90-day plan.

## System Design Walkthroughs
- [Design Uber](https://vibeengines.com/systemdesign/uber-system-design): Build a planet-scale ride-hailing system. Learn how to handle real-time location tracking, matching algorithms, scalability, and payments.
- [Design a URL Shortener](https://vibeengines.com/systemdesign/url-shortener-system-design): Build a URL shortener (think Bitly or TinyURL). Learn how to mint unique short codes with base62, make the read-heavy redirect path sub-millisecond with caching, shard billions of mappings, and track clicks asynchronously.
- [Design WhatsApp](https://vibeengines.com/systemdesign/whatsapp-system-design): Build a real-time messaging system. See how persistent WebSockets, a session registry, offline inbox queues, the ✓✓ delivery receipts, group fan-out, media on a CDN, and end-to-end encryption fit together.
- [Design Twitter](https://vibeengines.com/systemdesign/twitter-system-design): Build Twitter's news feed. Learn the social graph, why fan-out on write beats read-time merging, how a precomputed timeline cache makes feed reads O(1), how ranking surfaces the best tweets, and how a hybrid model solves the celebrity problem.
- [Design YouTube](https://vibeengines.com/systemdesign/youtube-system-design): Build a planet-scale video platform. See how raw uploads become an adaptive-bitrate ladder through an async transcoding pipeline, how a CDN serves immutable segments from the edge, how tiered blob storage holds exabytes affordably, and how view counts stay async.
- [Design a Rate Limiter](https://vibeengines.com/systemdesign/rate-limiter-system-design): Build a distributed rate limiter. Learn where to put the check, how to key and tier limits, the token-bucket and sliding-window algorithms, why shared atomic counters in Redis avoid race conditions, and the fail-open vs fail-closed trade-off.
- [Design Dropbox](https://vibeengines.com/systemdesign/dropbox-system-design): Build a file sync engine. See how splitting metadata from bytes, content-addressed block storage with deduplication, delta sync, a push-then-pull notification service, and conflict-safe versioning fit together to keep files consistent across every device.
- [Design Ticketmaster](https://vibeengines.com/systemdesign/ticketmaster-system-design): Build an event-booking system. Tackle the double-booking problem head-on: seat inventory, short-lived holds with TTLs, exactly-once purchases via ACID transactions, payment sagas with idempotency, and a virtual waiting room that tames the on-sale stampede.
- [Design a Notification System](https://vibeengines.com/systemdesign/notification-system-design): Build a multi-channel notification system. See how one API, a message queue and a worker fleet decouple slow third-party delivery, how preferences and quiet hours gate every send, how templates fan out to push, SMS and email, and how delivery tracking, retries, dedup and rate limits keep it reliable.
- [Design Typeahead (Autocomplete)](https://vibeengines.com/systemdesign/typeahead-system-design): Build a search typeahead. See how a prefix trie turns search into an O(L) walk, how a prefix-keyed cache answers the skewed common case in under a millisecond, how precomputed top-k ranking surfaces the best ten, how an offline builder keeps suggestions fresh from query logs, and how to personalize and shard.
- [Design a Message Queue](https://vibeengines.com/systemdesign/message-queue-system-design): Build a distributed message queue like Kafka. See how an append-only commit log, partitions keyed for order, consumer groups with server-side offsets, leader/follower replication, controller-driven leader election, retention and compaction, and exactly-once guarantees fit together.
- [Design a Key-Value Store](https://vibeengines.com/systemdesign/key-value-store-system-design): Build a distributed key-value store like DynamoDB. See how consistent hashing places keys, how replication and tunable quorums (R + W > N) trade consistency for availability, how vector clocks resolve conflicts, and how gossip membership, hinted handoff and read repair keep it alive through failure.
- [Design a Distributed Cache](https://vibeengines.com/systemdesign/distributed-cache-system-design): Build a distributed cache like Redis or Memcached. See how cache-aside shields the database, how consistent hashing shards across nodes, how TTL and LRU/LFU eviction bound memory, how replication and invalidation keep it correct, and how to survive cache stampedes and hot keys.
- [Design a News Feed](https://vibeengines.com/systemdesign/news-feed-system-design): Build a social news feed. See how the social graph, pull vs push fan-out, a precomputed feed cache, relevance ranking, the hybrid model that tames the celebrity problem, blending multiple content sources, and cursor pagination fit together.
- [Design a Web Crawler](https://vibeengines.com/systemdesign/web-crawler-system-design): Build a distributed web crawler. See how a URL frontier drives the fetch–parse–enqueue loop, how a bloom-filter seen-set stops infinite re-crawling, how politeness and robots.txt keep you a good citizen, how DNS caching and content dedup remove bottlenecks, and how to shard the frontier by host and dodge traps.
- [Design Google Docs](https://vibeengines.com/systemdesign/google-docs-system-design): Build a real-time collaborative editor. See how edits become tiny operations, how OT and CRDTs resolve concurrent edits so every copy converges, how ops broadcast over WebSockets, how an op log plus snapshots give history and recovery, and how presence, offline sync and per-document sharding fit together.
- [Design a Job Scheduler](https://vibeengines.com/systemdesign/job-scheduler-system-design): Build a distributed job scheduler (cron at scale). See how a durable job store indexed by run time, a due scanner, a ready queue feeding a worker pool, idempotent at-least-once execution, leader election to avoid double-fires, retries with backoff and a DLQ, and time-wheel sharding fit together.
- [Design Netflix](https://vibeengines.com/systemdesign/netflix-system-design): Build a planet-scale video streaming service. See how the play path splits authorization from byte delivery, how origin storage and CDN edges serve immutable segments, how an adaptive-bitrate ladder adapts to any connection, how a parallel transcoding pipeline builds it, and how Open Connect, recommendations and QoE events fit together.
- [Design Instagram](https://vibeengines.com/systemdesign/instagram-system-design): Build a photo-sharing app. See how splitting media from metadata, a CDN for immutable images, async image processing, a precomputed feed cache, asynchronous like/view counters, TTL-based ephemeral stories, and sharding fit together to serve billions of photos.
- [Design Pastebin](https://vibeengines.com/systemdesign/pastebin-system-design): Build a text-paste service. See how base62 key generation, separating metadata from blob storage, a cache and CDN for the read-heavy immutable path, TTL expiration, privacy flags and size limits, and async analytics fit together.
- [Design an ID Generator](https://vibeengines.com/systemdesign/distributed-id-generator-system-design): Build a distributed unique ID generator like Twitter Snowflake. See why auto-increment and UUIDs fall short, how a 64-bit ID packs a timestamp, machine id and sequence to stay collision-free and time-sortable without per-ID coordination, how machine ids are assigned, and how clock skew is handled.
- [Design a Search Engine](https://vibeengines.com/systemdesign/search-engine-system-design): Build a web search engine. See how an inverted index turns search into list lookups, how query parsing mirrors indexing, how an offline indexer builds postings, how BM25 and PageRank rank results, and how document-sharded scatter-gather, result caching and a fresh index scale it to billions of pages.
- [Design an Ad Click Aggregator](https://vibeengines.com/systemdesign/ad-click-aggregator-system-design): Build a real-time ad click aggregator. See how a thin ingest API and event stream absorb millions of clicks a second, how a stream processor aggregates into time windows, how dedup keys give exactly-once counts, how a raw event lake and batch recompute reconcile the numbers, and how fraud filtering and watermarks handle the sharp edges.
- [Design Airbnb](https://vibeengines.com/systemdesign/airbnb-system-design): Build a lodging marketplace. See how listings and geo search with filters, per-listing availability calendars, atomic booking that never double-books, payment hold-and-capture with idempotency, event-driven reviews and reindexing, and read replicas fit together.
- [Design Slack](https://vibeengines.com/systemdesign/slack-system-design): Build a team chat app. See how channel messaging and per-channel history, real-time delivery over WebSockets with a session registry, cross-server fan-out via pub/sub, ephemeral presence and typing, message search, unread counts and notifications, and channel sharding fit together.
- [Design Google Maps](https://vibeengines.com/systemdesign/google-maps-system-design): Build a mapping and navigation service. See how pre-rendered map tiles on a CDN, a weighted road graph, A* shortest-path routing, contraction hierarchies for instant long routes, crowdsourced traffic for live ETAs, geocoding, and regional graph partitioning fit together.
- [Design a Stock Exchange](https://vibeengines.com/systemdesign/stock-exchange-system-design): Build a stock exchange matching engine. See how an in-memory order book with price-time priority matches orders, how pre-trade risk checks guard the core, how a single sequencer and single-threaded engine give deterministic low-latency matching, and how market-data feeds, journaling/replay, clearing and symbol partitioning fit together.
- [Design a Payment System](https://vibeengines.com/systemdesign/payment-system-design): Build a payment system like Stripe. See how a payment is modeled as a state machine of authorize and capture, how idempotency keys prevent double-charges, how a double-entry ledger keeps every cent auditable, how tokenization shrinks PCI scope, and how async webhooks, reconciliation and a durable retryable worker handle slow banks and failure.
- [Design a CDN](https://vibeengines.com/systemdesign/cdn-system-design): Build a Content Delivery Network like Cloudflare or Akamai. See why distance is the enemy, how edge PoPs cache content near users, how anycast/GeoDNS routes to the nearest edge, how Cache-Control TTLs and tiered shield caches protect the origin, how versioned URLs and purge solve invalidation, and how stale-while-revalidate keeps it fast and up.
- [Design a Load Balancer](https://vibeengines.com/systemdesign/load-balancer-system-design): Build a load balancer like NGINX or HAProxy. Learn why you scale out instead of up, how one entry point fronts a pool of stateless servers, how balancing algorithms (round-robin, least-connections, weighted, hashing) pick a server, how health checks evict dead boxes, L4 vs L7 routing, and how to make the balancer itself redundant.
- [Design an API Gateway](https://vibeengines.com/systemdesign/api-gateway-system-design): Build an API gateway like Kong or Amazon API Gateway. See how one front door decouples clients from your microservices, how it routes by path, offloads authentication and rate limiting to the edge, aggregates responses (BFF) and caches hot GETs, stays stateless and pooled, and isolates a failing service with timeouts and circuit breakers.
- [Design DNS](https://vibeengines.com/systemdesign/dns-system-design): Build the Domain Name System. See why one central name→IP table can't work, how a delegated hierarchy of root, TLD and authoritative servers splits the namespace, how a recursive resolver walks it, how caching with TTLs makes lookups instant, how replication and anycast make it DDoS-proof, and how GeoDNS, DNSSEC and propagation work.
- [Design Object Storage](https://vibeengines.com/systemdesign/object-storage-system-design): Build an object store like Amazon S3. See why one disk caps capacity, durability and availability, how a flat bucket/key namespace scales to trillions of immutable objects, how a metadata service maps keys to chunk locations, how replication and erasure coding deliver eleven-nines durability, how read-after-write consistency is anchored in metadata, and how multipart uploads, tiering and background repair work.
- [Design a Distributed File System](https://vibeengines.com/systemdesign/distributed-file-system-system-design): Build a distributed file system like GFS or HDFS. See why one file server caps capacity and throughput, how huge files split into large chunks across chunkservers, how a single master serves only metadata while clients stream bytes directly, how rack-aware replication survives correlated failures, how a leased primary orders pipelined writes, and how the master is made recoverable.
- [Design a Time-Series Database](https://vibeengines.com/systemdesign/time-series-database-system-design): Build a time-series database like InfluxDB or Prometheus TSDB. See why a row-per-point SQL table melts, how series = metric + tags models the data, how columnar storage with delta-of-delta timestamps and XOR values shrinks points to ~1–2 bytes, how an LSM write path with a WAL swallows the firehose, how sharding by series and downsampling work, and why cardinality is the real scaling limit.
- [Design a Metrics & Monitoring System](https://vibeengines.com/systemdesign/metrics-monitoring-system-design): Build a monitoring system like Prometheus or Datadog. See why SSH-and-grep can't scale, how counters, gauges and histograms instrument the golden signals, pull vs push collection, storing the sample firehose in a time-series database, splitting alerting into a rule evaluator and an alert manager that dedupes and routes, dashboards, HA collectors and federation, and why you must monitor the monitor.
- [Design a Distributed Tracing System](https://vibeengines.com/systemdesign/distributed-tracing-system-design): Build a distributed tracing system like Jaeger or Honeycomb. See why metrics and logs can't explain one slow cross-service request, how spans sharing a trace id form a waterfall, how trace context propagates in headers across every hop, how spans are emitted fire-and-forget through agents to a collector, why tail-based sampling keeps the errors and slow traces, and how the trace store serves both assembly and search.
- [Design a Log Search System](https://vibeengines.com/systemdesign/log-search-system-design): Build a log aggregation and search system like the ELK stack or Loki. See why grep-over-SSH can't scale, how structured logs and shipper agents get data off ephemeral hosts, how a Kafka buffer absorbs bursts, how a parse/enrich pipeline feeds an inverted index, how time-based sharding and scatter-gather search billions of lines in milliseconds, and how hot-warm-cold retention bounds cost.
- [Design a Feature Flag System](https://vibeengines.com/systemdesign/feature-flags-system-design): Build a feature flag / experimentation platform like LaunchDarkly. See why redeploying to toggle a feature is slow and risky, how a flag store + dashboard lift decisions out of code, how an SDK evaluates flags locally with zero network calls, how consistent-hash bucketing gives sticky percentage rollouts, how local cache + streaming + edge deliver a millisecond kill switch, and how exposure events turn a flag into an A/B experiment.
- [Design a Leaderboard](https://vibeengines.com/systemdesign/leaderboard-system-design): Build a real-time leaderboard for millions of players. See why SQL ORDER BY + COUNT rank melts at scale, how a sorted set (Redis ZSET) gives O(log N) update/rank and O(log N + K) top-K, how relative "around me" boards work, why sharding a global ranking is uniquely hard, how time-windowed boards reset cleanly, and how a durable store backs the rebuildable in-memory index.
- [Design a Distributed Counter](https://vibeengines.com/systemdesign/distributed-counter-system-design): Build a distributed counter for view counts and likes at massive scale. See why a single UPDATE row melts under write contention, how sharding into N sub-counters trades read cost for parallel writes, how batching through a stream cuts write volume, how a cached total makes reads O(1), how HyperLogLog counts uniques in a few KB, and how idempotency keys make increments exactly-once.
- [Design a Digital Wallet](https://vibeengines.com/systemdesign/digital-wallet-system-design): Build a digital wallet like PayPal or Venmo. See why a mutable balance column is dangerous, how an append-only double-entry ledger makes balance derived and money conserved, how atomic debit+credit transfers survive a mid-transfer crash, how idempotency keys stop double-charges, how per-account locking prevents double-spend, how cross-shard transfers use sagas, and how pending/settled states and reconciliation handle slow bank rails.
- [Design a Fraud Detection System](https://vibeengines.com/systemdesign/fraud-detection-system-design): Build a real-time fraud detection system like Stripe Radar. See why static rules fail against an adaptive adversary, how real-time features (velocity, device, geo) from a feature store carry the signal, how an ML model blends with rules under an ~80ms budget, how streaming aggregations keep features fresh, how the chargeback/label feedback loop retrains the model, and how allow/deny/step-up decisioning and graph features handle nuance and fraud rings.
- [Design a Video Conferencing System](https://vibeengines.com/systemdesign/video-conferencing-system-design): Build a video conferencing system like Zoom or Google Meet. See why real-time media needs UDP/WebRTC not TCP, why a peer-to-peer mesh explodes at N², how an SFU lets each peer upload once and forwards streams, how simulcast adapts quality per receiver, how signaling with SDP and ICE/STUN/TURN connects peers across NATs, and how geo-distributed cascaded SFUs scale to huge global calls.
- [Design a Live Streaming System](https://vibeengines.com/systemdesign/live-streaming-system-design): Build a live video streaming system like Twitch or YouTube Live. See why it optimizes for cheap CDN fan-out instead of ultra-low latency, how ingest accepts one broadcaster push, how transcoding builds an adaptive bitrate ladder, how HLS/DASH segmenting turns live video into cacheable HTTP files, how a CDN fans them to millions, the latency-vs-scale dial, and how live chat and DVR/VOD fit in.
- [Design a Food Delivery System](https://vibeengines.com/systemdesign/food-delivery-system-design): Build a food delivery system like DoorDash or Uber Eats. See why it's a three-sided marketplace plus a real-time logistics engine, how the order lifecycle is a durable state machine, how the dispatch engine optimizes courier assignment (who and when, not nearest-now), how location tracking and geo-indexing work, how ETA is an ML sum of prep + travel + wait, and how geo-sharding and surge balance supply and demand.
- [Design a Proximity Service](https://vibeengines.com/systemdesign/proximity-service-system-design): Build a proximity / nearby-search service like Yelp or "find drivers near me". See why SQL distance queries degrade to full scans, the 2D indexing problem, how geohash encodes 2D into a locality-preserving 1D key, how quadtrees and S2 cells adapt to density, the cell-boundary problem, caching hot cells, and how moving objects and geo-sharding are handled.
- [Design a Distributed Lock](https://vibeengines.com/systemdesign/distributed-lock-system-design): Build a distributed lock (mutual exclusion across machines) like Redis locks, Redlock or etcd/ZooKeeper locks. See why a "locked=true" flag deadlocks and races, how atomic acquire grants to exactly one, how a TTL lease auto-releases a dead holder, how ownership tokens make release safe, why fencing tokens are the real safety mechanism against pauses, and why correctness-critical locks need a consensus quorum.
- [Design a Service Discovery System](https://vibeengines.com/systemdesign/service-discovery-system-design): Build a service discovery system like Consul, etcd, Eureka or Kubernetes DNS. See why hardcoded IPs break in a dynamic fleet, how a service registry maps names to live instances, how self-registration and health checks keep it accurate, the client-side vs server-side discovery tradeoff, why the registry needs consensus (CP) or accepts AP staleness, and how caching and watches keep lookups fast and fresh.
- [Design a Flash Sale System](https://vibeengines.com/systemdesign/flash-sale-system-design): Build a flash-sale / limited-inventory system for a massive concurrent drop. See why read-then-decrement oversells, how admission control and a virtual waiting room pace the thundering herd, how an atomic inventory decrement guarantees exactly N buyers win, how reserve-then-confirm with a hold TTL and async order processing work, and how to tame the single hot inventory key with fairness and anti-bot defenses.
- [Design a Collaborative Editor](https://vibeengines.com/systemdesign/collaborative-editor-system-design): Build a real-time collaborative document editor like Google Docs, Notion or Figma. See why a whole-document lock kills concurrency, how naive position-based edits corrupt a document, how Operational Transformation's central sequencer works and where it bottlenecks, how CRDTs remove that bottleneck with causal, order-independent merges, why presence/cursors live outside the document's durable history, and how offline-first editing and tombstone garbage collection round out the design.
- [Design a Calendar System](https://vibeengines.com/systemdesign/calendar-system-design): Build a shared calendar like Google Calendar or Outlook. See why storing every recurring occurrence explodes storage, how RRULE-based recurrence is expanded at read time with exceptions layered on top, how free/busy conflict detection stays fast via interval overlap, the timezone/DST trap that can silently shift a recurring meeting by an hour, how invite/RSVP fan-out avoids blocking the organizer, how reminders scale via a time-bucketed trigger index, and how devices sync incrementally.
- [Design a Hotel Booking System](https://vibeengines.com/systemdesign/hotel-booking-system-design): Build a hotel/room booking platform like Booking.com or Marriott. See why read-then-decrement inventory oversells rooms, how a multi-night stay needs an all-or-nothing atomic transaction across every date, how reserve-then-confirm with a hold TTL prevents both overselling and cart-abandonment loss, why dynamic pricing is cached rather than computed live, how search is split from the strongly-consistent booking path (CQRS), and how controlled overbooking is a business policy the same atomic system enforces.
- [Design a Dating App](https://vibeengines.com/systemdesign/dating-app-system-design): Build a swipe-based dating app like Tinder or Hinge. See why a live full-table nearby scan doesn't scale, how a geospatial index plus a swiped-exclusion set fixes candidate generation, the mutual-match race condition and how a database uniqueness constraint guarantees exactly one match, how ranked feeds are precomputed rather than live, why blocking is deliberately the strictest-consistency path in the whole system, and how bot/fake-profile detection runs quietly, asynchronously, off the hot path.
- [Design a Ride-Matching Engine](https://vibeengines.com/systemdesign/ride-matching-system-design): Build the matching and dispatch engine at the heart of a ride-hailing platform — the specific subsystem deciding which driver gets which rider, not the trip lifecycle or payments. See why straight-line distance is a bad proxy for real ETA, why greedy one-at-a-time matching is globally suboptimal, how batch matching solves an assignment-optimization problem across a short window, surge pricing as supply/demand balancing, ingesting driver locations at write-heavy scale, and fairness for idle drivers.
- [Design a Logging Pipeline](https://vibeengines.com/systemdesign/logging-pipeline-system-design): Build the ingestion pipeline that collects, buffers and delivers logs from thousands of services — the write path, not the query/search side. See why synchronous writes to a central log server are dangerous, local agent buffering, bounded backpressure and overflow policy, batching for throughput, where structured parsing should happen, at-least-once delivery with dedup, sampling at high volume, and why a logging storm can take down the very system it was meant to observe.
- [Design an Email System](https://vibeengines.com/systemdesign/email-system-design): Build an email system like Gmail or Outlook. See why raw inbound mail can't land straight in a mailbox, retry-with-backoff for unreliable delivery across the open internet, layered spam/authentication filtering, per-user mailbox sharding, thread reconstruction via message headers instead of subject lines, delivery dedup and bounce-loop prevention, and IMAP-style incremental multi-device sync.
- [Design an Online Judge](https://vibeengines.com/systemdesign/online-judge-system-design): Build a code-execution judge like LeetCode, Codeforces or HackerRank's backend. See why running submitted code inline is a security catastrophe, what real sandboxing has to guarantee beyond just a container, async queue-based execution for contest-scale bursts, verdict determination across hidden test cases, CPU-time (not wall-clock) resource limits for fairness, judge determinism, and fair queueing so one flood of submissions can't starve everyone else.
- [Design Webhook Ingestion at Scale](https://vibeengines.com/systemdesign/webhook-ingestion-at-scale-system-design): Build a reliable webhook ingestion pipeline — the backbone of every integration. Learn signature verification and replay protection, acknowledging fast with a durable queue, idempotent processing that turns at-least-once delivery into effectively exactly-once, bounded retries with a dead-letter queue, replay after a fix, and monitoring consumer lag and DLQ depth.
- [Design a Customer Data Integration Pipeline](https://vibeengines.com/systemdesign/customer-data-integration-pipeline-system-design): Build the pipeline that ingests a customer’s messy data on almost every deployment. Learn source connectors (API, SFTP, database, change-data-capture), staging, validation and mapping to a canonical schema, quarantining bad rows instead of dropping them, incremental sync by checkpoint, idempotent upsert loads with backfill, and reconciliation that proves the data landed.
- [Design Multi-Tenant Customer Isolation](https://vibeengines.com/systemdesign/multi-tenant-customer-isolation-system-design): Serve many customers from one system without ever leaking data between them. Learn tenant context propagation, the data-isolation spectrum (row-level, schema-per-tenant, database-per-tenant), preventing noisy neighbors with per-tenant quotas, per-tenant encryption keys and config, and audit plus automated cross-tenant tests that make isolation provable.
- [Design an Audit Logging & Compliance Trail](https://vibeengines.com/systemdesign/audit-logging-and-compliance-trail-system-design): Build the audit system that passes a customer’s security review. Learn structured capture of who-did-what-when, an append-only immutable (WORM) store, tamper-evidence with hash chaining, retention and archival for compliance windows, and access-controlled querying that redacts sensitive data and audits the auditors.

## AI System Design Walkthroughs
- [Design a Conversational AI](https://vibeengines.com/ai-system-design/conversational-ai-system-design): Build a production conversational AI system (think ChatGPT). See how the request path splits an inference gateway from the model servers, how the context window is assembled and token-budgeted, how conversation memory is stored and recalled, how tokens stream back over a persistent connection, and how guardrails gate every prompt and response.
- [Design a RAG Pipeline](https://vibeengines.com/ai-system-design/rag-pipeline-system-design): Build a retrieval-augmented generation pipeline. See how documents are chunked and embedded, how a vector store answers semantic search, how two-stage retrieval with reranking finds the best passages, how the prompt is grounded to stop hallucination, and how evals keep a quietly-drifting index honest.
- [Design an AI Agent System](https://vibeengines.com/ai-system-design/ai-agent-system-design): Build an autonomous AI agent. See how the plan-act-observe loop turns a goal into action, how the model emits typed tool calls, how a sandboxed executor runs them safely, how working and long-term memory fit together, and how budgets and approval gates keep a multi-step agent from running away.
- [Design an LLM Inference Server](https://vibeengines.com/ai-system-design/llm-inference-serving-system-design): Build an LLM inference serving system. See how a request queue absorbs spiky traffic, how the prefill/decode split and continuous batching keep GPUs full, how the KV cache and paged attention make each token cheap, how tensor sharding fits a giant model, and how autoscaling rides demand — all balancing latency against throughput,.
- [Design a Recommendation System](https://vibeengines.com/ai-system-design/recommendation-system-design): Build a large-scale recommendation system. See how a two-stage retrieve-and-rank funnel picks the best few from millions, how two-tower embeddings and ANN generate candidates fast, how a heavy ranking model scores engagement, how a feature store stays consistent between training and serving, and how the feedback loop keeps recommendations fresh.
- [Design a Vector Database](https://vibeengines.com/ai-system-design/vector-database-system-design): Build a vector database. See why "k nearest of a billion vectors" needs its own index, how a distance metric ranks similarity, how IVF cells and an HNSW graph make search sub-linear, how product quantization fits billions in RAM, how metadata filtering and sharding hold up — and how ANN fails silently when you starve the search.
- [Design Semantic Search](https://vibeengines.com/ai-system-design/semantic-search-system-design): Build a semantic search engine. See why keyword search misses meaning, how a single shared embedding model puts documents and queries in one space, how the chunk→embed→index ingest path is built, how hybrid BM25 + vector fusion catches exact terms, how a cross-encoder reranks the shortlist — and how a model-version upgrade silently randomizes results.
- [Design an LLM Gateway](https://vibeengines.com/ai-system-design/llm-gateway-system-design): Build an LLM gateway and model router. See why apps should call one provider-agnostic API instead of vendor SDKs, how adapters normalize every provider, how a capability-first router picks a model, how retries and failover survive a provider outage, how per-tenant limits and budgets isolate a shared quota, how caching cuts cost and latency — and how cost-only routing silently wrecks quality.
- [Design an LLM Cache](https://vibeengines.com/ai-system-design/llm-cache-system-design): Build a prompt & response caching layer for LLMs. See why repeated and near-duplicate prompts should skip the model, how an exact-match cache keys on the normalized request, how a semantic cache reuses answers above a tuned similarity threshold, how prompt-prefix (KV) reuse cheapens even misses, how TTL and invalidation keep it fresh — and how a loose threshold silently serves wrong answers.
- [Design a Fine-Tuning Pipeline](https://vibeengines.com/ai-system-design/fine-tuning-pipeline-system-design): Build an LLM fine-tuning and training pipeline. See how datasets are curated (the real work), how a pretrained base is adapted with LoRA/PEFT, how the distributed training loop is monitored, how a held-out eval gate decides promotion, how a versioned model registry enables rollback, how canary deploys ship safely, and how the production data flywheel compounds — plus why eval-set contamination inflates metrics silently — through an interactive diagram.
- [Design a Feature Store](https://vibeengines.com/ai-system-design/feature-store-system-design): Build a feature store for ML. See how one feature definition kills training/serving skew, how a shared pipeline computes features once, how the offline store serves point-in-time-correct training data, how the online store serves millisecond lookups, how a versioned registry makes features reusable assets, how batch + streaming keep them fresh, and how drift monitoring catches silent decay.
- [Design Content Moderation](https://vibeengines.com/ai-system-design/content-moderation-system-design): Build a content-moderation pipeline (text + image). See how a staged funnel hash-matches known-bad content, how text and multimodal classifiers emit per-category scores, how OCR closes the text-in-image loophole, how a policy engine maps scores to graduated actions, how a human review queue handles the uncertain middle, how appeals and a retraining loop fight adversarial evasion — and why fully trusting the classifier fails — through an interactive diagram.
- [Design an AI Coding Assistant](https://vibeengines.com/ai-system-design/ai-coding-assistant-system-design): Build an AI coding assistant (like Copilot or Cursor). See how inline completion / tab prediction meets a sub-second latency budget, how context is assembled with fill-in-the-middle, how repo-aware retrieval grounds completions in the codebase, how a code-specialized model streams suggestions, how debounce/cancel/cache win the milliseconds, how acceptance-rate telemetry measures quality, how an agentic chat mode handles multi-file edits, and why starving the context yields confident wrong code — through an interactive diagram.
- [Design Multi-Agent Orchestration](https://vibeengines.com/ai-system-design/multi-agent-orchestration-system-design): Build a multi-agent orchestration / workflow engine. See how an orchestrator decomposes a goal across specialist agents, when NOT to go multi-agent, how shared state coordinates them, how a durable workflow engine checkpoints and resumes, how typed handoffs stop telephone-game degradation, how fan-out/fan-in parallelizes independent work, how budgets and termination prevent runaways, and why uncapped agents loop and burn unbounded cost — through an interactive diagram.
- [Design LLM Eval & Observability](https://vibeengines.com/ai-system-design/llm-eval-observability-system-design): Build an LLM evaluation and observability pipeline. See how offline evals and online observability form two loops, how tracing every call is the foundation, how versioned golden datasets become your real benchmark, how programmatic/LLM-judge/human scorers combine, how a CI regression gate blocks regressions, how production monitoring catches drift, how failures feed back as fixtures — and why an unvalidated LLM judge silently corrupts every metric — through an interactive diagram.
- [Design an LLM Guardrails System](https://vibeengines.com/ai-system-design/guardrails-system-design): Build an LLM guardrails / safety-filter system. See how a safety pipeline wraps every call, how input guardrails screen PII, prompt-injection and scope, why injection needs defense-in-depth, how output guardrails check toxicity, PII, schema and groundedness, how violations are handled gracefully, how cheap-first layering keeps it affordable, why both over- and under-blocking fail — and how trusting untrusted input lets injection through — through an interactive diagram.
- [Design a Text-to-Image Service](https://vibeengines.com/ai-system-design/text-to-image-system-design): Build a text-to-image generation service like Midjourney, DALL·E or hosted Stable Diffusion. See why synchronous generation fails, how the async job pattern accepts fast and works later, how a queue absorbs bursts against fixed GPU capacity, what the diffusion denoising loop actually does, how batching and autoscaling keep the GPU fleet cost-effective, how object storage + CDN deliver images, and why moderation is required on both the prompt and the image.
- [Design a Speech-to-Text Service](https://vibeengines.com/ai-system-design/speech-to-text-system-design): Build a speech-to-text / ASR service like Whisper-at-scale or Deepgram. See why batch and streaming transcription have opposite constraints, how a gateway splits the paths over one GPU fleet, how VAD and overlapping chunks feed a fixed model window, what the ASR inference pipeline does, how batching and autoscaling keep GPUs economical, and how post-processing (punctuation, timestamps, diarization) turns raw tokens into a usable transcript.
- [Design a Text-to-Speech Service](https://vibeengines.com/ai-system-design/text-to-speech-system-design): Build a text-to-speech / voice synthesis service like ElevenLabs or Play.ht. See why natural TTS is a pipeline (text normalization → acoustic model → vocoder), how batch and streaming differ, why time-to-first-audio is the metric for voice agents, how voices and cloning work, how caching common phrases skips the GPU, how GPU scaling protects the latency budget, and why cloning demands consent and watermarking.
- [Design a Realtime Voice Agent](https://vibeengines.com/ai-system-design/voice-agent-system-design): Build a realtime voice AI agent like ChatGPT voice mode or an AI phone agent. See why a sequential STT→LLM→TTS pipeline feels robotic, how streaming and pipelining the three stages cut per-turn latency, how turn-taking (endpointing + barge-in) makes it feel human, how the interruptible orchestrator manages state and clean cancellation, where the latency budget goes, and how tools and transport (WebRTC/SIP) fit in.
- [Design an AI Answer Engine](https://vibeengines.com/ai-system-design/ai-answer-engine-system-design): Build an AI answer engine like Perplexity. See why a bare LLM is stale and hallucinates with no sources, how retrieve-then-generate (RAG over the live web) grounds answers, how a query planner rewrites and decomposes questions, how search + fetch + rerank build a tight evidence set, how grounded generation cites every claim, how citation verification catches unsupported statements, and how to defend against prompt injection from web content.
- [Design an Embeddings Service](https://vibeengines.com/ai-system-design/embeddings-service-system-design): Build an embeddings service that powers semantic search, RAG and recommendations. See why embedding needs a shared service, how online (low-latency query) and batch (millions of docs) modes differ, what the model outputs, how a batched GPU pipeline indexes a corpus, the critical rule that query and corpus must share the same model version (so a model change re-embeds everything), and how caching by (text, version) saves cost.
- [Design a Reranking Service](https://vibeengines.com/ai-system-design/reranking-service-system-design): Build a reranking service — the precision tier of two-stage retrieval for search and RAG. See why vector (bi-encoder) search has great recall but rough ordering, how retrieve-wide-then-rerank-narrow works, why a cross-encoder scores query and candidate jointly for precision, how the top-K latency/cost tradeoff is tuned, how to serve it batched and cached, and why recall gates precision so both stages are essential.
- [Design a GraphRAG System](https://vibeengines.com/ai-system-design/graph-rag-system-design): Build a GraphRAG system — knowledge-graph-augmented retrieval. See why vanilla vector RAG fails on multi-hop and global questions, how a knowledge graph of entities and relationships lets retrieval traverse connections, how LLM extraction builds the graph, how community detection and hierarchical summaries enable global questions, how local vs global query modes work, and why hybrid graph+vector retrieval is the strongest form.
- [Design a Multimodal RAG System](https://vibeengines.com/ai-system-design/multimodal-rag-system-design): Build a multimodal RAG system that answers questions grounded in images, charts, tables and PDFs. See why text-only RAG loses visual information, how documents are parsed into multimodal chunks, unified multimodal embeddings vs convert-to-text, cross-modal retrieval, why generation needs a vision-language model that actually sees the retrieved images, how assets are stored and served, and the modality-gap and cost tradeoffs.
- [Design an Agent Memory System](https://vibeengines.com/ai-system-design/agent-memory-system-design): Build a long-term memory system for an LLM agent or chatbot. See why stuffing the whole history into context fails, how short-term (context window) and long-term (persistent) memory differ, how the write path extracts salient facts, how context is assembled under a token budget, how memories live in vector + structured stores, how recall is RAG over memory, and why consolidation and forgetting keep memory coherent.
- [Design a Code Execution Sandbox](https://vibeengines.com/ai-system-design/code-sandbox-system-design): Build a secure code execution sandbox for untrusted, LLM-generated (or user-submitted) code — the runtime behind code agents, online judges and notebooks. See why running code directly is a full compromise, how containers and microVMs isolate it, how resource limits stop hangs and fork bombs, the submit→isolate→capture pipeline, why sandboxes must be ephemeral, how warm pools keep it fast, and how egress control prevents exfiltration.
- [Design an LLM Router](https://vibeengines.com/ai-system-design/llm-router-system-design): Build an LLM router that sends each request to the cheapest model that can handle it. See why one-model-for-all overpays on the easy majority and fails the hard minority, how a fast difficulty classifier provides the routing signal, how tiered routing with a cheap-first cascade survives classifier errors, how semantic routing to specialists is cheaper and better, how caching and multi-provider fallback add resilience, and why the quality bar comes before cost.
- [Design a Batch Inference System](https://vibeengines.com/ai-system-design/batch-inference-system-design): Build an offline batch LLM inference system that grinds millions of prompts at maximum throughput per dollar. See why looping the online API fails, how the async job model works, how huge and continuous batching saturate the GPU, how a sharded restartable pipeline survives failures, how length bucketing and prefix caching squeeze each batch, and how checkpointing unlocks cheap spot GPUs and batch-discount pricing.
- [Design a Synthetic Data Pipeline](https://vibeengines.com/ai-system-design/synthetic-data-system-design): Build a synthetic data pipeline that uses LLMs to generate training and eval data. See why naive "generate 10,000 examples" gives low-diversity, error-prone data, how a strong teacher model generates candidates, how diversity steering avoids mode collapse, how quality filtering and verification (execute code, ground facts) keep only good examples, how the data powers distillation/augmentation/evals, and how to avoid model collapse and contamination.
- [Design an RLHF Pipeline](https://vibeengines.com/ai-system-design/rlhf-pipeline-system-design): Build an RLHF alignment pipeline. See why a pretrained base model is capable but unaligned, how supervised fine-tuning teaches instruction-following, why preference comparisons beat demonstrations, how a reward model turns human comparisons into a dense score, how PPO optimizes the policy with a KL constraint to prevent reward hacking, the DPO and RLAIF alternatives, and the reward-hacking, overoptimization and labeler-quality traps.
- [Design a Document AI Pipeline](https://vibeengines.com/ai-system-design/document-ai-system-design): Build a document AI / intelligent document processing pipeline that turns PDFs, scans and forms into structured data. See why plain OCR gives characters but loses structure, how preprocessing and OCR produce located text, how layout analysis recovers 2D structure (tables, key-value pairs), how templates vs ML vs VLM extraction produce schema JSON, how validation and confidence catch misreads and hallucinated fields, and how human-in-the-loop review keeps it accurate.
- [Design ChatGPT](https://vibeengines.com/ai-system-design/chatgpt-system-design): Design ChatGPT itself — a chat product serving hundreds of millions of weekly users and billions of prompts a day. See why the serving path must be stateless, how conversations shard by id, how the context is rebuilt every turn under a token budget, how a model router becomes the #1 cost lever, how prefix caching kills redundant prefill, how continuous batching squeezes the GPU fleet, and the load-shedding playbook for a capacity crunch.
- [Design a Computer-Use Agent](https://vibeengines.com/ai-system-design/computer-use-agent-system-design): Build a computer-use / browser agent — the agent whose only API is the screen. See how the see-think-act loop works one verified action at a time, why perception mixes screenshots with accessibility trees, how set-of-marks grounding turns "click Submit" into coordinates, why execution lives in a disposable sandboxed VM, how every action is verified against the next frame, where approval gates catch irreversible clicks, and how task memory survives 60-step workflows — through an interactive diagram where you can change the page mid-task.
- [Design a Deep Research Agent](https://vibeengines.com/ai-system-design/deep-research-agent-system-design): Build a deep research agent — the system behind every "deep research" product. See how a lead agent decomposes the question into a coverage plan, why parallel sub-researchers get isolated contexts, how the search-read-note loop compounds understanding, why evidence lives as claims-paired-with-sources, how gap-driven iteration ends under a hard budget, and how citation verification keeps the final report honest — through an interactive diagram where you can poison a source.
- [Design an AI Meeting Notetaker](https://vibeengines.com/ai-system-design/ai-meeting-notetaker-system-design): Build an AI meeting notetaker. See how a capture bot joins calls with per-speaker audio, why consent is architecture rather than a checkbox, how streaming ASR and diarization turn chaos into an attributed transcript, why extracted decisions and action items must cite timestamped segments, how meeting memory answers questions across months of calls, and how artifacts land in the tools where work happens — through an interactive diagram where you can unleash crosstalk.
- [Design a Text-to-Video System](https://vibeengines.com/ai-system-design/text-to-video-system-design): Build a Sora-style text-to-video service. See why minutes-long renders force an async job spine, how safety gates both prompts and pixels, why an LLM expands prompts toward the training distribution, how a GPU scheduler runs queue economics with tiers and preemption, how diffusion transformers denoise spacetime latents jointly for coherent motion, why C2PA provenance and watermarking ship on every render, and how draft-then-final rendering makes iteration affordable — through an interactive diagram with a viral-surge chaos mode.
- [Design an Adaptive AI Tutor](https://vibeengines.com/ai-system-design/ai-tutor-system-design): Build an adaptive tutoring system like Khanmigo or Duolingo's AI tutor. See why a fixed question order fails every learner, how a per-skill mastery model picks the next problem, why grading routes structured answers to a deterministic checker and reserves the LLM for open-ended judgment, how the mastery feedback loop closes, why explanations are grounded in a curriculum knowledge base instead of freely generated, how a Socratic hint ladder avoids just giving away the answer, and how a long-term learner profile drives spaced repetition.
- [Design an AI Code Review Bot](https://vibeengines.com/ai-system-design/code-review-bot-system-design): Build an automated PR review bot like CodeRabbit or Graphite. See why cheap deterministic linters run before any LLM call, how review is scoped to the diff plus just enough context, how a repo embedding index (RAG over the codebase) supplies cross-file context the diff alone can't show, why every finding is confidence-gated before posting, how a comment ledger prevents re-pushes from spamming old feedback, how secrets are redacted before they ever reach the LLM, and how developer reactions tune down false positives over time.
- [Design an Agent Control Plane](https://vibeengines.com/ai-system-design/agent-control-plane-system-design): Build the platform layer that runs a whole fleet of production AI agents — not how one agent coordinates a task, but how an organization deploys, versions, budgets, permissions, monitors, and can instantly kill any of potentially hundreds of independently-running agents. See why ad-hoc agent scripts are an operational blind spot, a central agent registry with versioning, server-enforced per-agent tool permissions, hard cost budgets checked per step, an out-of-band kill switch, full execution tracing, and canary rollout of new agent versions.
- [Design a Model Registry (MLOps)](https://vibeengines.com/ai-system-design/model-registry-mlops-system-design): Build the platform that versions, evaluates, promotes and can instantly roll back trained ML models — the governance layer between "a model finished training" and "a model is safely serving production traffic." See why an artifact alone is meaningless without lineage, staged promotion through gated environments, automated evaluation gates that fail closed, shadow/canary deployment because offline metrics aren't sufficient, instant rollback via immutable versioning, and production drift monitoring.
- [Design a GPU Cluster Scheduler](https://vibeengines.com/ai-system-design/gpu-cluster-scheduler-system-design): Build a scheduler for a shared pool of expensive GPUs across many teams. See why naive FIFO scheduling starves large distributed jobs and fragments capacity, gang scheduling for all-or-nothing distributed training, topology-aware placement, priority and preemption for latency-sensitive inference versus long-running batch training, fair-share quotas across competing teams, checkpoint-and-resume, and reconciling the scheduler's bookkeeping against real cluster state.
- [Design a Data Labeling Platform](https://vibeengines.com/ai-system-design/data-labeling-platform-system-design): Build a human annotation platform like Scale AI or Labelbox — sourcing labels from people, not generating them programmatically. See why a single annotator's answer can't be trusted as ground truth, multi-annotator consensus, secretly-mixed gold-standard items that measure labeler accuracy in real time, skill-based task routing, active learning to prioritize which unlabeled examples matter most, and aligning labeler pay with measured quality.
- [Design a Prompt Management & A/B Testing Platform](https://vibeengines.com/ai-system-design/prompt-mgmt-ab-platform-system-design): Build the platform that versions, evaluates, and safely A/B tests prompts in a production LLM application — a much faster-moving artifact than model weights, often edited by non-engineers. See why hardcoded prompts force a full deploy for every tweak, externalizing prompts as versioned config, an offline eval gate before rollout, live A/B testing, guardrail metrics that must not regress, routine one-click rollback, and a review gate suited to non-engineer editors.
- [Design Realtime Speech Translation](https://vibeengines.com/ai-system-design/realtime-translation-system-design): Build a live speech-to-speech translator, chaining streaming ASR, MT, and TTS under a tight latency budget. See why record-then-translate feels like a walkie-talkie, streaming partial transcripts, why streaming translation must revise its own output as more context arrives, chunking policy, voice/prosody preservation, disfluency filtering, per-stage latency budgeting, and code-switching.
- [Design an AI Ad Creative Platform](https://vibeengines.com/ai-system-design/ai-ad-creative-system-design): Build a platform that generates ad creative at scale for advertisers, built on top of generative models rather than serving them directly. See why one hand-designed creative can't be tested at scale, programmatic variant generation, a brand-safety and ad-policy compliance gate that fails closed, rights and licensing tracking, dynamic multi-armed-bandit budget allocation, a performance feedback loop, and tiered generation cost control.
- [Design a Multi-Tenant AI SaaS Platform](https://vibeengines.com/ai-system-design/multi-tenant-ai-saas-system-design): Build an AI product serving many separate customer organizations from shared infrastructure. See why unscoped shared retrieval risks cross-tenant data leaks, enforcing isolation at the data layer, per-tenant customization via configuration, noisy-neighbor prevention with per-tenant quotas, per-tenant cost attribution, data-residency routing, automated onboarding, and defense-in-depth isolation that survives a bug in any single layer.
- [Design an Autonomous Email Agent](https://vibeengines.com/ai-system-design/email-agent-system-design): Build an AI agent that triages, drafts, and sends email on a user's behalf, where sending is often irreversible. See why auto-sending everything is dangerous, a human-approval gate scoped to action reversibility, priority triage, context assembly from thread history, tone/style matching, defending against indirect prompt injection hidden in received email, and a full audit trail.
- [Design a Sales CRM Agent](https://vibeengines.com/ai-system-design/sales-crm-agent-system-design): Build an AI agent embedded in a CRM that enriches leads, scores priority, drafts outreach, and suggests next actions — writing into a shared system of record and staying a suggester, not an autonomous actor, for relationship-sensitive interactions. See multi-source enrichment with provenance tracking, lead scoring, write-back validation that fails closed, next-best-action suggestion, personalization at scale, activity logging, and stale-data safeguards.
- [Design a Support Resolution Agent](https://vibeengines.com/ai-system-design/support-resolution-agent-system-design): Build an AI agent that triages, resolves, and escalates customer support tickets end-to-end. See why answering from general knowledge alone is dangerous when the real answer depends on account-specific state, grounding responses in real account/order data, confidence-based escalation instead of guessing, tiered auto/assisted/escalate resolution, seamless handoff context, outcome-based quality tracking, tone-aware de-escalation, and identity verification against social engineering.
- [Design a CI Test-Generation Agent](https://vibeengines.com/ai-system-design/ci-test-gen-agent-system-design): Build an agent that automatically generates tests for new and changed code in a CI pipeline. See why manual tests leave coverage gaps, coverage-gap analysis, generating tests against the real code, mutation testing to verify a test is actually meaningful, flaky-test detection before it poisons CI signal, why a human review gate is still required, and running expensive validation in a background lane.
- [Design a Personal Knowledge Assistant](https://vibeengines.com/ai-system-design/personal-knowledge-assistant-system-design): Build an AI assistant grounded in a user's own private documents and notes, where privacy is the central architectural constraint. See why dumping years of personal content into one context window fails, retrieval over messy heterogeneous formats, continuous incremental ingestion, disambiguating with personal context, source attribution, encryption and minimizing third-party exposure, genuine deletion, and recency-aware retrieval for facts that change over time.
- [Design an Edge Inference Fleet](https://vibeengines.com/ai-system-design/edge-inference-fleet-system-design): Build the platform that deploys and manages ML inference across a large fleet of edge devices — phones, IoT sensors, kiosks, cars. See why cloud-only inference fails at fleet scale, model compression for severe resource budgets, offline-capable on-device inference, staged rollout that's harder than server rollback, bandwidth-conscious delta updates, telemetry from devices you don't control, graceful degradation, and devices that self-heal their model version on reconnect.
- [Design an AI Video Dubbing System](https://vibeengines.com/ai-system-design/ai-video-dubbing-system-design): Build a system that translates and re-synthesizes speech in existing video, synchronized to lip movements — an offline batch problem with its own timing and ethical constraints. See why naive translate-and-overlay drifts out of sync, timing-constrained translation, higher-quality offline voice cloning, the audio-vs-video lip-sync trade-off, cross-segment consistency, consent for voice likeness, review gates scaled by content stakes, and background audio preservation.
- [Deploy an LLM in a Customer’s Environment](https://vibeengines.com/ai-system-design/on-prem-llm-deployment-system-design): Deploy a large language model inside a customer’s own environment — the constraint a forward deployed engineer meets when a regulated customer won’t send data to a public API. See why a hosted endpoint is a non-starter, right-sizing the model and precision to the fixed hardware they actually own, serving efficiently on limited GPUs, running with no network egress (air-gapped, no phone-home), shipping model and security updates as signed bundles into a locked-down environment, and getting observability out without exfiltrating customer data.
- [Design Secure Document Ingestion + RAG](https://vibeengines.com/ai-system-design/secure-document-ingestion-and-rag-system-design): Build a retrieval-augmented assistant over a customer’s sensitive internal documents, where security — not relevance — is the hard constraint. See why naive RAG leaks documents across users, classifying and tagging access on ingest, permission-aware retrieval that intersects relevance with what the user may see, redacting PII and secrets before the prompt and logs, defending against prompt injection carried inside untrusted documents, and citing sources plus auditing every access so the pipeline can pass a security review.
- [Design an Agent Payment Gateway](https://vibeengines.com/ai-system-design/agent-payment-gateway-system-design): Build the platform that lets autonomous agents pay for things mid-task without draining an account — the agent rails, not the human card rails. See why a direct payment credential gives an agent unbounded, unscoped spending power, routing every payment through one mediated gateway, verifying a signed spending mandate (signature, scope, expiry) instead of trusting the agent's claim, enforcing per-transaction and cumulative spend caps BEFORE any settlement, machine-native x402 (HTTP 402) settlement with no human checkout, an immutable audit trail of every decision, and why the gateway must fail closed — so a runaway or hijacked agent is capped at the mandate, not the credit limit.
- [Design an MCP Security Gateway](https://vibeengines.com/ai-system-design/mcp-security-gateway-system-design): Build the security layer between an AI host and the MCP servers it connects to — the MCP-protocol-specific threat surface, not a generic LLM guardrail. See why a direct connection implicitly trusts untrusted third-party servers, routing all MCP traffic through a mediating gateway, an explicit server/tool allowlist (deny by default), scanning tool descriptions for injection (attacker-controlled text the model reads as instructions — a channel unique to MCP), issuing narrowly-scoped short-lived tokens per server so a compromised one is bounded to its slice, egress control against exfiltration through tool results, an immutable audit trail, and why the gateway must fail closed.
- [Design an Agentic Browser Security Gateway](https://vibeengines.com/ai-system-design/agentic-browser-security-gateway-system-design): Build the enterprise perimeter that contains a whole fleet of agentic browsers without banning them — the fleet-level layer, not one agent's own injection defenses. See why ungoverned agentic browsers are an invisible exfiltration surface (and why a ban just creates shadow usage), routing every action through one gateway, a central org-wide policy engine, taint tracking so data from an untrusted web page can't drive a sensitive action (provenance beats detection), an action allowlist with risk classification, human-approval breakpoints for the irreversible minority, and a fleet-wide immutable audit trail.
- [Design a Hybrid Edge-Cloud Agent](https://vibeengines.com/ai-system-design/hybrid-edge-cloud-agent-system-design): Build an on-device agent that runs on the NPU by default and escalates hard queries to the cloud — but where privacy, not just confidence, decides what may leave the device. See why default-to-cloud is default-to-leak, answering on-device by default, a privacy classifier that gates escalation FIRST (must-stay-local data is answered locally even when the model is unsure), confidence-based escalation only for privacy-cleared queries (the cascade math lives in the LLM Router design), redaction to minimize what leaves, and an on-device escalation audit — capability and privacy reconciled by making the boundary a hard constraint confidence can never override.
- [Design an RL Environment Farm](https://vibeengines.com/ai-system-design/rl-environment-farm-system-design): Build the infrastructure that trains reasoning models — the environment-and-verifier side of RL with verifiable rewards, not the preference-tuning of RLHF. See why running rollouts inline in the trainer is unsafe and unscalable, sandboxed rollout workers that safely execute untrusted model-generated code, a scheduler that fans rollouts across a fleet and distributes the policy, a SOUND verifier (a gameable one makes the model learn the exploit — reward hacking), a task bank that serves the productive difficulty band (a curriculum, because learning needs reward variance), and a trajectory store that closes the loop — with reward-hacking and sandbox-escape chaos.

## Algorithms (Played, Not Watched)
- [Dijkstra: The Last Mile](https://vibeengines.com/algorithm/dijkstra-last-mile): Don't watch Dijkstra's algorithm — play it. Drive a courier through a living isometric city, lose the fastest route to your own instincts, then meet the Dispatcher who floods the streets to find the optimal path every time. Four acts: drive it, watch the frontier, predict the next lock, then break it with a negative cycle.
- [Binary Search: The Vault](https://vibeengines.com/algorithm/binary-search): Don't memorize binary search — play it. Crack a vault of sorted dials, burn through guesses by instinct, then meet the Halver who throws away half the search space with every single look and finds any value in O(log n). Three acts — crack it, watch the window collapse, predict the midpoint.
- [Quicksort: The Pivot Pit](https://vibeengines.com/algorithm/quicksort): See quicksort actually work — then drive it. Watch the pivot partition an array in place, smaller-left and larger-right; pick your own pivot and feel how its position sets the balance; then feed it an already-sorted list and watch a fixed pivot melt down to O(n²) — and fix it with one random line. Three acts — watch the pivot, pick the pivot, break the worst case.
- [Merge Sort: The Cascade](https://vibeengines.com/algorithm/merge-sort): Don't read about merge sort — play it. Watch single-element runs cascade upward into one sorted array, merge two sorted halves by hand by always taking the smaller front, then prove the payoff: O(n log n) on sorted, reversed and shuffled input alike — the guarantee quicksort can't make. Three acts — watch the cascade, merge two runs, prove the guarantee.
- [BFS: The Flood](https://vibeengines.com/algorithm/bfs-flood): Don't memorize breadth-first search — play it. Find your own way through a maze, then release the flood that spreads from the start in rings and touches the exit by the shortest path every time, then watch depth-first search dive deep and miss it. Three acts — navigate it, release the flood, BFS vs DFS.
- [A* Search: The Ascent](https://vibeengines.com/algorithm/a-star-pathfinding): Don't memorize A* — fly it. Orbit a real 3D mountain, climb it by instinct, then meet the Pathfinder who folds one optimistic guess into Dijkstra's flood so the whole search leans straight at the summit. Four acts in live 3D — climb it, watch the heuristic beat the blind flood, predict the lowest-f pop, then break optimality with a heuristic that lies.
- [Sieve of Eratosthenes: Prime Time](https://vibeengines.com/algorithm/sieve-of-eratosthenes): Find every prime under 100 without dividing once. Hit play and watch the multiples fall away in cheerful waves while the primes light up gold — whatever's left standing is prime. A playable take on the 2,000-year-old sieve, with the theory, a worked example and a quiz.
- [Build Order: DFS & Topological Sort](https://vibeengines.com/algorithm/dfs-topological-sort): Don't memorize topological sort — play it. Schedule eight interdependent build tasks by hand and feel the constraints bite, then let a depth-first search dive to the bottom of every dependency and surface a valid build order by reversing its finish times. Three acts — schedule it yourself, watch DFS reverse-post-order it, then add one bad edge and watch it detect the cycle and refuse.
- [Six Degrees: Union-Find](https://vibeengines.com/algorithm/union-find): Don't memorize the Disjoint Set Union — play it. Wire up nine strangers one handshake at a time and watch separate friend circles merge into one, hit a redundant connection and see it refuse to close a cycle, then click any node to run find and watch path compression flatten the tree so the next lookup is instant. Union by rank, path compression and the near-constant O(α(n)) that powers Kruskal's MST — plus full theory, a runnable challenge and a quiz.
- [The Tournament: Heap Sort](https://vibeengines.com/algorithm/heap-sort): Don't memorize heap sort — watch the tournament play out. See an array read as a binary tree, build it into a max-heap where every parent beats its children so the champion sits at the root, then pluck that root maximum to the end again and again as the sorted region grows from the right. Sift-down, the two phases, and why it's O(n log n) in place with no extra memory — plus full theory, a runnable challenge and a quiz.
- [The Typo Fixer: Edit Distance](https://vibeengines.com/algorithm/edit-distance): Don't memorize edit distance — watch the grid fill in. See how many insert, delete, and replace edits turn kitten into sitting, as a dynamic-programming table computes each cell from its diagonal, up, and left neighbors, then traces the cheapest path of edits back through the grid. The Levenshtein recurrence, match-is-free, and O(m·n) — plus full theory, a runnable challenge and a quiz.
- [The Cheapest Grid: Kruskal's MST](https://vibeengines.com/algorithm/kruskal-mst): Don't memorize Kruskal's algorithm — watch it wire up a network. Connect eight towns for the least total cable by always laying the cheapest edge that doesn't close a loop, with Union-Find rejecting cycles on the fly and the minimum spanning tree turning green edge by edge. Greedy choice, the cut property, and O(E log E) — plus full theory, a runnable challenge and a quiz.
- [The Patient Router: Bellman-Ford](https://vibeengines.com/algorithm/bellman-ford): Don't memorize Bellman-Ford — watch the distances settle. Find shortest paths from one source even with negative edge weights by relaxing every edge round after round until nothing improves, then one extra pass to catch a negative cycle. See why Dijkstra's greedy commit breaks on negatives while Bellman-Ford's patience doesn't — O(V·E), plus full theory, a runnable challenge and a quiz.
- [The Non-Backtracker: KMP](https://vibeengines.com/algorithm/kmp): Don't memorize KMP — watch the pattern slide. Find a pattern in a text in linear time by never re-reading a character: build the pattern's LPS failure table from its own repeats, then on a mismatch jump the pattern forward instead of restarting the text pointer. See the false start, the jump, and the match — plus the O(n+m) theory, a runnable challenge and a quiz.
- [The Word Tree: Trie](https://vibeengines.com/algorithm/trie): Don't memorize the trie — watch words grow into a tree. Insert CAT, CAR, CARD, and DOG letter by letter and see shared prefixes share a path, with a flag marking where each real word ends. Then search a word and a prefix by walking down from the root. The O(length) prefix tree behind autocomplete — plus full theory, a runnable challenge and a quiz.
- [The Moving Frame: Sliding Window](https://vibeengines.com/algorithm/sliding-window): Don't memorize the sliding window — watch it glide. Find the best sum of k consecutive numbers in one O(n) pass: as the frame slides, subtract the number leaving and add the number entering instead of re-summing. See the entering and leaving cells light up and the best window lock in — plus the fixed-vs-variable window theory, a runnable challenge and a quiz.
- [The Standoff: N-Queens](https://vibeengines.com/algorithm/n-queens): Don't memorize backtracking — watch it try, clash, and undo. Place queens on a board so none attack each other, one column at a time: try a safe row, recurse, and when a column has no safe square, back up and move the previous queen. See placements go down, conflicts flash red, and the search backtrack its way to a solution — plus the pruning theory, a runnable challenge and a quiz.
- [The Instant Lookup: Hash Table](https://vibeengines.com/algorithm/hash-table): Don't memorize the hash table — watch it drop keys into buckets. See a hash function scatter names across an array in O(1), then feed it a collision and watch two keys chain in the same bucket — the reason lookups are usually instant but degrade when the table fills. Hashing, collisions, chaining and the load factor — plus full theory, a runnable challenge and a quiz.
- [The Chain of Nodes: Linked List](https://vibeengines.com/algorithm/linked-list): Don't memorize the linked list — watch the pointers move. Insert at the head in O(1), delete a node by re-pointing around it, and reverse the whole list by flipping every arrow. Nodes, next-pointers and the O(n) walk — plus full theory, a worked trace and a quiz.
- [LIFO & FIFO: Stack & Queue](https://vibeengines.com/algorithm/stack-queue): Don't memorize stacks and queues — watch them fill and drain side by side. A stack pushes and pops at the top (last in, first out); a queue adds at the back and removes at the front (first in, first out). The two O(1) containers behind undo, recursion, BFS and scheduling — plus full theory, a worked trace and a quiz.
- [The Ordered Tree: Binary Search Tree](https://vibeengines.com/algorithm/binary-search-tree): Don't memorize the BST — watch it grow. Insert values (smaller left, larger right) so the tree stays sorted, search one path down in O(log n), then feed it sorted input and watch it collapse into a lopsided list — the reason self-balancing trees exist. Plus full theory, a worked trace and a quiz.
- [The Segment Tree](https://vibeengines.com/algorithm/segment-tree): Don't memorize the segment tree — watch it answer ranges in log time. Each node stores an interval's sum, so a range-sum query combines a handful of covering nodes in O(log n), and a point update fixes one leaf and ripples to the root — also O(log n). The mutable cousin of the prefix sum — plus full theory, a worked trace and a quiz.
- [The Closing Gap: Two Pointers](https://vibeengines.com/algorithm/two-pointers): Don't memorize the two-pointer trick — watch the gap close. On a sorted array, a left and right pointer converge to find a target pair: too big, pull right in; too small, push left out. It turns an O(n²) double loop into one O(n) pass — plus full theory, a worked trace and a quiz.
- [The Running Total: Prefix Sums](https://vibeengines.com/algorithm/prefix-sums): Don't memorize prefix sums — watch the running total build. Precompute cumulative sums once in O(n), then answer any range-sum query in O(1) with a single subtraction: sum(i..j) = P[j] − P[i−1]. The trick behind range problems and 2-D image sums — plus full theory, a worked trace and a quiz.
- [The Best Streak: Kadane's Algorithm](https://vibeengines.com/algorithm/kadane): Don't memorize Kadane's algorithm — watch the best streak emerge. Find the maximum-sum contiguous subarray in one pass: keep a running sum, drop it the moment it turns negative, and remember the best. The elegant O(n) DP one-liner — plus full theory, a worked trace and a quiz.
- [The Loaded Bag: 0/1 Knapsack](https://vibeengines.com/algorithm/knapsack): Don't memorize the knapsack DP — watch the table fill. Maximize value under a weight limit: each cell asks take it or leave it, dp[i][w] = max(leave, value + dp[i-1][w-weight]). Fill the grid, then trace back which items were picked. The canonical DP table — plus full theory, a worked trace and a quiz.
- [The Rolling Hash: Rabin-Karp](https://vibeengines.com/algorithm/rabin-karp): Don't memorize Rabin-Karp — watch the hash roll. Find a pattern in text by hashing each window and comparing numbers, rolling the hash forward in O(1): drop the leaving char, add the entering one. On a hash match, verify the characters. The fingerprinting idea behind plagiarism and dedup — plus full theory, a worked trace and a quiz.
- [No Comparisons: Counting & Radix Sort](https://vibeengines.com/algorithm/counting-sort): Don't memorize counting sort — watch it sort without a single comparison. Tally how many times each value appears, then emit the values in order straight from the counts — O(n + k), the non-comparison sort that beats the O(n log n) barrier for bounded keys (and the stable pass inside radix sort). Plus full theory, a worked trace and a quiz.
- [The Fewest Coins: Coin Change](https://vibeengines.com/algorithm/coin-change): Don't memorize coin change — watch the table fill. Find the fewest coins that make an amount by building the best answer for every amount up from 0: dp[a] = 1 + min over coins of dp[a-coin]. See why grabbing the biggest coin (greedy) fails and DP gets it right — plus full theory, a worked trace and a quiz.
- [The Longest Climb: Longest Increasing Subsequence](https://vibeengines.com/algorithm/longest-increasing-subsequence): Don't memorize the LIS — watch it build. For each element, the longest increasing run ending there is one plus the best run ending on an earlier, smaller element: dp[i] = 1 + max(dp[j] for j<i, A[j]<A[i]). Fill the table, then trace the longest chain. The classic O(n²) DP (with an O(n log n) patience-sort trick) — plus full theory, a worked trace and a quiz.
- [Bits Do the Walking: Fenwick Tree](https://vibeengines.com/algorithm/fenwick-tree): Don't memorize the binary indexed tree — watch the bits do the walking. A Fenwick tree stores partial sums so a prefix-sum query and a point update both run in O(log n), using one trick: the lowest set bit i & -i tells each cell which range it owns. A query walks down, an update walks up. Plus full theory, a worked trace and a quiz.
- [Every Vertex a Stepping Stone: Floyd–Warshall](https://vibeengines.com/algorithm/floyd-warshall): Don't memorize Floyd–Warshall — watch the distance matrix improve. Three nested loops let every vertex act as an intermediate, one at a time, until dist[i][j] holds the shortest path between every pair. See each relaxation: is i → k → j cheaper than what we knew? Plus full theory, a worked trace and a quiz.
- [Find the Peak by Thirds: Ternary Search](https://vibeengines.com/algorithm/ternary-search): Don't memorize ternary search — watch the window shrink. When a function has a single peak, two probes at the one-third marks reveal which outer third can't hold the maximum, so you drop it and keep two-thirds. Repeat and the window collapses onto the peak in O(log n). See why it needs a unimodal shape, not a monotonic one. Plus full theory, a worked trace and a quiz.
- [Scatter, Sort, Gather: Bucket Sort](https://vibeengines.com/algorithm/bucket-sort): Don't memorize bucket sort — watch values fall into place. Scatter n values into k ordered buckets by value, sort each small bucket with a cheap insertion sort, then read the buckets left to right. Because the buckets are ordered, concatenation is already sorted — no merge. On uniform data it runs in O(n + k). Plus full theory, a worked trace and a quiz.
- [Push, Recurse, Pop: Subsets by Backtracking](https://vibeengines.com/algorithm/subsets-backtracking): Don't memorize backtracking — watch the decision tree grow and unwind. To list every subset, treat each element as include-or-skip; every node you visit is a subset, and finishing a branch pops the last choice to try the next. That push-recurse-pop rhythm powers subsets, permutations, N-Queens and Sudoku. Plus full theory, a worked trace and a quiz.
- [Cut the Dead Branches: Combination Sum](https://vibeengines.com/algorithm/combination-sum): Don't memorize combination sum — watch the dead branches get cut. Given reusable candidates, find every combination that adds to a target. Backtracking explores the choices, but the point is pruning: the instant a pick would overshoot what remains, that whole branch is abandoned. See how a bound turns an exponential search fast. Plus full theory, a worked trace and a quiz.
- [Guess, Hit a Wall, Erase: Sudoku Solver](https://vibeengines.com/algorithm/sudoku-solver): Don't memorize the Sudoku solver — watch it guess, hit a wall and erase. Scan for the first empty cell, try each digit legal in its row, column and box, place it and recurse. When a cell has no legal digit, backtrack: undo the last placement and try the next. The same push-recurse-pop skeleton, now steered by constraints. Played on a 4×4 board, with theory and a quiz.
- [The Biggest Tile That Fits: Euclidean GCD](https://vibeengines.com/algorithm/euclidean-gcd): Don't memorize the Euclidean algorithm — see it as tiling. The greatest common divisor is the side of the largest square that fills the two numbers' rectangle with no gap. Peel the biggest square that fits, tile the leftover strip, repeat — that is exactly gcd(a, b) = gcd(b, a mod b), in O(log n). Plus full theory, a worked trace and a quiz.
- [Climb in Doubling Jumps: Modular Exponentiation](https://vibeengines.com/algorithm/modular-exponentiation): Don't memorize fast power — watch the exponent climb in doubling jumps. To compute a^b mod m you square the base to reach a, a², a⁴, a⁸ …, and multiply in only the powers the binary digits of b select. That is O(log b) multiplications instead of b, with the mod every step keeping numbers small — the engine behind RSA. Plus full theory, a worked trace and a quiz.
- [Fill the Grid, Walk It Back: Longest Common Subsequence](https://vibeengines.com/algorithm/longest-common-subsequence): Don't memorize LCS — watch the table fill, then walk it backwards. On a character match a cell extends the diagonal by one; on a mismatch it copies the better of up or left. Fill the grid and the corner holds the length; backtrack along the diagonals to recover the actual subsequence. The same table as edit distance. Plus full theory, a worked trace and a quiz.
- [Slide the Z-Box: Z-Algorithm](https://vibeengines.com/algorithm/z-algorithm): Don't memorize the Z-algorithm — watch the Z-box slide. The Z-array records how far each position re-matches the prefix. A cached [l, r] window lets you mirror earlier answers for free and compare fresh characters only when extending past its edge — the trick that makes it O(n). Great for pattern search via P # T. Plus full theory, a worked trace and a quiz.
- [Sift Up, Sift Down: Heap & Priority Queue](https://vibeengines.com/algorithm/heap-priority-queue): Don't memorize the heap — watch values sift up and down. A binary heap is a complete tree where every parent beats its children, so the max is always the root, stored in a plain array (node i has children 2i+1, 2i+2). Push appends and sifts up; pop takes the root and sifts down, both O(log n) — the engine behind priority queues, Dijkstra and heapsort. Plus full theory, a worked trace and a quiz.
- [Grow the Cheapest Tree: Prim’s MST](https://vibeengines.com/algorithm/prim-mst): Don't memorize Prim's algorithm — watch the tree grow. Prim builds a minimum spanning tree from one vertex, each step greedily adding the cheapest edge crossing from the tree to the outside via a min-heap of frontier edges. The cut property proves the greedy grab is always safe. Plus full theory, a worked trace and a quiz.
- [The Tree That Rebalances Itself: AVL Tree](https://vibeengines.com/algorithm/avl-tree): Don't memorize AVL rotations — watch the tree rebalance itself. An AVL tree is a binary search tree that tracks each node's balance factor and rotates the instant one tips to ±2: a single rotation for straight-line LL/RR leans, a double for LR/RL zigzags. That keeps height O(log n) forever, so search never decays. Plus full theory, a worked trace and a quiz.
- [Let the Mirror Do the Work: Manacher’s Algorithm](https://vibeengines.com/algorithm/manacher): Don't memorize Manacher's algorithm — watch the mirror do the work. Find the longest palindromic substring in O(n): insert separators so every palindrome is odd, then compute a radius at each center, reusing a mirror inside the cached rightmost palindrome [C, R] and expanding only past its edge. The palindrome twin of the Z-algorithm. Plus full theory, a worked trace and a quiz.
- [Frequent Symbols, Short Codes: Huffman Coding](https://vibeengines.com/algorithm/huffman-coding): Don't memorize Huffman coding — watch the tree assemble itself. Give frequent symbols short codes and rare ones long codes, with no code a prefix of another. Huffman builds the optimal such code greedily: merge the two least-frequent nodes with a min-heap until one tree remains, then read each code off its root-to-leaf path. The entropy stage inside zip, JPEG and MP3. Plus full theory, a worked trace and a quiz.
- [Finish First, Fit the Most: Interval Scheduling](https://vibeengines.com/algorithm/interval-scheduling): Don't memorize activity selection — watch the greedy choice pay off. To fit the most non-overlapping intervals on one resource, sort by earliest finish time and take each interval that starts after the last one you took ends. Finishing soonest leaves the most room — which is why this beats sorting by shortest or earliest start, and is provably optimal. Plus full theory, a worked trace and a quiz.
- [The Waiting Line: Monotonic Stack](https://vibeengines.com/algorithm/monotonic-stack): Don't memorize the monotonic stack — watch it resolve. Find the next greater element for every item in one pass by keeping a stack that only ever decreases: when a taller bar arrives, it instantly resolves everything shorter waiting below it. The O(n) trick behind next-greater, daily temperatures, largest rectangle and more — plus full theory, the code, and a quiz.
- [The Dutch National Flag: Three-Way Partition](https://vibeengines.com/algorithm/dutch-national-flag): Don't memorize sort-colors — watch three pointers sort it. Arrange a row of 0s, 1s and 2s into three clean bands in a single in-place pass: swap 0s down to low, 2s up to high, leave 1s be. The elegant three-pointer partition — and the exact scheme that keeps quicksort fast on duplicates — plus full theory, the code and a quiz.
- [The Last One Standing: Boyer-Moore Majority Vote](https://vibeengines.com/algorithm/boyer-moore-majority): Don't memorize the majority vote — watch the votes cancel out. Find the value that appears more than half the time in one pass with just two variables: keep a candidate, add for a match, cancel for a mismatch, and whoever survives is the majority. O(n) time, O(1) space, works on streams — plus full theory, the code and a quiz.
- [Find the Kth Element: Quickselect](https://vibeengines.com/algorithm/quickselect): Don't memorize quickselect — watch it throw away half the array each step. Find the kth-smallest element (or the median) without fully sorting: partition around a pivot, see which side the target rank falls in, and recurse into only that one. Average O(n) instead of O(n log n) — plus full theory, the code and a quiz.
- [The Fair Draw: Reservoir Sampling](https://vibeengines.com/algorithm/reservoir-sampling): Don't memorize reservoir sampling — watch it stay fair. Pick one element uniformly at random from a stream of unknown length, holding just one slot: keep the i-th arrival with probability 1/i, and every element ends up equally likely. The one-pass, O(1)-space trick behind sampling logs and huge files — plus full theory, the code and a quiz.
- [Every Number Home: Cyclic Sort](https://vibeengines.com/algorithm/cyclic-sort): Don't memorize cyclic sort — watch each number walk home. When an array holds the values 1..n scrambled, sort it in O(n) with no comparisons: swap the current element to the index it belongs at until it's home, then advance. The pattern behind find-the-missing-number and find-the-duplicate — plus full theory, the code and a quiz.
- [Fibonacci Fast-Forwarded: Matrix Exponentiation](https://vibeengines.com/algorithm/matrix-exponentiation): Don't memorize matrix exponentiation — watch it fast-forward. The n-th Fibonacci number is the top of a 2×2 matrix raised to the n-th power, and repeated squaring raises a matrix to a huge power in O(log n) instead of O(n). Read the exponent in binary, square the base, fold it into the result on set bits — plus full theory, the code and a quiz.
- [Express Lanes: The Skip List](https://vibeengines.com/algorithm/skip-list): Don't memorize the skip list — ride its express lanes. A sorted linked list searches in O(n); stack a few sparse express lanes on top and search drops to O(log n) — matching a balanced tree, but built from coin flips instead of rotations. Watch a search skip across the top lane and descend to the value — plus full theory, the code and a quiz.
- [Halving the Exponential: Meet in the Middle](https://vibeengines.com/algorithm/meet-in-the-middle): Don't memorize meet-in-the-middle — watch two halves shake hands. Subset-sum over n items is 2^n by brute force; split the set in half, enumerate each half's 2^(n/2) subset sums, and match complements across the gap to hit your target. The square-root speedup that turns 2^40 into 2^20 — plus full theory, the code and a quiz.
- [Two Nodes, Climbing to Meet: LCA with Binary Lifting](https://vibeengines.com/algorithm/lca-binary-lifting): Don't memorize binary lifting — watch two tree nodes climb to meet. The lowest common ancestor is where two nodes' paths to the root first join; binary lifting stores each node's 2^k-th ancestor so you leap up the tree in powers of two, level the deeper node, then lift both together — LCA in O(log n) after O(n log n) preprocessing. Made playable, with theory and a quiz.
- [Counting a Crowd in Kilobytes: HyperLogLog](https://vibeengines.com/algorithm/hyperloglog): Don't memorize HyperLogLog — watch leading zeros count a crowd. Counting distinct items in a huge stream would need a set holding every one; HyperLogLog needs a few kilobytes. Hash each item, count the leading zeros, keep the longest run per bucket, and the harmonic mean of those runs estimates the cardinality within ~1%. The probabilistic sketch behind Redis PFCOUNT and approximate COUNT(DISTINCT) — made playable, with theory and a quiz.
- [Cycles Into Components: Tarjan’s SCC](https://vibeengines.com/algorithm/tarjan-scc): Don't memorize Tarjan's algorithm — watch cycles collapse into components. A strongly connected component is a maximal group of nodes that can all reach each other; Tarjan finds every one in a single depth-first pass using two numbers per node — a discovery time and a low-link — popping a component off a stack the moment a cycle's root is found, in O(V+E). Made playable, with theory and a quiz.
- [How Databases Stay Balanced: B-Trees](https://vibeengines.com/algorithm/b-tree): Don't memorize B-trees — watch a node overflow and split. A B-tree keeps millions of keys sorted and shallow by packing many per node and splitting a full node in half, floating its median up to the parent. That's how database indexes and filesystems find any key in a handful of disk reads. Watch keys insert, nodes fill, and the tree grow upward — with theory and a quiz.
- [One Pass, Every Word: Aho-Corasick](https://vibeengines.com/algorithm/aho-corasick): Don't memorize Aho-Corasick — watch one pass catch every pattern. Searching a text for a whole dictionary one word at a time is slow; Aho-Corasick builds a trie of the patterns, wires failure links that say where to fall back on a mismatch, and scans the text once — finding every occurrence of every pattern in O(text + matches). The multi-pattern generalization of KMP behind intrusion detection and virus scanners — made playable, with theory and a quiz.
- [Pushing Water Through Pipes: Dinic’s Max-Flow](https://vibeengines.com/algorithm/dinic-max-flow): Don't memorize Dinic's algorithm — watch flow saturate a network. Given pipes with capacities, how much can flow from source to sink? Dinic layers the graph by shortest distance with a BFS, then floods every shortest augmenting path at once with a DFS blocking flow — repeating in O(V²E). The fast max-flow / min-cut engine behind matching, scheduling, and image segmentation — made playable, with theory and a quiz.
- [Consistent Hashing: The Ring](https://vibeengines.com/algorithm/consistent-hashing): Don't memorize consistent hashing — play the ring. Place servers and keys on a hash ring where each key belongs to the next server clockwise, add a node and watch only ~1/N of the keys move instead of nearly all (as hash % N would), then flip on virtual nodes to smooth a lopsided load. The sharding primitive behind caches, databases, and load balancers — made playable, with theory and a quiz.
- [Bloom Filter: Maybe Yes, Never No](https://vibeengines.com/algorithm/bloom-filter): Don't memorize the Bloom filter — play it. Add items by lighting k bits with k hashes, then query: all bits set means 'probably present', any bit unset means 'definitely absent'. Hunt down a live false positive and see why a Bloom filter can give a false yes but never a false no — the tiny, key-less probabilistic set behind caches, databases, and crawlers. Made playable, with theory and a quiz.
- [Count–Min Sketch: Counting in Tiny Space](https://vibeengines.com/algorithm/count-min-sketch): Don't memorize the Count–Min Sketch — play it. Count how often items appear in a stream using a fixed grid of counters and d hashes: bump one cell per row on each event, and estimate a frequency by taking the minimum across rows. Watch a collision inflate an estimate, and see why it can over-count but never under-count — the structure behind heavy-hitters and streaming analytics. Made playable, with theory and a quiz.
- [Fisher–Yates: The Fair Shuffle](https://vibeengines.com/algorithm/fisher-yates): Don't memorize the Fisher–Yates shuffle — play it. Walk the array from the back, swap each element with a random one from the unshuffled front, and watch a provably uniform permutation build in O(n). Then see why the tempting naive shuffle (swap each slot with any random index) is silently biased. The one correct way to shuffle — made playable, with theory and a quiz.
- [Radix Sort: Sorting Without Comparing](https://vibeengines.com/algorithm/radix-sort): Don't memorize radix sort — play it. Sort numbers by distributing them into 10 buckets by their last digit, gather, then repeat for each higher digit — with zero comparisons. Watch a stable pass per digit sort n numbers in O(n·d), and see why the passes must run least-significant digit first. Made playable, with theory and a quiz.
- [Bidirectional BFS: Meet in the Middle](https://vibeengines.com/algorithm/bidirectional-bfs): Don't memorize bidirectional BFS — play it. Run two breadth-first searches at once, one forward from the start and one backward from the goal, and stop the instant their frontiers touch. Watch two small explored regions meet in the middle instead of one huge one, cutting explored nodes from roughly b^d toward 2·b^(d/2). Made playable, with theory and a quiz.
- [Morris Traversal: Threading the Tree](https://vibeengines.com/algorithm/morris-traversal): Don't memorize Morris traversal — play it. Walk a binary tree in sorted order using O(1) extra space by temporarily threading each node's inorder predecessor back to it, then undoing the thread on the way back — no stack, no recursion. Watch the threads appear and vanish as the tree is traversed in place and left exactly as it started. Made playable, with theory and a quiz.
- [LSM-Tree: Write Fast, Merge Later](https://vibeengines.com/algorithm/lsm-tree): Don't memorize the LSM-tree — play it. Writes land instantly in an in-memory memtable; when it fills, it flushes to an immutable sorted file (SSTable) on disk. Reads check the memtable then the SSTables newest-first, and compaction merges files while dropping shadowed old versions. The write-optimized engine behind RocksDB, Cassandra, and LevelDB — made playable, with theory and a quiz.
- [Convex Hull: Wrapping the Points](https://vibeengines.com/algorithm/convex-hull): Don't memorize the convex hull — play it. Sort points left to right, then sweep once building a lower chain and once building an upper chain, popping any point that makes a non-left turn — the cross product decides every turn. Andrew's monotone chain finds the tightest enclosing polygon in O(n log n). Made playable, with theory and a quiz.
- [External Merge Sort: Bigger Than Memory](https://vibeengines.com/algorithm/external-merge-sort): Don't memorize external merge sort — play it. When the data is too big for RAM, sort it in two phases: read chunks that fit in memory, sort each and write it back as a sorted run, then k-way merge all the runs by repeatedly emitting the smallest current head. The disk-based sort behind databases and big-data engines — made playable, with theory and a quiz.
- [Eulerian Path: Every Edge, Once](https://vibeengines.com/algorithm/euler-path): Don't memorize Hierholzer's algorithm — play it. An Eulerian path uses every edge of a graph exactly once, and exists only when 0 or 2 vertices have odd degree. Hierholzer builds it in O(E): walk unused edges until stuck, then splice in side-loops from any vertex with edges left. Watch the trail form and the degree rule decide whether it can — made playable, with theory and a quiz.
- [MinHash: Similarity in a Signature](https://vibeengines.com/algorithm/minhash): Don't memorize MinHash — play it. Estimate the Jaccard similarity of two sets by comparing k tiny hash-based signatures: for each hash, the minimum value over a set's elements matches between two sets with probability equal to their Jaccard similarity. Add hash functions and watch the estimate converge on the true overlap. The trick behind near-duplicate detection at web scale — made playable, with theory and a quiz.
- [Line Sweep: Sliding the Line](https://vibeengines.com/algorithm/line-sweep): Don't memorize the line sweep — play it. Slide an imaginary line across the input and handle a sorted list of events as it passes: +1 when an interval starts, −1 when it ends. A running counter reveals the maximum overlap (the 'meeting rooms' answer) in O(n log n). The sweep-line technique behind interval, overlap, and computational-geometry problems — made playable, with theory and a quiz.
- [Miller–Rabin: Probably Prime](https://vibeengines.com/algorithm/miller-rabin): Don't memorize Miller–Rabin — play it. Test whether a huge number is prime without factoring it: pick bases and check a chain of modular squares. A single failing base proves the number composite with certainty; passing k bases makes it prime with error at most 4⁻ᵏ. Watch a Carmichael number get caught and a pseudoprime fool the first bases before it's exposed — made playable, with theory and a quiz.
- [Karatsuba: Three, Not Four](https://vibeengines.com/algorithm/karatsuba): Don't memorize Karatsuba — play it. Split two numbers in half and the schoolbook method needs four sub-multiplications; Karatsuba computes the same product with only three, using one clever combination. Recursing that trick drops multiplication from O(n²) to about O(n^1.585). Watch the three products form and combine — made playable, with theory and a quiz.
- [Tree DP: Answers Flow Up](https://vibeengines.com/algorithm/tree-dp): Don't memorize tree DP — play it. Solve problems on a tree by computing each node's answer from its children in one post-order pass. Here: the maximum-weight independent set — pick nodes with the largest total weight, no two adjacent — by keeping two values per node (best if you take it, best if you don't). Watch the values flow up from the leaves and the optimal set light up — made playable, with theory and a quiz.
- [Bridges & Articulation Points: The Weak Links](https://vibeengines.com/algorithm/bridges-articulation): Don't memorize Tarjan's bridge-finding — play it. A bridge is an edge whose removal disconnects the graph; an articulation point is such a vertex. One DFS, tracking each node's discovery time and the earliest ancestor its subtree can reach (its low-link), finds them all in O(V+E). Watch the DFS assign disc and low values and the critical edges light up — made playable, with theory and a quiz.
- [Simulated Annealing: Cool to Improve](https://vibeengines.com/algorithm/simulated-annealing): Don't memorize simulated annealing — play it. Optimize a hard problem (a traveling-salesman tour) by proposing small random changes: always accept improvements, but sometimes accept a worse move too — with a probability that shrinks as a 'temperature' cools. Early heat escapes local minima; late cooling settles into a great solution. Watch the tour untangle as the temperature drops — made playable, with theory and a quiz.
- [Extended Euclidean & CRT: gcd, and a Bonus](https://vibeengines.com/algorithm/extended-euclid): Don't memorize the extended Euclidean algorithm — play it. It finds gcd(a,b) and, for free, the integers x and y with a·x + b·y = gcd — the Bézout coefficients that give modular inverses and power the Chinese Remainder Theorem. Watch the coefficient table build row by row and the identity a·x + b·y = gcd hold at every step — made playable, with theory and a quiz.
- [Pollard's Rho: Factor by Collision](https://vibeengines.com/algorithm/pollard-rho): Don't memorize Pollard's rho — play it. Factor a composite number without trial division by iterating a pseudo-random function mod n until two runners collide, then taking a gcd to reveal a factor. The sequence loops into a ρ shape — a tail leading into a cycle — which is where the algorithm gets its name. Watch the tortoise and hare meet and a factor pop out — made playable, with theory and a quiz.
- [Sqrt Decomposition: Blocks of Root-N](https://vibeengines.com/algorithm/sqrt-decomposition): Don't memorize sqrt decomposition — play it. Split an array into blocks of size √n and precompute each block's answer. A range query then touches only a few whole blocks plus the partial ends — O(√n) instead of O(n) — and a point update fixes one element and its block. The simplest fast-range-query structure — made playable, with theory and a quiz.
- [Lazy Segment Tree: Update Lazily](https://vibeengines.com/algorithm/segment-tree-lazy): Don't memorize lazy propagation — play it. A segment tree answers range queries in O(log n), but a range update that hits every leaf would be O(n). Lazy propagation fixes that: mark a handful of covering nodes with a pending 'lazy' tag and push it down to children only when a later query actually needs it. Watch a range-add tag O(log n) nodes instead of touching every leaf — made playable, with theory and a quiz.
- [Bitmask DP: Sets as Integers](https://vibeengines.com/algorithm/bitmask-dp): Don't memorize bitmask DP — play it. Encode a set of visited items as the bits of an integer, and dynamic-program over (subset, position) states. On the traveling salesman problem this is the Held–Karp algorithm: O(2ⁿ·n²) instead of O(n!) — turning an intractable factorial search into an exponential one that's vastly smaller for real n. Watch subsets fill in as binary masks and the optimal tour emerge — made playable, with theory and a quiz.
- [Interval Tree: What Contains This?](https://vibeengines.com/algorithm/interval-tree): Don't memorize the interval tree — play it. Store intervals in a BST keyed by their low endpoint and augment each node with the maximum endpoint in its subtree. A 'stabbing' query — which intervals contain point q — then prunes whole subtrees using that max, answering in O(log n + k) instead of scanning them all. Watch the search skip subtrees that can't possibly overlap — made playable, with theory and a quiz.
- [Suffix Array: Suffixes, Sorted](https://vibeengines.com/algorithm/suffix-array): Don't memorize the suffix array — play it. Sort all suffixes of a string and store their starting positions; the result powers fast substring search, longest-repeated-substring, and more, in a fraction of a suffix tree's memory. Add the LCP array — the shared prefix between neighbours — and you unlock even more. Watch the suffixes sort and the shared prefixes light up — made playable, with theory and a quiz.
- [Digit DP: Count by Digits](https://vibeengines.com/algorithm/digit-dp): Don't memorize digit DP — play it. Count how many numbers from 0 to N satisfy a digit property (like a target digit sum) without checking each one. Build them digit by digit, tracking a 'tight' flag that says whether the prefix still hugs N's own digits. Watch the count assemble position by position instead of looping to a billion — made playable, with theory and a quiz.
- [Treap: Balance by Chance](https://vibeengines.com/algorithm/treap): Don't memorize the treap — play it. It's a binary search tree and a heap at once: each node has a key (BST-ordered) and a random priority (heap-ordered). Since the shape is decided by random priorities, not insertion order, the tree stays balanced in expectation with no complicated rebalancing rules — just rotations. Watch keys insert and rotate into a balanced tree — made playable, with theory and a quiz.
- [Splay Tree: Touch It, Lift It](https://vibeengines.com/algorithm/splay-tree): Don't memorize the splay tree — play it. Every time you touch a node, it rotates all the way up to the root — so recently and frequently accessed keys stay near the top and become cheap to reach again. No balance factors or colors, just splaying, with O(log n) amortized operations. Watch each access reshape the tree and pull the key to the root — made playable, with theory and a quiz.
- [Mo's Algorithm: Reorder to Win](https://vibeengines.com/algorithm/mos-algorithm): Don't memorize Mo's algorithm — play it. Given many offline range queries, answer them by keeping one running window and sliding its two ends with cheap add/remove steps. The trick is the order: sort queries by their left endpoint's √n block, and total pointer movement collapses from O(q·n) to O((n+q)·√n). Watch reordering shrink the work — made playable, with theory and a quiz.
- [Timsort: Sort What's Already There](https://vibeengines.com/algorithm/timsort): Don't memorize Timsort — play it. The default sort in Python and Java finds the natural sorted 'runs' already present in real data, extends short ones with insertion sort, then merges the runs with a smart stack — so nearly-sorted input sorts in nearly O(n). Watch the runs get detected and merged into a fully sorted array — made playable, with theory and a quiz.
- [Min-Cost Max-Flow: Cheapest Flow First](https://vibeengines.com/algorithm/min-cost-max-flow): Don't memorize min-cost max-flow — play it. Every edge has a capacity and a per-unit cost; you want the maximum flow from source to sink at the least total cost. The method: repeatedly find the cheapest augmenting path (a shortest path by cost in the residual graph) and push flow along it. Watch flow accumulate along the cheapest routes first — made playable, with theory and a quiz.
- [Hungarian Algorithm: The Perfect Match](https://vibeengines.com/algorithm/hungarian): Don't memorize the Hungarian algorithm — play it. Given a cost matrix of workers × tasks, find the assignment of one worker per task that minimizes total cost, without trying all n! matchings. Subtract each row's minimum, then each column's, so zeros mark the cheapest options — then pick n independent zeros. Watch the matrix reduce and the optimal assignment appear — made playable, with theory and a quiz.
- [FFT: Values, Not Coefficients](https://vibeengines.com/algorithm/fft): Don't memorize the FFT — play it. Multiplying two polynomials by their coefficients is O(n²), but multiplying them as sampled values is just O(n) pointwise. The Fast Fourier Transform converts between coefficient form and value form in O(n log n) by evaluating at the roots of unity via divide-and-conquer — so polynomial multiplication and convolution drop from O(n²) to O(n log n). Watch the multiply pipeline run — made playable, with theory and a quiz.
- [Persistent Segment Tree: Every Version Kept](https://vibeengines.com/algorithm/persistent-segment-tree): Don't memorize the persistent segment tree — play it. An ordinary update destroys the old state; a persistent one keeps every past version by copying only the O(log n) nodes on the update path and sharing everything else. So you can query the array as it was at any moment in history, using O(log n) extra memory per update. Watch an update copy just one root-to-leaf path — made playable, with theory and a quiz.
- [Red-Black Tree: Balance in Two Colors](https://vibeengines.com/algorithm/red-black-tree): Don't memorize the red-black tree — play it. It keeps a binary search tree balanced by painting nodes red or black and enforcing a few color rules that bound the height to O(log n). Every insertion adds a red node, then restores the rules with recolorings and at most a couple of rotations. Watch keys insert and the tree recolor and rotate itself back into balance — made playable, with theory and a quiz.
- [Piece Table & Rope: Edit Without Copying](https://vibeengines.com/algorithm/piece-table): Don't memorize the piece table — play it. Text editors don't re-copy a whole document on every keystroke. A piece table keeps the original text read-only, appends all new text to a separate add buffer, and describes the document as a list of 'pieces' that point into the two buffers. Inserting just splits a piece — no big copy, and undo is trivial. Watch an edit split a piece — made playable, with theory and a quiz.

## Labs (AI & Engineering, Played)
- [Gradient Descent: The Descent](https://vibeengines.com/lab/gradient-descent): Don't read about gradient descent — play it. Roll a ball into the valley of a loss landscape by hand and waste steps, then let the algorithm read the slope and step downhill on its own. Crank the learning rate until it overshoots and explodes, dial it down until it crawls, then switch on momentum to escape a local minimum. Four acts — descend it, follow the gradient, tune the learning rate, escape the trap.
- [The Tokenizer](https://vibeengines.com/lab/tokenizer): A language model can't read words — it reads tokens. Watch your text shatter into sub-word chunks, race character vs word vs sub-word tokenizers head-to-head, then build Byte-Pair Encoding by hand: merge the most frequent pair over and over to grow a vocabulary and shrink the sequence. Five acts — shatter it, race three tokenizers, build BPE, tune the vocab size, and feel why 'strawberry' trips up an LLM.
- [The Dice Loader: Sampling](https://vibeengines.com/lab/sampling-explorer): Don't read about temperature, top-k, and top-p — drive them. A language model turns logits into a probability over the next token, then rolls; three dials load those dice. Slide temperature to sharpen or flatten the odds, clamp the tail with top-k or top-p, and watch the bar chart renormalize live — then hit Sample and roll. See exactly why an LLM sounds robotic at low temperature and unhinged at high.
- [The Gravity Wells: K-Means](https://vibeengines.com/lab/kmeans-clustering): Don't read about k-means — watch the clusters form. Drop three centroids into a cloud of thirty unlabeled points, then run two moves on repeat: assign every point to its nearest centroid, then slide each centroid to the mean of its crowd. Watch the mess snap into clean groups and the inertia drop each round. Unsupervised clustering, made playable, with theory, a runnable challenge and a quiz.
- [The Meaning Map: Embeddings](https://vibeengines.com/lab/embedding-space): Don't read about embeddings — explore the map. Every word becomes a point in space, placed so that closeness means similar meaning. Click a word to rank its nearest neighbours by cosine similarity, then run the famous vector arithmetic — king − man + woman lands right on queen, paris − france + japan lands on tokyo. Word embeddings and cosine similarity, made playable, with theory and a quiz.
- [The Sliding Stencil: Convolution](https://vibeengines.com/lab/image-convolution): Don't read about convolution — slide the stencil yourself. A 3×3 kernel glides over an image and, at each spot, multiplies the pixels underneath by its weights and sums them into one output pixel. Swap kernels — identity, edge-detect, blur, sharpen, emboss, Sobel — and watch the same image become edges, or blur, or sharpened. The single operation inside every CNN, made playable, with theory, a runnable challenge and a quiz.
- [The Spotlight: Attention](https://vibeengines.com/lab/attention-visualizer): Don't read about attention — shine the spotlight yourself. In a Transformer, every word looks at every other word and weights how much to listen to each. Click a word to see where its attention goes — the verb leaning on its subject, the determiner pointing at its noun — as glowing links and a heatmap whose weights sum to one. Self-attention (the softmax(QKᵀ) heart of every LLM), made playable, with theory and a quiz.
- [Out of the Static: Diffusion](https://vibeengines.com/lab/diffusion-denoise): Don't read about diffusion — watch the picture climb out of the static. Diffusion models generate by starting from pure random noise and removing a little of it, step by step, until a shape appears. Step through the reverse process and watch a heart emerge from random pixels as the noise level drops to zero. The idea behind Stable Diffusion and DALL·E, made playable, with theory and a quiz.
- [The Bend: Activation Functions](https://vibeengines.com/lab/activation-functions): Don't read about activations — bend the curve yourself. A neural network is just linear algebra until you add a non-linear activation on each neuron. Plot sigmoid, tanh, ReLU, leaky ReLU, and GELU with their derivatives, and slide a point to read the gradient — watching sigmoid's slope vanish at the edges while ReLU's stays a flat 1. The reason deep nets learn, made playable, with theory and a quiz.
- [The Line-Drawer: Perceptron](https://vibeengines.com/lab/perceptron-playground): Don't read about the perceptron — watch it draw the line. The simplest neural network, one neuron from 1958, learns to separate two classes of points by nudging a straight boundary every time it gets one wrong. Step through the updates and watch the line swing from a bad guess into a perfect split — then meet the XOR wall that a single line can't cross. The seed of every neural network, made playable, with theory, a runnable challenge and a quiz.
- [The Loop: Agent Loop Simulator](https://vibeengines.com/lab/agent-loop-simulator): Don't read about the agent loop — run it. Step a model through plan → act → observe: it thinks, calls a tool, reads the result, and loops until it can answer. Watch the context window fill turn by turn and compaction fold old turns away before it overflows — the beating heart of every AI harness, made playable, with theory and a quiz.
- [The Break-In: Prompt Injection](https://vibeengines.com/lab/prompt-injection-playground): Don't read about prompt injection — try to pull one off. Feed a helpful agent a booby-trapped message that tries to steal its secret or hijack its tools, and watch it get owned. Then switch on real defenses — instruction hierarchy, input sanitizing, output filtering, tool permissions — and watch the same attack bounce. The #1 security risk in LLM apps, made playable, with theory and a quiz.
- [The Loop Designer: Outer Loops](https://vibeengines.com/lab/loop-designer): Don't read about loop engineering — break a loop, then fix it. An agent must migrate 8 files overnight, unattended; you design its outer loop. Toggle the hard cap, the independent verifier, and the external memory, hit Run, and watch the classic failures fire live: the $500 runaway, groundhog-day amnesia, and victory declared on broken code. Four scenarios, one lesson — same agent, different loop, opposite outcomes.
- [The Memory Tax: KV-Cache Visualizer](https://vibeengines.com/lab/kv-cache-visualizer): Don't read about the KV cache — fill it. A model generating text pays a hidden rent: for every token, in every layer, it stores a key and a value so it never recomputes the past. Watch the cache stack up as it decodes, collapse it with grouped-query attention, then slam into the VRAM wall that decides how many users a GPU can serve — and quantize the cache to claw the memory back. Four acts — fill it, collapse it with GQA, hit the wall, quantize it.
- [The Skip-List of Space: HNSW](https://vibeengines.com/lab/hnsw-visualizer): Don't read about approximate nearest-neighbor search — navigate it. A billion vectors, and you need the closest few in milliseconds — you can't compare them all. Drop a query into a vector space and watch HNSW hop across a layered proximity graph: coarse express lanes up top, dense local streets at the bottom. Race it against brute-force scanning, then tune efSearch and M to feel the recall-latency-memory trade. Three acts — navigate the layers, race brute force, tune recall vs speed.
- [The Understudy: Speculative Decoding](https://vibeengines.com/lab/speculative-decoding): Don't read about speculative decoding — run it. A giant model reads one token at a time, slow, because each token drags all its weights through the GPU. So a small draft model guesses the next few tokens, and the big model verifies them all in one pass, keeping every guess it agrees with. Watch tokens get accepted and rejected, then tune the acceptance rate and draft length to see where 2-3x faster generation — with identical output — comes from. Three acts — feel the bottleneck, draft and verify, dial acceptance to speed.
- [The Rounding Room: Quantization](https://vibeengines.com/lab/quantization-lab): Don't read about quantization — round some weights yourself. A model is billions of 16-bit numbers, but do you need all 16? Snap each weight to a coarser grid — 8 bits, 4, even 2 — and watch the memory collapse while precision blurs. Discover why weights bunch near zero, why NF4 places its levels at the quantiles of a bell curve to beat plain INT4, and where quality finally breaks. Three acts — round one weight, quantize the whole bell curve, trade memory against quality at scale.
- [The Switchboard: Mixture of Experts](https://vibeengines.com/lab/moe-routing): Don't read about mixture-of-experts — route the tokens yourself. How does a trillion-parameter model run like a small one? A router sends each token to just a few of many experts, so the model stores a giant and pays for a sliver. Watch tokens light up their chosen experts, slide expert count and top-k to pull total and active parameters apart, then send a burst with load-balancing off to watch one expert overload — and on to fix it. Three acts — route a token, store big pay small, balance the load.
- [The Crowded Desk: Context Rot](https://vibeengines.com/lab/context-rot-demo): Don't read about context rot — cause it. Give a model a bigger window and it should get smarter, right? Bury one crucial fact in a wall of filler and find out. Slide the needle from top to bottom to watch it sink in the middle, pour in filler to watch recall rot as the desk fills, then toggle retrieval, repositioning and compaction to claw it back. Three acts — lost in the middle, the rot curve, fight back with context engineering.
- [The Assembly Line: Batching & Throughput](https://vibeengines.com/lab/batching-simulator): Don't read about batching — run the GPU. One request wastes a chip built for hundreds, because generating a token streams every weight through the GPU whether you use one sequence or fifty. Slide the batch up to watch throughput soar and cost-per-token fall, trade it against a latency budget, then race static batching (stalls on the slowest request) against continuous batching (never idles). Three acts — fill the GPU, throughput vs latency, static vs continuous.
- [The Taste Trainer: RLHF & DPO](https://vibeengines.com/lab/rlhf-preference-lab): Don't read about RLHF — do the aligning. A base model can write but doesn't know what people prefer, so you teach it taste: pick which of two answers is better, over and over, and watch a reward model learn your preferences. Then turn up the optimization pressure and watch the policy chase that reward — and reward-hack it into sycophancy — while a KL penalty pulls it back. Finally see how DPO skips the whole reward model. Three acts — teach the taste, chase and hack the reward, the DPO shortcut.
- [The Blame Machine: Backpropagation](https://vibeengines.com/lab/backprop-visualizer): Don't read about backpropagation — run it. A network guesses and gets it wrong; the hard question is which weight is to blame, and by how much. Push a number forward through a tiny network, measure the loss, then watch the error flow backward assigning a gradient to every weight via the chain rule. Train it to convergence (or crank the learning rate until it explodes), then slide network depth to watch gradients vanish and explode. Three acts — forward and back, learn a step, vanish and explode.
- [Raft: The Election](https://vibeengines.com/lab/raft-simulator): Don't read about Raft — run the cluster. Five nodes start as followers with random election timers; when one times out it becomes a candidate, bumps the term, and asks the others for votes. Win a majority and you're leader, sending heartbeats that reset everyone's timers. Kill the leader and watch a new election fire. Leader election and split-vote handling, made playable, with theory and a quiz.
- [The Quorum Dial](https://vibeengines.com/lab/quorum-simulator): Don't read about quorums — dial them. With N replicas, a write goes to W of them and a read consults R of them. When R+W>N the read and write sets are forced to overlap, so a read always sees the latest write — strong consistency. Drop below that and reads can miss the newest value. Slide R and W and watch a read go fresh or stale. Tunable consistency, made playable, with theory and a quiz.
- [Vector Clocks: Who Caused What](https://vibeengines.com/lab/vector-clocks): Don't read about vector clocks — trace them. Three processes with no shared clock each keep a vector counting events they know about. A local event bumps your own entry; sending attaches your vector; receiving merges by taking the element-wise max. Compare two vectors and you can tell whether one event caused the other — or whether they're truly concurrent. Watch causality emerge on a timeline, made playable, with theory and a quiz.
- [CRDT Merge: No Conflict](https://vibeengines.com/lab/crdt-merge): Don't read about CRDTs — merge them. Three replicas edit the same counter at the same time with no coordination, then sync in any order — and always converge to the exact same value. The secret is a merge that is commutative, associative, and idempotent (here, element-wise max of per-replica counts). Increment replicas independently, merge them, and watch every replica agree, made playable, with theory and a quiz.
- [The Rumor Mill: Gossip](https://vibeengines.com/lab/gossip-sim): Don't read about gossip protocols — start a rumor. One node learns an update; each round, every node that knows it tells a random peer. The knowledge spreads like an epidemic — doubling each round — so all N nodes hear it in about log N rounds, with no central coordinator and graceful tolerance of failures. Watch a single update sweep a whole cluster, made playable, with theory and a quiz.
- [The Eviction Race: LRU vs LFU](https://vibeengines.com/lab/eviction-race): Don't read about cache eviction — race the policies. Feed the same access stream to three caches of equal size and watch them make different choices: FIFO evicts the oldest, LRU evicts the least-recently-used, LFU evicts the least-frequently-used. On a hot-key-plus-scan workload, LFU keeps the hot item while LRU and FIFO throw it away — and the hit rates diverge. Step the stream and watch, made playable, with theory and a quiz.
- [The Load Balancer](https://vibeengines.com/lab/load-balancer-sim): Don't read about load balancing — distribute the traffic. A load balancer spreads requests across a pool of servers, but the strategy decides everything: round-robin cycles blindly, least-connections sends work to the least-busy server, and hashing pins each client to one server for stickiness. When requests have uneven cost, the naive strategies pile up on one box while least-connections stays smooth. Send traffic and watch the queues, made playable, with theory and a quiz.
- [Backpressure: The Bounded Queue](https://vibeengines.com/lab/queue-backpressure): Don't read about backpressure — feel the queue fill. A fast producer feeds a slow consumer through a bounded buffer. Without backpressure the queue overflows and you silently drop work; with backpressure you slow the producer to the consumer's pace so nothing is lost — you trade latency for reliability. Toggle backpressure and watch drops turn into controlled waiting, made playable, with theory and a quiz.
- [The TCP Sawtooth](https://vibeengines.com/lab/tcp-congestion): Don't read about TCP congestion control — watch the sawtooth form. A sender probes the network's capacity by growing its congestion window exponentially at first (slow start), then linearly (congestion avoidance). When a packet is lost, it halves the window and probes again. This additive-increase / multiplicative-decrease loop makes millions of independent senders converge to a fair, stable share. Grow the window, inject loss, and watch it recover — made playable, with theory and a quiz.
- [The DNS Journey](https://vibeengines.com/lab/dns-journey): Don't read about DNS — watch a name resolve. Typing a domain kicks off a recursive walk down a global tree: your resolver asks a root server (which points to the TLD), the TLD server (which points to the authoritative server), and finally the authoritative server (which returns the IP). Then it caches the answer so the next lookup is instant. Resolve a name step by step and watch the cache short-circuit a repeat lookup, made playable, with theory and a quiz.
- [The TLS Handshake](https://vibeengines.com/lab/tls-handshake): Don't read about TLS — watch two strangers agree on a secret while everyone is listening. A certificate proves the server's identity, and an ephemeral Diffie-Hellman exchange lets client and server derive the same secret key from public numbers without ever sending it across the wire. Step through the messages, watch each side compute the identical secret, and see why an eavesdropper still can't read it — with real tiny-number DH math, a quiz, and theory.
- [The Query Planner](https://vibeengines.com/lab/sql-planner): Don't guess why your query is slow — watch the planner choose. A cost-based query planner estimates the cost of every way to run a query — full table scan, index scan, bitmap AND of two indexes — and picks the cheapest. The catch: an index isn't always a win. Change how selective each predicate is, add or drop indexes, and watch the planner flip between a sequential scan and an index scan for reasons you can finally see. Made playable, with theory and a quiz.
- [B-Tree vs LSM-Tree](https://vibeengines.com/lab/btree-vs-lsm-race): Don't read about storage engines — race them. A B-tree updates data in place: reads are cheap and stable, but every write is a random disk write. An LSM-tree appends writes to an in-memory buffer, flushes them as sorted runs, and compacts in the background: writes are cheap and sequential, but a read may have to check several runs. Stream the same writes into both, watch flushes and compaction happen, and see which engine wins for writes and which for reads — made playable, with theory and a quiz.
- [The Git Object Graph](https://vibeengines.com/lab/git-object-graph): Don't read about how Git stores your code — build the object graph. Every commit is a snapshot, not a diff: Git stores file contents as blobs, directories as trees, and each commit points to a tree plus its parent. Everything is addressed by the hash of its content, so identical content is stored exactly once and unchanged files are shared across commits for free. Edit files, commit, and watch new objects appear and unchanged ones get reused — made playable, with theory and a quiz.
- [How a Regex Runs: The NFA](https://vibeengines.com/lab/regex-nfa): Don't read about regular expressions — run one, state by state. A regex compiles to a small state machine (an NFA), and matching a string means tracking the SET of states the machine could be in at once — following epsilon jumps and consuming one character at a time. Because it tracks a set instead of guessing and backtracking, it matches in linear time with no catastrophic blowups. Feed characters into the machine for a(b|c)*d and watch the active states light up — made playable, with theory and a quiz.
- [The Optimizer Race](https://vibeengines.com/lab/optimizer-race): Don't read about optimizers — race them down the same hill. Training a neural network is gradient descent on a loss surface, and the optimizer decides the path. On an ill-conditioned ravine, plain SGD zigzags and crawls, momentum builds speed along the valley floor, and Adam adapts its step size per direction to head almost straight for the bottom. Step the three optimizers down the same surface and watch their paths and losses diverge — made playable, with theory and a quiz.
- [The Loss Landscape](https://vibeengines.com/lab/loss-landscape): Don't read about local minima — drop a ball and watch. Training is gradient descent on a loss landscape, and the shape decides whether descent finds the best answer, gets trapped in a worse one, or crawls to a halt. Roll a ball down a convex bowl (always finds the bottom), a double-well surface (where the start decides which minimum), and a flat plateau (where the gradient vanishes and progress stalls). See why the surface's shape governs training — made playable, with theory and a quiz.
- [Inside a Transformer: Self-Attention](https://vibeengines.com/lab/transformer-forward-pass): Don't read about attention — compute it, token by token. At the heart of every transformer is self-attention: each token forms a query, compares it against every token's key to get scores, softmaxes those into weights, and builds its new representation as a weighted sum of every token's value. That's how a model lets 'it' look back at 'robot.' Pick a query token and watch its scores become softmax weights become a context vector — with the real dot-product math, a quiz, and theory.
- [RoPE: Position by Rotation](https://vibeengines.com/lab/rope-positional-lab): Don't read about rotary position embeddings — rotate the vectors yourself. Attention has no built-in sense of order, so RoPE injects position by rotating each token's query and key by an angle proportional to its position. Because a dot product depends only on the angle between vectors, the attention score ends up depending only on the RELATIVE distance between tokens. Slide two tokens along a sequence and watch their score depend purely on the gap — made playable, with theory and a quiz.
- [Chain-of-Thought vs Direct](https://vibeengines.com/lab/cot-vs-direct): Don't read about chain-of-thought — watch it rescue a wrong answer. A model produces one token at a time, so asking it to blurt a final answer to a multi-step problem crams the whole computation into one step — and it often takes a tempting shortcut and gets it wrong. Asking it to think step by step lets it spend intermediate tokens working the problem, each step small enough to get right. Run the same problems both ways and see the shortcut fail and the chain succeed — made playable, with theory and a quiz.
- [The MCP Playground](https://vibeengines.com/lab/mcp-playground): Don't read about MCP — watch a model use tools through it. The Model Context Protocol is a standard way to connect an AI host to external tools and data: servers advertise tools with schemas, the host discovers them, the model decides which to call and with what arguments, the server runs the tool, and the result flows back for the model to answer. Step through a real request — get the weather, then save it to notes — and see the whole discover, call, result, answer loop, with theory and a quiz.
- [The Latent Walk](https://vibeengines.com/lab/gan-latent-walk): Don't read about latent space — walk through it. A generative model turns a vector of numbers into an image, and that space is smooth and structured: nearby codes make similar images, a straight line between two codes morphs one into the other, and specific directions correspond to meaningful attributes. Move through a toy generator's latent space, interpolate between two points, and steer a single semantic direction to see how a model organizes what it can create — made playable, with theory and a quiz.
- [The Deployment Target Chooser](https://vibeengines.com/lab/deployment-target-chooser): Don't guess where a customer solution should run — answer the constraints and watch the recommendation fall out. The FDE question that reshapes an architecture most is "where can this run?". Toggle whether data can leave, whether it's regulated, whether there's internet, and how fast you must ship updates, and see how the four targets — SaaS, customer VPC, on-prem, air-gapped — score, with the reasoning behind the winner. Made playable, with theory and a quiz.
- [The Integration Reliability Lab](https://vibeengines.com/lab/integration-reliability-lab): Don't read about reliable integrations — watch a flaky endpoint drop and duplicate events, then fix it. Send a stream of deliveries through an endpoint that sometimes fails or times out, and toggle the three patterns that make it survive real traffic: retries (fewer losses, but new duplicates), idempotency (kills the duplicates), and a dead-letter queue (turns loss into something recoverable). Watch the exactly-once delivery rate climb — made playable, with theory and a quiz.
- [The Data Mapping Lab](https://vibeengines.com/lab/data-mapping-lab): Don't read about data mapping — do it, and watch rows pass or fail. Every customer hands you a messy export; before it flows in, each column must be mapped to a canonical field and coerced to a type, with the rows that don't fit quarantined, not silently dropped. Pick which column feeds each field and watch validation light up green and red, row by row — a wrong mapping fails everything, a right one quarantines only the bad values. Made playable, with theory and a quiz.
- [The Rollout Strategy Lab](https://vibeengines.com/lab/rollout-strategy-lab): Don't read about rollout strategies — ship a bug and watch the blast radius. How you roll out a change to a customer's users decides how many people a bad release hits before you catch it: big-bang exposes everyone, a canary exposes 1% first. Pick a strategy, ship a buggy or healthy release, and see the blast radius — and the rollout speed you trade for safety. Made playable, with theory and a quiz.
- [The Scoping Simulator](https://vibeengines.com/lab/scoping-simulator): Don't read about scoping — cut it under a deadline. You have a two-week budget and a wishlist. Pick the features for a proof of concept and watch the verdict: does it include the one vertical slice that proves value, and does it fit the timebox? Overload it and you ship nothing; skip the core and you prove nothing. Find the smallest slice that makes the customer believe — made playable, with theory and a quiz.
- [All At Once — Text Diffusion Decoding](https://vibeengines.com/lab/text-diffusion-decoding): Don't read about diffusion LLMs — run one. An autoregressive model writes one token per pass; a text-diffusion model starts from a fully masked block and refines the whole thing in parallel over K denoising steps, emitting B/K tokens per pass. Watch a block go from ██████ to clean text, then tune the block size and step count to feel the speed-versus-coherence dial — and see why text diffusion (masking, discrete) is not image diffusion (Gaussian noise, continuous). Interactive, with theory and a quiz.
- [The Million-Token Bill — Sparse Attention](https://vibeengines.com/lab/sparse-attention-1m): Don't read about long-context attention — run the numbers. Dense attention caches a key/value per token and scores every query against all of them, so at a million tokens memory grows linearly and compute grows with the square. Pull the two levers of compressed sparse attention — compress each token's K/V to a latent, and select only the top-k blocks per query — and watch the KV cache and attention FLOPs collapse, with the two savings multiplying (as in DeepSeek-V4). Drag the context to a million and see the ratios fall. Interactive, with theory and a quiz.

## Coding Challenges (DSA & AI Engineering)
- [Two Sum](https://vibeengines.com/challenge/two-sum): The classic warm-up: find the two numbers that add up to a target. Brute force is O(n²) — a hash map gets you to one pass, O(n). Solve it in Python or TypeScript, right in your browser, with hidden tests and a reveal-solution button.
- [Valid Parentheses](https://vibeengines.com/challenge/valid-parentheses): The canonical stack problem: decide whether every bracket is closed by the right type, in the right order. A stack turns nested matching into a single pass. Solve it in Python or TypeScript with hidden tests.
- [Fizz Buzz](https://vibeengines.com/challenge/fizzbuzz): The famous screening question. Print 1…n, but multiples of 3 become "Fizz", of 5 become "Buzz", and of both become "FizzBuzz". Easy — the catch is testing divisibility in the right order. Solve it in Python or TypeScript.
- [Softmax](https://vibeengines.com/challenge/softmax): The function at the end of every classifier and language model: turn raw scores (logits) into a probability distribution. Implement the numerically stable version so big logits do not overflow. Solve it in Python or TypeScript.
- [Cosine Similarity](https://vibeengines.com/challenge/cosine-similarity): The measure behind every embedding search and RAG system: how aligned are two vectors, ignoring their length? Dot product over the product of magnitudes — 1 identical, 0 orthogonal, -1 opposite. Solve it in Python or TypeScript.
- [Top-K Retrieval](https://vibeengines.com/challenge/top-k-retrieval): The core of the "R" in RAG: given a query embedding and a set of document embeddings, return the indices of the k most similar docs by cosine similarity, with a stable tie-break. Solve it in Python or TypeScript.
- [Token-Level F1](https://vibeengines.com/challenge/token-f1): The metric behind QA evaluation (SQuAD and friends): how well does a predicted answer overlap a reference as a bag of words? Compute token precision and recall, then their harmonic-mean F1. Solve it in Python or TypeScript.
- [Single-Head Attention](https://vibeengines.com/challenge/single-head-attention): The operation at the heart of every Transformer: scaled dot-product attention. Given queries, keys, and values, let each query pull a weighted blend of the values — softmax(QKᵀ/√d)·V — with a numerically stable softmax and no numpy, just the math. Solve it in Python or TypeScript.
- [Layer Normalization](https://vibeengines.com/challenge/layer-norm): The stabilizer wrapped around every Transformer sub-layer: re-center and re-scale a vector to mean 0 and variance 1, then let learned gamma and beta stretch and shift it back — y = gamma·(x−mean)/√(var+eps) + beta. Keeps deep nets trainable. Solve it in Python or TypeScript.
- [Cross-Entropy Loss](https://vibeengines.com/challenge/cross-entropy): The loss that trains almost every classifier and language model. It measures how surprised the model was by the right answer — high probability on the true class → near 0, confidently wrong → explodes. Return -log(p[target]), eps-guarded. Solve it in Python or TypeScript.
- [K-Nearest Neighbors](https://vibeengines.com/challenge/knn): The simplest classifier there is: to label a new point, look at the k closest labeled points and let them vote. No training, no weights — just Euclidean distances, with deterministic tie-breaks. The whole model is the dataset. Solve it in Python or TypeScript.
- [TF-IDF](https://vibeengines.com/challenge/tf-idf): The scoring that ran search for decades — and still seeds hybrid retrieval today. Reward a word frequent in one document but rare across the corpus, shrug off words that appear everywhere: tf·log(N/df). Solve it in Python or TypeScript.
- [LRU Cache](https://vibeengines.com/challenge/lru-cache): The eviction policy behind every size-limited cache: when you run out of room, throw out whatever was used least recently. The trick is O(1) get and put — an ordered hash map (Python dict / JS Map) gives you exactly that. Solve it in Python or TypeScript.
- [Retry with Exponential Backoff](https://vibeengines.com/challenge/retry-backoff): Tools time out and APIs rate-limit — a production agent retries without hammering. Exponential backoff waits longer after each failure (1s, 2s, 4s, 8s…) up to a cap. Compute the delay schedule: delay[i] = min(cap, base·2ⁱ). Solve it in Python or TypeScript.
- [Trim History to a Token Budget](https://vibeengines.com/challenge/token-budget-trim): Every agent turn re-sends the whole conversation, so history must fit the context budget. Keep the most recent messages that fit and drop the oldest — the trimmer at the heart of context management. Solve it in Python or TypeScript.
- [Parse a Tool Call](https://vibeengines.com/challenge/tool-call-parser): When a model wants to act, it emits a call like search(query=cats, limit=5). Parse that string into a function name and typed arguments before the harness can dispatch it — the little parser that turns a model's intent into an action. Solve it in Python or TypeScript.
- [Run the Goal Loop](https://vibeengines.com/challenge/goal-loop): The engine of loop engineering: attempt the front task, let an independent verifier judge it, retry failures with state untouched, and stop when the goal is met — or loudly when the cap trips. Implement the whole outer loop as one pure, testable function. Solve it in Python or TypeScript.
- [BM25 Scoring](https://vibeengines.com/challenge/bm25): The keyword-ranking function every fancy retriever still has to beat. Implement BM25 — term frequency that saturates, rare terms weighted up, long documents normalized down — the lexical half of every hybrid search pipeline. Solve it in Python or TypeScript.
- [BPE Merge Step](https://vibeengines.com/challenge/bpe-merge): One step of how every tokenizer vocabulary is built: count adjacent symbol pairs across the corpus, pick the most frequent (ties break lexicographically), and merge it everywhere, left to right, without overlaps. Run it a few thousand times and you have byte-pair encoding. Solve it in Python or TypeScript.
- [MMR Reranking](https://vibeengines.com/challenge/mmr-rerank): Top-k by similarity returns five copies of the same paragraph. Implement Maximal Marginal Relevance: greedily pick results that are relevant to the query AND different from what you already picked — λ·relevance − (1−λ)·redundancy, with cosine similarity. Solve it in Python or TypeScript.
- [Streaming Median](https://vibeengines.com/challenge/streaming-median): Latency dashboards do this every second: maintain the median of a stream without re-sorting per event. The classic two-heap trick — a max-heap for the low half, a min-heap for the high half, the median always at the boundary. Solve it in Python or TypeScript.
- [Token Bucket Rate Limiter](https://vibeengines.com/challenge/token-bucket): The algorithm inside most production rate limiters — and it never runs a timer. Refill the bucket lazily from the time elapsed since the last request, cap at capacity, spend one token or reject. Two numbers of state per client, exactly like the Redis version. Solve it in Python or TypeScript.
- [Circuit Breaker](https://vibeengines.com/challenge/circuit-breaker): Stop one failing dependency from taking down the fleet: trip after consecutive failures, fail fast while open, probe once after the cooldown. Implement the closed → open → half-open state machine as a pure, testable replay. Solve it in Python or TypeScript.
- [Beam Search Decoder](https://vibeengines.com/challenge/beam-search): Greedy decoding takes the best next token and never looks back — straight into garden paths. Keep the k best partial sequences alive at every step, with a product score and a clean tie-break, and watch k=2 escape a trap k=1 falls into. Solve it in Python or TypeScript.
- [Number of Islands](https://vibeengines.com/challenge/number-of-islands): The canonical connected-components question. Flood-fill each unvisited patch of land with BFS or DFS, count how many floods you started — grid traversal, visited bookkeeping, and the classic diagonal trap. Solve it in Python or TypeScript.
- [Merge Intervals](https://vibeengines.com/challenge/merge-intervals): Calendar apps and memory allocators run on this: sort by start, sweep once, grow or close the current block. Touching endpoints merge, nested intervals vanish — the classic that punishes off-by-one thinking. Solve it in Python or TypeScript.
- [Top-K Frequent Elements](https://vibeengines.com/challenge/top-k-frequent): Count, then rank — the two-step pattern behind trending topics and hot-key detection. A hash map counts; a (-count, value) sort ranks with a clean tie-break; buckets get you to O(n) if you want the flex. Solve it in Python or TypeScript.
- [3Sum](https://vibeengines.com/challenge/three-sum): The rite of passage: every unique zero-sum triplet, no duplicates, no O(n³). Sort once, fix one element, squeeze the rest with two pointers, and skip duplicates at all three levels. Solve it in Python or TypeScript.
- [Union-Find (Connected Components)](https://vibeengines.com/challenge/union-find): The disjoint-set behind Kruskal’s MST and network connectivity: answer "are these connected?" in near-constant time with union by rank and path compression, then count the components. Solve it in Python or TypeScript, with hidden tests.
- [Min Stack](https://vibeengines.com/challenge/min-stack): A stack that also returns its minimum in O(1) — no scanning. Carry the running minimum alongside each element. Replay push/pop/top/getMin operations. Solve it in Python or TypeScript, with hidden tests.
- [Sliding-Window Rate Limiter](https://vibeengines.com/challenge/sliding-window-rate-limiter): Allow at most N requests per rolling window — the rate limiter that guards real APIs. A sliding log of accepted timestamps gives exact limits without fixed-window bursts. Decide accept/reject for a stream. Solve it in Python or TypeScript, with hidden tests.
- [LFU Cache](https://vibeengines.com/challenge/lfu-cache): The cache that evicts what you use least often — and, on ties, least recently. Harder than LRU: track frequency and recency together, still O(1) per op. Replay get/put operations. Solve it in Python or TypeScript, with hidden tests.
- [Consistent Hashing Ring](https://vibeengines.com/challenge/consistent-hash-ring): How distributed caches decide which node owns a key — with tiny churn when nodes join or leave. Build a hash ring with virtual nodes and route keys clockwise. A provided hash keeps Python and TypeScript in sync. Hidden tests.
- [Bloom Filter](https://vibeengines.com/challenge/build-bloom-filter): A tiny bit-array that answers "have I seen this?" in a fraction of a set’s memory — with occasional false positives but never a false negative. Build one with double hashing. Provided hashes keep both languages in sync. Hidden tests.
- [Implement a Trie](https://vibeengines.com/challenge/implement-trie): The prefix tree behind autocomplete and spell-check: insert, search, and startsWith in time proportional to word length. Replay the operations on a tree keyed by characters. Solve it in Python or TypeScript, with hidden tests.
- [KMP Failure Table](https://vibeengines.com/challenge/kmp-failure-table): The precomputation that makes KMP string search run in O(n): for every prefix, the longest proper prefix that is also a suffix. Get it right and matching never backtracks. Build it in Python or TypeScript, with hidden tests.
- [Longest Common Subsequence](https://vibeengines.com/challenge/lcs-diff): The DP behind "git diff" and DNA alignment: the longest subsequence common to two strings (order kept, gaps allowed). A classic 2-D table in O(m·n). Solve it in Python or TypeScript, with hidden tests.
- [Mini Regex Matcher (. and *)](https://vibeengines.com/challenge/mini-regex-matcher): Implement regex matching with "." and "*" — the classic hard interview problem. The subtlety: "*" can match nothing or many, so you must explore both. Solve it with DP in Python or TypeScript, with hidden tests.
- [Expression Calculator](https://vibeengines.com/challenge/expression-calculator): Evaluate an arithmetic string with precedence and parentheses, the way an interpreter does. A tiny recursive-descent parser handles precedence naturally. Solve it in Python or TypeScript, with hidden tests.
- [JSON Parser (Recursive Descent)](https://vibeengines.com/challenge/json-parser): Write the parser behind every API and config file: turn a JSON string into native objects, arrays, numbers, strings, booleans and null — by hand, without the built-in parser. Recursive descent mirrors the grammar. Solve it in Python or TypeScript, with hidden tests.
- [Dijkstra’s Shortest Paths](https://vibeengines.com/challenge/dijkstra): The algorithm every routing table and map app leans on: single-source shortest paths with non-negative weights. Greedily settle the closest node, relax its edges, repeat. Return the distance to every node. Solve it in Python or TypeScript, with hidden tests.
- [A* Pathfinding on a Grid](https://vibeengines.com/challenge/a-star-grid): The pathfinder inside games and robots: A* expands nodes by "cost so far + estimated cost to go", so the heuristic focuses the search toward the goal instead of spreading blindly. Return the shortest path length. Solve it in Python or TypeScript, with hidden tests.
- [Course Schedule (Cycle Detection)](https://vibeengines.com/challenge/course-schedule): Can you finish every course given its prerequisites? The classic "is this dependency graph acyclic?" check a build system runs. Detect a cycle with a topological sort. Solve it in Python or TypeScript, with hidden tests.
- [Word Ladder](https://vibeengines.com/challenge/word-ladder): Transform one word into another one letter at a time, every step a real word — a shortest path in a hidden graph, so a job for BFS. Return the shortest ladder length. Solve it in Python or TypeScript, with hidden tests.
- [Matrix Exponentiation](https://vibeengines.com/challenge/matrix-power): Raise a matrix to the n-th power in O(log n) multiplies instead of n — the trick that computes the billionth Fibonacci number almost instantly. Fast exponentiation, lifted from numbers to matrices. Solve it in Python or TypeScript, with hidden tests.
- [Skip List Insert & Search](https://vibeengines.com/challenge/skiplist-insert): O(log n) search and insert from nothing but linked lists and express lanes — the structure behind Redis sorted sets. Here node heights are given, so it’s fully deterministic. Solve it in Python or TypeScript, with hidden tests.
- [Reservoir Sampling](https://vibeengines.com/challenge/reservoir-sample): Pick k items uniformly at random from a stream of unknown length — one pass, O(k) memory. Here the random draws are supplied, so the result is deterministic and testable. Solve it in Python or TypeScript, with hidden tests.
- [HyperLogLog Cardinality Estimator](https://vibeengines.com/challenge/hll-cardinality): Count how many distinct items a stream held — billions of them — using a few kilobytes, not a giant set. Turn "the longest run of leading zeros" into an estimate. Powers COUNT(DISTINCT) in Redis and BigQuery. Solve it in Python or TypeScript, with hidden tests.
- [Raft Leader Election (Majority)](https://vibeengines.com/challenge/raft-election-step): The heartbeat of the Raft consensus algorithm: a candidate becomes leader only by winning a strict majority of the cluster — the rule that guarantees at most one leader per term. Decide an election round. Solve it in Python or TypeScript, with hidden tests.
- [Vector Clock Merge](https://vibeengines.com/challenge/vector-clock-merge): Vector clocks let processes with no shared time agree on which event caused which. The key operation: on receive, take the element-wise max of the two clocks, then tick your own entry. Solve it in Python or TypeScript, with hidden tests.
- [CRDT: Grow-Only Counter](https://vibeengines.com/challenge/crdt-gcounter): A counter many replicas increment independently, with no coordination, that always converges to the same total after syncing — a G-Counter, the simplest CRDT. Merge per-replica payloads by element-wise max. Solve it in Python or TypeScript, with hidden tests.
- [Softmax with Temperature](https://vibeengines.com/challenge/softmax-temperature): The dial that controls how "creative" a language model is: temperature scales the logits before the softmax — low sharpens toward greedy, high flattens toward uniform. Implement it, numerically stable. Solve it in Python or TypeScript, with hidden tests.
- [Semantic Chunker (Token Budget)](https://vibeengines.com/challenge/semantic-chunker): Before you embed a document for retrieval, split it into chunks that fit a token budget — without slicing a sentence. The greedy packer fills each chunk with whole sentences until the next would overflow. Solve it in Python or TypeScript, with hidden tests.
- [Speculative Decoding: Accept Step](https://vibeengines.com/challenge/speculative-accept): Speculative decoding speeds up LLM inference: a small draft model proposes tokens, the big target model verifies them in one pass. The accept/reject rule guarantees the output matches the target’s own distribution. Implement it. Solve it in Python or TypeScript, with hidden tests.
- [KV-Cache Eviction (Attention Sinks)](https://vibeengines.com/challenge/kv-eviction): An LLM’s KV cache grows every token, so long chats must drop old entries without wrecking quality. StreamingLLM keeps the first few "attention sink" tokens plus a sliding window, evicting the middle. Compute the survivors. Solve it in Python or TypeScript, with hidden tests.
- [Constrained Decoding (Logit Masking)](https://vibeengines.com/challenge/constrained-decode): How do you force an LLM to emit only valid JSON or a token your grammar allows? Mask the logits: set every disallowed token to −∞, then take the argmax over what remains. The backbone of structured output. Solve it in Python or TypeScript, with hidden tests.
- [Verify a Webhook Signature](https://vibeengines.com/challenge/webhook-signature-verify): Every real integration sends signed webhooks — and every FDE has to verify them. Recompute the signature over the payload, compare in constant time, and reject stale events to stop replay attacks. Solve it in Python or TypeScript, with hidden tests.
- [Idempotency Key Handler](https://vibeengines.com/challenge/idempotency-key-handler): Networks retry. A webhook fires twice; a payment is re-sent after a timeout. Without idempotency you double-charge or double-write. The fix: dedupe by a client-supplied key and always return the first result. Solve it in Python or TypeScript, with hidden tests.
- [CSV → Schema Mapper](https://vibeengines.com/challenge/csv-schema-mapper): Every customer hands you a messy export. Before it flows into your system, each row must be coerced to a schema — strings to ints, "true" to booleans — and the rows that don’t fit quarantined, not silently dropped. Solve it in Python or TypeScript, with hidden tests.
- [Data Reconciliation Diff](https://vibeengines.com/challenge/data-reconciliation-diff): The customer swears the migration worked. You reconcile: compare source records against what landed in the target, keyed by id, and report exactly what was added, removed, or changed. Solve it in Python or TypeScript, with hidden tests.
- [PII Redactor](https://vibeengines.com/challenge/pii-redactor): Before customer data touches a log line — or a third-party LLM — the personal bits have to go. Mask emails, SSNs, credit cards, and phone numbers with pattern matching, leaving the rest readable. Solve it in Python or TypeScript, with hidden tests.
- [Config Validator](https://vibeengines.com/challenge/config-validator): Half of "it doesn’t work at the customer" is a bad config — a missing key, a string where an int belongs, an env that isn’t allowed. Validate it up front and fail loudly with a clear list instead of crashing three layers deep. Solve it in Python or TypeScript, with hidden tests.
- [API Pagination Collector](https://vibeengines.com/challenge/api-pagination-collector): The customer’s API returns 100 rows at a time behind a cursor. You need all of them. Follow the "next" pointer page by page until it runs out — the loop behind every "sync everything" integration. Solve it in Python or TypeScript, with hidden tests.
- [Exponential Backoff with Full Jitter](https://vibeengines.com/challenge/backoff-jitter): When a customer’s API throws 503s, everyone retrying on the same doubling schedule stampedes it in sync. Full jitter spreads the retries randomly across the window so the herd disperses. Compute the delay schedule. Solve it in Python or TypeScript, with hidden tests.
- [Write a Verifier](https://vibeengines.com/challenge/write-a-verifier): In RL from verifiable rewards, the verifier IS the reward — and a gameable one is worse than none, because every false positive is a lie the model learns. Write a verifier a reward-hacking agent can’t fool: recompute the score from ground truth, demand exact task coverage, and compare types-intact. Solve it in Python or TypeScript, with hidden tests.
- [Build Your Own Agent Loop](https://vibeengines.com/challenge/build-your-own-agent-loop): Strip an "AI agent" of its mystique and what’s left is a loop: read the model’s next move — tool call or final answer — run the tool, feed the observation back, repeat until it answers or the step cap trips. Implement the whole ReAct inner loop as one pure function. Solve it in Python or TypeScript, with hidden tests.
- [Spot the Bug in AI Code](https://vibeengines.com/challenge/spot-the-bug-in-ai-code): An assistant wrote a chat-history trimmer that looks right, passes the obvious case, and silently drops the system prompt the moment the conversation gets long. Reviewing AI code means catching exactly this: confident, plausible, wrong on the case that matters. Find the bug and fix it. Solve it in Python or TypeScript, with hidden tests.
- [Read the Codebase, Fix the Bug](https://vibeengines.com/challenge/code-comprehension-rpn): The skill an AI can’t fake for you: drop into unfamiliar code, trace how the pieces call each other, and fix the one that’s wrong without breaking the rest. A reverse-Polish calculator spread across three functions gets subtraction and division backwards — read the operand flow, then fix it at the source. Solve it in Python or TypeScript, with hidden tests.

## Paper Breakdowns
- [Attention Is All You Need](https://vibeengines.com/paper/attention-is-all-you-need): The paper that introduced the Transformer — the architecture underneath GPT, BERT, Claude, and Gemini. Self-attention, Query/Key/Value, multi-head attention, positional encoding, and the real BLEU results, explained in depth with analogies and animated visuals, not just equations.
- [BERT](https://vibeengines.com/paper/bert): The paper that made "pre-train once, fine-tune anywhere" the default for NLP. Bidirectional context, masked language modeling, next-sentence prediction, the [CLS]/[SEP] tokens, and the GLUE sweep — explained with analogies, not just equations.
- [Retrieval-Augmented Generation](https://vibeengines.com/paper/rag): The paper behind every "chat with your docs" product. Pair a generator with a neural retriever so the model looks knowledge up instead of memorizing it — dense retrieval, top-k documents, RAG-Sequence vs RAG-Token, and why retrieval cuts hallucination.
- [Chain-of-Thought Prompting](https://vibeengines.com/paper/chain-of-thought): Show a model a few worked examples with their reasoning and it starts solving problems it used to fail. Why reasoning emerges only at scale, the GSM8K jump, zero-shot "Let's think step by step", and how CoT seeded modern reasoning models.
- [LoRA](https://vibeengines.com/paper/lora): The paper that made fine-tuning affordable. Freeze the giant pretrained model and train two tiny low-rank matrices instead — up to 10,000x fewer trainable parameters, no extra inference latency, and swappable per-task adapters. The road to QLoRA and PEFT.
- [ReAct](https://vibeengines.com/paper/react): The blueprint for AI agents. Interleave reasoning with actions so a model can think, use a tool, observe the result, and think again — the Thought–Action–Observation loop that grounds reasoning, cuts hallucination, and underpins every tool-using agent.
- [Direct Preference Optimization](https://vibeengines.com/paper/dpo): RLHF without the RL. Align a model to human preference pairs with one simple classification-style loss — no separate reward model, no unstable reinforcement learning. Why "your LM is secretly a reward model", and how DPO became the default alignment method.
- [Chinchilla](https://vibeengines.com/paper/chinchilla): The compute-optimal scaling law that said models were too big. Parameters and training tokens should scale together — ~20 tokens per parameter — so a 70B model trained on 1.4T tokens beat the 280B giants. Why every model since trains on trillions of tokens.
- [FlashAttention](https://vibeengines.com/paper/flash-attention): Attention was slow for the wrong reason. By treating it as a memory-movement problem — tiling, online softmax, keeping work in fast SRAM instead of slow HBM — FlashAttention makes exact attention several times faster and cuts its memory from quadratic to linear, unlocking long context windows.
- [Mixture of Experts](https://vibeengines.com/paper/mixture-of-experts): How models got huge without getting slow. Many expert sub-networks plus a gating network that routes each token to just a few — so a model holds hundreds of billions of parameters but only activates a fraction per token. Gating, top-k routing, load balancing, and the road to Switch Transformer and Mixtral.
- [Word2Vec](https://vibeengines.com/paper/word2vec): How words became math. Dense word vectors learned from the company a word keeps, so king − man + woman lands near queen. Skip-gram, CBOW, the distributional hypothesis, and the origin of every embedding model powering search and RAG.
- [ResNet](https://vibeengines.com/paper/resnet): The skip connection that made deep learning deep. Why stacking layers made networks worse, and how residual learning let them reach 150+ layers and win ImageNet — the identity shortcut every Transformer still uses inside every block.
- [Diffusion Models](https://vibeengines.com/paper/diffusion-models): How AI paints from pure noise. Add noise to an image step by step until it's static, then train a network to reverse it and sculpt pictures out of chaos — the forward and reverse processes behind Stable Diffusion, DALL·E, and Midjourney.
- [CLIP](https://vibeengines.com/paper/clip): How AI learned to connect images and words. Train an image encoder and a text encoder together on 400M internet image-caption pairs so pictures and words share one space — enabling zero-shot classification and the text-to-image bridge behind modern generators.
- [GPT-3](https://vibeengines.com/paper/gpt-3): The paper that made models learn from the prompt. Scale a Transformer decoder to 175 billion parameters and a new behavior emerges — in-context learning: teach it a task with a few examples in the prompt, no fine-tuning, no weight updates. Zero-, one-, and few-shot prompting explained.
- [InstructGPT](https://vibeengines.com/paper/instructgpt): How RLHF taught models to follow instructions — the paper behind ChatGPT. The three-step recipe: supervised fine-tuning, a reward model learned from human rankings, and PPO reinforcement learning. A 1.3B aligned model beat 175B GPT-3 on human preference — alignment over scale.
- [Llama 2](https://vibeengines.com/paper/llama-2): The paper that opened up the LLM. Meta released a strong family of open-weight models — 7B, 13B, 70B — with chat alignment included. Pretraining on 2T tokens, grouped-query attention, and Llama 2-Chat's RLHF with separate helpfulness and safety reward models — the release that seeded the open-model ecosystem.
- [Scaling Laws](https://vibeengines.com/paper/scaling-laws): The physics of making models bigger. A language model's loss falls as a smooth power law in model size, dataset size, and compute — so performance is predictable before you train. Compute-optimal training, the forecast that justified GPT-3, and how Chinchilla later corrected the recipe.
- [T5](https://vibeengines.com/paper/t5): The model that turned every NLP task into text-to-text. One encoder-decoder Transformer, one loss, one format: translation, summarization, classification, and Q&A all become text-in, text-out. The C4 dataset, span-corruption pre-training, and a rigorous study of what drives transfer learning.
- [Vision Transformer (ViT)](https://vibeengines.com/paper/vision-transformer): When an image became 16×16 words. Cut a picture into patches, treat each patch as a token, and feed them to a plain Transformer — no convolutions. Patch embeddings, the class token, and why data scale lets attention beat the CNNs that ruled computer vision for a decade.
- [Latent Diffusion](https://vibeengines.com/paper/latent-diffusion): The paper behind Stable Diffusion. Compress an image into a small latent space with a VAE, run the diffusion denoising there instead of on pixels for a tens-of-times efficiency win, and steer it with text via cross-attention. The architecture that put text-to-image generation on consumer GPUs.
- [DDPM](https://vibeengines.com/paper/ddpm): The original denoising diffusion math — the paper that made diffusion work. A fixed forward process adds Gaussian noise over many steps; a U-Net learns the reverse. The masterstroke: train the network to simply predict the added noise with a plain MSE loss. The foundation under every modern image generator.
- [GANs](https://vibeengines.com/paper/gans): The counterfeiter and the detective. Two networks locked in a game: a generator forging fakes from noise and a discriminator trying to catch them. The minimax objective that taught machines to imagine, its notorious instabilities and mode collapse, and how diffusion later overtook it.
- [AlexNet](https://vibeengines.com/paper/alexnet): The paper that started the deep learning revolution. AlexNet won ImageNet 2012 by a landslide — cutting top-5 error from ~26% to ~15% — proving deep CNNs with big data and GPUs beat decades of hand-engineered features. ReLU, dropout, GPU training, and data augmentation, explained.
- [Seq2Seq](https://vibeengines.com/paper/seq2seq): Teaching neural nets to translate. An encoder LSTM reads an input sentence into a single fixed vector; a decoder LSTM writes the translation out. The architecture that made neural machine translation work — and whose fixed-vector bottleneck directly motivated the attention mechanism.
- [Mamba](https://vibeengines.com/paper/mamba): The linear-time challenger to attention. A selective state-space model that compresses history into a fixed-size state and scales linearly with sequence length — matching Transformers on language while being far cheaper on very long sequences. Selective SSMs, the recurrent/parallel duality, and hardware-aware design.
- [Whisper](https://vibeengines.com/paper/whisper): Robust speech recognition from the open web. An encoder-decoder Transformer trained on 680,000 hours of diverse, weakly-labeled web audio — transcribing and translating dozens of languages robustly, often zero-shot. The data bet, the multitask token format, and why scale beat clean supervision.
- [Segment Anything (SAM)](https://vibeengines.com/paper/segment-anything): A foundation model for cutting out objects. Point, click, or box anything in any image and SAM returns a precise mask — zero-shot. The image-encoder / prompt-encoder / mask-decoder design, and the data engine that bootstrapped SA-1B, a dataset of 1 billion masks.
- [DeepSeek-R1](https://vibeengines.com/paper/deepseek-r1): How a model learned to reason from reward alone. Reward only correct final answers and step-by-step chain-of-thought emerges on its own — including a spontaneous "aha moment" of self-correction. R1-Zero's pure RL, cold-start data, and cheap distillation of reasoning into small open models.
- [Toolformer](https://vibeengines.com/paper/toolformer): How a language model taught itself to use APIs. Toolformer learns, self-supervised, to call a calculator, search, QA, translation, and calendar — inserting API calls into text and keeping only the calls that make its next-word prediction better. The recipe that seeded modern tool-using AI agents.
- [GRPO (DeepSeekMath)](https://vibeengines.com/paper/grpo): The RL algorithm behind DeepSeek-R1. PPO needs a critic as large as the model itself; GRPO deletes it — sample a group of answers, score them, and reward whoever beats the group average. Half the memory, none of the critic's instability, and the engine that later made reasoning emerge from reward alone.
- [Titans](https://vibeengines.com/paper/titans): Models that memorize at test time. A neural long-term memory keeps learning during inference — writing what surprises it into its own weights, with momentum and adaptive forgetting — so attention handles the recent window while the memory holds the far past. Beats Transformers and Mamba on 2M+ token recall.
- [Constitutional AI](https://vibeengines.com/paper/constitutional-ai): Alignment from principles, not labels. Write the values down as a constitution, have the model critique and revise its own outputs against them, then run RL on AI-judged preferences (RLAIF) — harmlessness that scales with compute instead of crowds, and refuses without stonewalling. The backbone of Claude's alignment.
- [Self-Consistency](https://vibeengines.com/paper/self-consistency): Sample many diverse reasoning paths, marginalize out the reasoning, majority-vote the answer. Correct answers are attractors — many routes converge on them while scattered errors disagree. +17.9 points on GSM8K from a pure decoding change, and the first clean proof that inference compute is a quality dial.
- [Tree of Thoughts](https://vibeengines.com/paper/tree-of-thoughts): When LLMs learn to search. Frame problem-solving as a tree of intermediate "thoughts": propose candidates, self-evaluate their promise, expand with BFS/DFS, backtrack from dead ends. Game of 24 went 4% → 74% with the same GPT-4 — the inference procedure, not the model, was the ceiling.
- [QLoRA](https://vibeengines.com/paper/qlora): Fine-tune a 65B model on one GPU. Freeze the base in 4-bit NF4 (levels at the quantiles of a normal distribution), quantize the quantization constants, page optimizer spikes to CPU, and train 16-bit LoRA adapters on top — matching full 16-bit fine-tuning quality. Guanaco hit 99.3% of ChatGPT after 24h on a single card.
- [MemGPT](https://vibeengines.com/paper/memgpt): An operating system for LLM memory. Context window as RAM, external storage as disk, and the model as its own memory manager — paging facts in and out with function calls, revising core memories when facts change, and summarizing under memory pressure. The architecture behind modern agent memory (and Letta).
- [Reflexion](https://vibeengines.com/paper/reflexion): Agents that learn from their own mistakes — reinforcement through words instead of weights. Fail, write a verbal reflection on why, store it in episodic memory, retry with the lesson in context. Actor + Evaluator + Reflector took GPT-4 from 80% to 91% on HumanEval, and the pattern now lives inside every self-correcting agent.
- [Voyager](https://vibeengines.com/paper/voyager): The Minecraft agent that never stops learning. An automatic curriculum picks the next just-hard-enough goal, the agent writes code to achieve it, debugs against environment feedback, and saves every verified program to a compounding skill library. 3.3× more items, 15.3× faster tech tree — and the blueprint for agents that build their own tools.
- [Generative Agents](https://vibeengines.com/paper/generative-agents): The Smallville paper: 25 LLM characters living in a simulated town. A memory stream retrieved by recency × importance × relevance, reflection trees that turn events into beliefs, and plans that bend to interruptions — producing a Valentine's party that organized itself. The memory architecture behind modern persistent agents.
- [DeepSeek-V3](https://vibeengines.com/paper/deepseek-v3): Frontier performance at a tenth of the cost. A 671B MoE with 37B active, multi-head latent attention shrinking the KV cache ~10×, auxiliary-loss-free expert balancing, multi-token prediction, and FP8 training with zero loss spikes — 14.8T tokens for ≈$5.6M of compute. The paper that reset the industry’s cost assumptions.
- [Kimi K2](https://vibeengines.com/paper/kimi-k2): A trillion parameters built for agents. A 1T-param open MoE (32B active) trained through 15.5T tokens with ZERO loss spikes via MuonClip (Muon + QK-clip), plus large-scale synthesis of tool-use episodes so agentic behavior is pretrained, not bolted on. The moment open weights led on agent workloads.
- [Adam](https://vibeengines.com/paper/adam): The optimizer that trains almost every modern network. Momentum as the first moment, RMSProp as the second, and the bias correction most explanations skip — plus the famously robust defaults (0.9 / 0.999 / 1e-8) and AdamW. Built up from scratch with worked math and runnable code you can edit in the browser.
- [Dropout](https://vibeengines.com/paper/dropout): Randomly switch off half your neurons on every training step — and overfitting collapses. Why co-adaptation hurts, how inverted dropout scales survivors to keep expectations unchanged, and why the whole thing is secretly an ensemble of 2ⁿ networks. Worked math plus runnable code you can edit in the browser.
- [Batch Normalization](https://vibeengines.com/paper/batch-norm): The layer that made deep networks train fast and forgivingly. Normalize each feature across the batch to zero mean and unit variance, then a learnable scale and shift give the network its freedom back. Internal covariate shift, the train-vs-test running-statistics gotcha, and why it unlocks higher learning rates — worked math plus runnable code.
- [LayerNorm & RMSNorm](https://vibeengines.com/paper/layernorm-rmsnorm): The normalization inside every transformer. LayerNorm normalizes across one example’s features (batch-independent, unlike batch norm); RMSNorm drops the mean-centering to go faster. The exact invariances that separate them, and the tidy case where they’re mathematically identical — worked math plus runnable code.
- [Speculative Decoding](https://vibeengines.com/paper/speculative-decoding): Make a big model generate 2–3× faster with zero change to its output. A tiny draft model guesses several tokens ahead; the target verifies them all in one parallel pass and keeps the correct prefix. Why decoding is memory-bound, why the output is provably identical, and the expected-tokens math with its optimal draft length — worked math plus runnable code.
- [RoPE (RoFormer)](https://vibeengines.com/paper/rope-roformer): The position scheme inside LLaMA, GPT-NeoX, and most modern LLMs. Instead of adding a position vector, RoPE rotates query and key by an angle set by their position — and because rotations add, the attention score depends only on relative distance. The geometry, the per-dimension frequencies, and long-context scaling — worked math plus runnable code.
- [ColBERT](https://vibeengines.com/paper/colbert): Keep one vector per token, not one per document, and score by late interaction: each query token takes its best match anywhere in the document (MaxSim), summed. It recovers the term-level precision single-vector retrieval blurs away, at index-friendly speed. The math, the case where it clearly wins, and how it sits between dense and cross-encoder retrieval — with runnable code.
- [Sentence-BERT](https://vibeengines.com/paper/sentence-bert): The model that turned BERT into fast, comparable sentence embeddings — the ancestor of every embedding model behind vector search and RAG. Why plain BERT can’t be compared without a pass per pair, the siamese fix with mean pooling, and the O(n²)→O(n) arithmetic that took a task from 65 hours to 5 seconds. Worked math plus runnable code.
- [Switch Transformer](https://vibeengines.com/paper/switch-transformer): The mixture-of-experts model that scaled to 1.6 trillion parameters by routing each token to a single expert. Why top-1 routing simplifies MoE, the load-balancing auxiliary loss that keeps experts evenly used, expert capacity and token dropping, and how sparse activation decouples parameters from compute per token — worked math plus runnable code.
- [PagedAttention (vLLM)](https://vibeengines.com/paper/vllm-pagedattention): The idea that made LLM serving several times cheaper: store the KV cache in fixed-size blocks like an OS pages memory, instead of reserving each request’s maximum length. Why contiguous reservation wastes ~95% of the cache, how paging caps the waste to one block, copy-on-write prefix sharing, and the throughput vLLM unlocks — worked math plus runnable code.
- [Masked Autoencoders](https://vibeengines.com/paper/mae): BERT for images, finally working. Mask 75% of an image’s patches, encode only the visible quarter with a ViT, and reconstruct the missing pixels with a light decoder. Why images need such a high mask ratio, the asymmetric design that makes the encoder ~16× cheaper, and the strong transfer results — worked math plus runnable code.
- [SimCLR](https://vibeengines.com/paper/simclr): Contrastive learning that rivaled supervised vision with no labels. Two augmented views of an image are a positive pair against a batch of negatives; the NT-Xent loss pulls positives together and pushes negatives apart. The temperature, why augmentation and big batches are decisive, and how contrastive compares to masked pre-training — worked math plus runnable code.
- [Longformer](https://vibeengines.com/paper/longformer): The attention pattern that let transformers read long documents. Full self-attention is quadratic, so it caps out around 512 tokens; Longformer’s sliding window makes it linear in length, with dilation and depth for reach and a few global tokens for the big picture. The sparsity math and receptive-field growth — worked math plus runnable code.
- [Medusa](https://vibeengines.com/paper/medusa): Speculative decoding without a separate draft model. Medusa bolts extra prediction heads onto the model, each guessing a token further ahead, and verifies many candidate continuations in one pass via tree attention. Why head accuracy fades with distance, the tokens-per-pass math, and the trade-offs vs draft-model speculation — worked math plus runnable code.
- [Let's Verify Step by Step](https://vibeengines.com/paper/lets-verify-step-by-step): Reward every reasoning step, not just the final answer. Process reward models beat outcome reward models at judging hard math — they catch right-answer/wrong-reasoning, localize the failing step, and rerank many candidate solutions to pick sound ones. The process-vs-outcome math and the PRM800K dataset — worked math plus runnable code.
- [Product Quantization](https://vibeengines.com/paper/product-quantization): The compression that makes billion-scale vector search fit in memory. Split a vector into subvectors, quantize each with a 256-entry codebook, and store a 512-byte vector in 8 — while m small codebooks span k^m codes. The compression math, asymmetric distance lookups, and IVFPQ — worked math plus runnable code.
- [GraphRAG](https://vibeengines.com/paper/graphrag): RAG for the global questions vector retrieval can't answer. GraphRAG builds a knowledge graph from the corpus, detects communities of related entities, summarizes each, and map-reduces those summaries — so "what are the main themes across everything?" gets a comprehensive answer. Why top-k retrieval under-covers global queries, and the graph pipeline — worked math plus runnable code.
- [Textbooks Are All You Need (Phi)](https://vibeengines.com/paper/phi): A 1.3B model trained on curated, textbook-quality data rivaled models 10× larger. Data quality, not just scale, drives capability — a small clean dataset can carry more effective signal (tokens × quality) than a giant noisy one, and the small model is far cheaper to run. The effective-signal argument, compute math, and caveats — worked math plus runnable code.
- [Transformer-XL](https://vibeengines.com/paper/transformer-xl): The transformer that broke the fixed-context limit. Segment-level recurrence caches the previous segment's hidden states so context grows with depth, and relative positional encoding makes the recurrence coherent. Why vanilla transformers fragment context, how the cache reaches thousands of tokens back, and the ~1,800× evaluation speedup — worked math plus runnable code.
- [Ring Attention](https://vibeengines.com/paper/ring-attention): Context that scales with the number of devices. Shard the sequence across a ring, rotate the key/value blocks around it so every query sees every key, and per-device memory stays O(N/P) — with communication hidden behind computation. Exact dense attention, no approximation, pushing context into the millions. The rotation and overlap math — worked math plus runnable code.
- [Muon](https://vibeengines.com/paper/muon): The optimizer that orthogonalizes weight-matrix updates instead of scaling them element-wise like Adam. Pushing every singular value of the momentum to 1 spreads learning across all directions, done cheaply with Newton-Schulz iteration (matmuls, no SVD). Why it pairs with Adam for 1D params, and how it scaled to trillion-parameter training — worked math plus runnable code.
- [Flamingo](https://vibeengines.com/paper/flamingo): The visual language model that bridges a frozen vision encoder and a frozen LLM with a small trained connector. A Perceiver Resampler compresses each image into a fixed set of tokens, and gated cross-attention (tanh gate initialized at 0) injects them without breaking the language model — enabling few-shot multimodal in-context learning. The resampler and gating math — worked math plus runnable code.
- [DINOv2](https://vibeengines.com/paper/dinov2): Label-free visual features by self-distillation: a student learns to match a teacher that is an EMA of itself, with centering and sharpening to prevent collapse. DINOv2 scaled this with curated data into a general vision backbone that works frozen across detection, segmentation, and depth. The self-distillation loop and anti-collapse math — worked math plus runnable code.
- [3D Gaussian Splatting](https://vibeengines.com/paper/gaussian-splatting): Real-time photorealistic radiance fields. Represent a scene as millions of 3D Gaussians and render by projecting and alpha-compositing them front-to-back — fast rasterization instead of NeRF's slow ray-marching, hitting 100+ FPS. The compositing equation (C = Σ cᵢαᵢTᵢ), the differentiable optimization that fits Gaussians to photos, and why explicit beats implicit — worked math plus runnable code.
- [NeRF](https://vibeengines.com/paper/nerf): The paper that launched the radiance-field era. Store a 3D scene as a small MLP mapping (position, direction) → (color, density), and render photorealistic novel views by volume rendering along rays. The rendering integral (α = 1 − exp(−σδ), C = Σ Tᵢαᵢcᵢ), why positional encoding unlocks sharp detail, and how it set up Gaussian Splatting — worked math plus runnable code.
- [LLaVA](https://vibeengines.com/paper/llava): Visual instruction tuning the simple way. Connect CLIP to an LLM with a single linear projection, prepend the image tokens to the prompt, and instruction-tune on data a text-only GPT-4 generated — a capable visual assistant on a shoestring. The minimal connector (a matrix, <0.1% of the LLM), the synthetic-data trick, and two-stage training — worked math plus runnable code.
- [STaR](https://vibeengines.com/paper/star): A model teaching itself to reason. STaR generates chain-of-thought rationales, keeps only the ones that reach the correct answer, fine-tunes on them, and repeats — bootstrapping reasoning from question-answer pairs alone. Rationalization (hinting the answer) rescues hard problems. The self-improvement loop, foreshadowing RL-trained reasoning models — worked math plus runnable code.
- [AlphaGo](https://vibeengines.com/paper/alphago): The system that beat a Go world champion by fusing Monte Carlo Tree Search with deep networks: a policy network to propose moves and a value network to judge positions. How PUCT selection balances exploiting good moves against exploring promising ones, the supervised-then-self-play training, and the test-time-search idea it seeded — worked math plus runnable code.
- [MuZero](https://vibeengines.com/paper/muzero): Planning without knowing the rules. MuZero learns its own model — representation, dynamics, and prediction networks — and runs tree search entirely in a learned latent space, so it works where no simulator exists (like Atari). The three networks, the value-equivalence idea (a model trained to be useful for planning, not to reconstruct observations), and the n-step return — worked math plus runnable code.
- [AlphaFold 2](https://vibeengines.com/paper/alphafold-2): The system that solved the 50-year protein-folding problem — by reading evolution. Residues that touch in a folded protein mutate together across related sequences, so covarying columns of a multiple-sequence alignment reveal 3D contacts; the Evoformer refines them with attention and a structure module predicts coordinates. The coevolution insight, the Evoformer, and pLDDT confidence — worked math plus runnable code.
- [Codex](https://vibeengines.com/paper/codex): The GPT-on-code model behind GitHub Copilot — and the evaluation it standardized. Codex introduced HumanEval and pass@k: grade generated programs by whether they pass the unit tests, and measure the chance at least one of k samples works. The unbiased pass@k estimator (1 − C(n−c,k)/C(n,k)) and why sampling helps — worked math plus runnable code.
- [SWE-bench & SWE-agent](https://vibeengines.com/paper/swe-agent): Can a model do real software engineering? SWE-bench grades models on resolving actual GitHub issues — the patch must apply, make the failing tests pass, and break no passing tests. SWE-agent gives the model an Agent-Computer Interface (search/open/edit/run) built for the model, not humans. The strict resolution rule and why the interface matters — worked math plus runnable code.
- [AlphaCode](https://vibeengines.com/paper/alphacode): Median-human competitive programming by scale plus selection. AlphaCode samples millions of candidate programs, filters out those that fail the example tests, clusters the survivors by behavior, and submits a few representatives from the largest clusters — consensus as majority vote over code. The sample-filter-cluster pipeline and why it works — worked math plus runnable code.
- [Llama 3](https://vibeengines.com/paper/llama-3): A herd of open dense transformers trained far past the Chinchilla point. Llama 3 deliberately over-trains its smaller models on ~15 trillion tokens — nearly 100× the compute-optimal count — because a model is trained once but served billions of times, so inference, not training, dominates the lifetime bill. The training-optimal versus inference-optimal trade-off, with worked math and runnable code.
- [Gemini 1.5](https://vibeengines.com/paper/gemini-1-5): A million-token context window with near-perfect needle-in-a-haystack recall. Gemini 1.5, a sparse mixture-of-experts model, can retrieve a fact hidden anywhere in up to 1M (research: 10M) tokens — because its usable attention span covers the whole window (W ≥ L), where a limited window drops every early needle. Why long context is hard, why it is expensive, and how to test it — worked recall condition plus runnable code.
- [Sora](https://vibeengines.com/paper/sora): Text-to-video by treating video as a diffusion transformer over spacetime patches. Sora compresses a video into a latent volume, cuts it into patches — one token each — and denoises the sequence, so resolution, aspect ratio, and duration are all just different patch counts. Why that unifies any shape into one model, and why patch count (linear in duration, quadratic in resolution) sets the compute — worked math plus runnable code.
- [V-JEPA](https://vibeengines.com/paper/v-jepa): A self-supervised video world model that predicts in representation space, not pixels. V-JEPA masks regions of a video and predicts their features (encoder outputs) rather than reconstructing pixels — so the target drops the unpredictable detail a reconstruction loss is forced to model. Why abstraction beats reconstruction, and how a stop-gradient EMA target encoder avoids representation collapse — worked math plus runnable code.
- [RT-2](https://vibeengines.com/paper/rt-2): A Vision-Language-Action model that controls a robot by emitting actions as text tokens. RT-2 discretizes each dimension of a continuous action into bins — one vocabulary token per dimension — so a web-pretrained vision-language model co-trains on internet data and robot trajectories and its semantic knowledge transfers to control, generalizing to objects and commands never seen in robot data. Action-as-token, quantization precision, and emergent generalization — worked math plus runnable code.
- [Genie](https://vibeengines.com/paper/genie): A generative interactive environment that turns an image into a frame-by-frame playable world — trained on unlabeled video with no action labels. A latent action model infers a small discrete set of actions from consecutive frames, and a dynamics model turns them into control, so a tiny codebook forces consistent, reusable latent actions to emerge unsupervised. Latent-action inference and controllable generation — worked math plus runnable code.
- [PaLM](https://vibeengines.com/paper/palm): A 540-billion-parameter dense model trained with Pathways that made emergent abilities concrete. Some capabilities stay near chance until scale crosses a threshold, then jump sharply — because a task needing k sequential correct steps scores p^k, so a smooth per-step improvement becomes a sudden task-level breakthrough. Compositional emergence, why harder tasks emerge later, and what Pathways enabled — worked math plus runnable code.
- [Qwen3](https://vibeengines.com/paper/qwen3): An open model family that unifies a thinking mode (chain-of-thought) and a non-thinking mode (direct answer) in one model, with a controllable thinking budget. Since thinking gains saturate and help hard queries far more than easy ones, gating reasoning on difficulty — skip easy, spend the budget on hard — maximizes accuracy per token, beating always-think and never-think. The test-time-compute trade-off as a dial — worked math plus runnable code.
- [Dense Passage Retrieval](https://vibeengines.com/paper/dpr): The dual-encoder method that made dense retrieval beat BM25 for open-domain QA. DPR encodes questions and passages into a shared vector space and matches by dot product; its efficiency trick is in-batch negatives — a batch of B pairs yields a B×B similarity matrix whose diagonal is the positive and whose off-diagonal gives B×(B−1) negatives for free. Why matching on meaning beats keywords, and how the free-negatives trick trains it — worked math plus runnable code.
- [HNSW](https://vibeengines.com/paper/hnsw): The graph index behind fast approximate nearest-neighbor search — the default in nearly every vector database. HNSW wires points into a navigable small-world graph and searches it greedily (hop to the neighbor closest to the query), organized into a skip-list-style hierarchy of layers whose height grows like ln(N) — so search is O(log N) instead of O(N). Greedy navigation, the exponential level assignment, and why squaring the dataset only doubles the layers — worked math plus runnable code.
- [GPT-4 Technical Report](https://vibeengines.com/paper/gpt-4-report): The report is famous for what it withholds, but its key methodological claim is predictable scaling: OpenAI predicted GPT-4's final loss from models trained with up to ~1000× less compute by fitting a power law and extrapolating. Why loss falls as a smooth power law you can fit on cheap small runs and extend across a huge compute gap — turning a giant, risky training run into an engineering forecast — and where capability prediction still breaks. Worked math plus runnable code.
- [OpenAI o1](https://vibeengines.com/paper/o1-system-card): The reasoning model trained with reinforcement learning to think before it answers — and the discovery of a second scaling axis. For a fixed model, accuracy rises roughly log-linearly with test-time (inference) compute: each ×10 in thinking buys a fixed accuracy step, so reaching a higher accuracy costs a multiplicative jump in compute. Reasoning as search under a budget, the inference-scaling law, and its exponential price — worked math plus runnable code.
- [VAE](https://vibeengines.com/paper/vae): The Variational Autoencoder — how to turn a compressor into a generator. A plain autoencoder's latent space is full of holes you can't sample; the VAE encodes each input to a Gaussian cloud and pulls all the clouds toward a standard-normal prior, making the space smooth and samplable. Trained by maximizing the ELBO (reconstruction minus KL), with the KL in closed form and the reparameterization trick z = μ + σ·ε making sampling differentiable. The foundation of the latent space under latent diffusion — worked math plus runnable code.
- [PPO](https://vibeengines.com/paper/ppo): Proximal Policy Optimization — the RL algorithm behind RLHF. Naive policy gradients take steps that collapse the policy; PPO caps the step with a clipped surrogate objective, min(r·A, clip(r, 1−ε, 1+ε)·A), where r = π_new/π_old is the probability ratio and A the advantage. Once the ratio leaves the trust region 1±ε in the helpful direction the objective flattens — TRPO-level stability from a first-order clip, no hard constraint. The optimizer InstructGPT and RLHF pipelines used. Worked math plus runnable code.
- [DQN](https://vibeengines.com/paper/dqn): The Deep Q-Network that learned Atari from raw pixels and launched deep reinforcement learning. A neural net approximates the Q-function, trained toward the Bellman target y = r + γ·max Q(s′,a′) — immediate reward plus discounted best future value (just r on a terminal step). Two stabilizers made neural Q-learning trainable: experience replay (random minibatches from a buffer break frame correlation) and a frozen target network (a stationary goal so the net doesn't chase itself). The ancestor of AlphaGo and modern deep RL. Worked math plus runnable code.
- [Classifier-Free Guidance](https://vibeengines.com/paper/classifier-free-guidance): The "guidance scale" slider behind every diffusion image tool. A conditional diffusion model predicts the noise twice each step — with the prompt (ε_cond) and without it (ε_uncond) — then extrapolates: ε = (1+w)·ε_cond − w·ε_uncond, equivalently ε_uncond + (1+w)·(ε_cond − ε_uncond). w=0 is plain conditioning, larger w pushes further along the conditional direction for tighter prompt-following (too far → over-saturation). No separate classifier — trained with condition-dropout — and the source of negative prompts. Worked math plus runnable code.
- [Knowledge Distillation](https://vibeengines.com/paper/knowledge-distillation): How to compress a big, accurate "teacher" into a small, fast "student" — by training on the teacher's soft probability distribution, not just the hard label. A one-hot label is a thin signal; the teacher's full distribution encodes "dark knowledge" (a 2 looks a bit like a 7, nothing like a cat). The trick: a temperature-scaled softmax, p_i = exp(z_i/T) / Σ exp(z_j/T), softens the distribution as T grows so those tiny wrong-class probabilities become a strong training signal — without ever changing the top class. The student minimizes KL to the softened teacher plus cross-entropy on the labels. The "Distil" in DistilBERT and a first-line model-compression tool. Worked math plus runnable code.
- [VQ-VAE](https://vibeengines.com/paper/vq-vae): The autoencoder that made the latent DISCRETE — and quietly became the tokenizer behind image generation. The encoder outputs a continuous vector, but it is quantized to the nearest entry in a learned codebook {e_1..e_K}: k = argmin_j ‖z_e − e_j‖², so each latent position becomes one of K discrete tokens. The non-differentiable argmin is trained with a straight-through estimator (copy the decoder gradient back to the encoder), plus a three-part loss: reconstruction + codebook ‖sg[z_e]−e‖² + β·commitment ‖z_e−sg[e]‖². Discrete codes let a Transformer or diffusion prior model images/audio as tokens — the lineage behind VQ-VAE-2, DALL·E, and VQGAN. Worked math plus runnable code.
- [Graph Neural Networks](https://vibeengines.com/paper/graph-neural-networks): How a neural network learns on graphs — molecules, social networks, citation webs — where a convolution has nothing to slide over. The Graph Convolutional Network reduces it to message passing: each node updates itself by mixing its own feature with a degree-normalized average of its neighbors. One layer is H' = σ( H W) with  = D̃^(-1/2)(A+I)D̃^(-1/2) — self-loops (A+I) keep a node's own feature and the symmetric normalization stops high-degree hubs from dominating. Stack layers to reach further; too deep and features over-smooth. The template (gather, aggregate, update) behind GraphSAGE and GAT — and attention is message passing on a fully connected graph. Worked math plus runnable code.
- [GloVe](https://vibeengines.com/paper/glove): Word vectors from GLOBAL co-occurrence statistics — the count-based cousin of word2vec. Build a co-occurrence matrix X (X_ij = how often word j appears in the context of word i), then learn vectors so a dot product recovers the LOG count: w_i·w̃_j + b_i + b̃_j ≈ log(X_ij). The insight: co-occurrence RATIOS (P(solid|ice)/P(solid|steam)) carry meaning, and taking logs turns multiplicative ratios into differences a vector space represents — which is why king−man+woman≈queen works. Fit with weighted least squares, J = Σ f(X_ij)(…−log X_ij)², where f(x)=(x/xmax)^0.75 caps frequent pairs and f(0)=0 skips the empty matrix. The standard pretrained word embedding for years. Worked math plus runnable code.
- [The Lottery Ticket Hypothesis](https://vibeengines.com/paper/lottery-ticket-hypothesis): The finding that a dense, randomly-initialized network hides a small "winning ticket" — a sparse subnetwork that, trained in isolation FROM THE SAME INITIAL WEIGHTS, matches the full model's accuracy. You find it by iterative magnitude pruning: train, drop the smallest-magnitude weights (a binary mask), RESET survivors to their original init, repeat. The famous twist: randomly reinitializing the same sparse structure trains worse — structure and lucky initialization are entangled. After k rounds at prune fraction p, only (1−p)^k of the weights remain. A new lens on why over-parameterization helps, and the seed of sparse-training research. Worked math plus runnable code.
- [DDIM](https://vibeengines.com/paper/ddim): Denoising Diffusion Implicit Models — the trick that made diffusion sampling deterministic and 10–50× faster, using the SAME trained DDPM network (no retraining). Each step predicts the clean image x̂0 = (x_t − √(1−ᾱ_t)·ε)/√ᾱ_t, then re-projects to an earlier step: x_{t−1} = √ᾱ_{t−1}·x̂0 + √(1−ᾱ_{t−1}−σ²)·ε + σ·z. A single knob σ = η·√((1−ᾱ_{t−1})/(1−ᾱ_t))·√(1−ᾱ_t/ᾱ_{t−1}) unifies the two samplers: η=1 recovers stochastic DDPM, η=0 gives σ=0 and the deterministic DDIM that can skip timesteps. Determinism unlocks reproducibility, latent interpolation, and DDIM inversion for editing — and reframed sampling as an ODE. Worked math plus runnable code.
- [Self-Instruct](https://vibeengines.com/paper/self-instruct): How to bootstrap a large instruction-tuning dataset from a language model's OWN generations, starting from just 175 human-written seed tasks. The generate→filter→add loop: sample existing tasks as examples, prompt the model to write new instructions + input/output instances, filter, add survivors back, repeat — 175 seeds bloom into ~52K diverse tasks. The quantitative heart is a diversity filter: keep a new instruction only if its ROUGE-L similarity (longest-common-subsequence overlap) to every existing one is below 0.7, so the pool never collapses into near-duplicates. The seed of Alpaca and the open instruction-tuning wave, and a landmark in synthetic data. Worked math plus runnable code.
- [mixup](https://vibeengines.com/paper/mixup): The two-line data augmentation that trains on CONVEX COMBINATIONS of example pairs — blending both inputs and labels: x̃ = λ·x_i + (1−λ)·x_j, ỹ = λ·y_i + (1−λ)·y_j, with λ ~ Beta(α,α). A 70/30 blend of a cat and a dog is trained with the soft label "0.7 cat, 0.3 dog." This "vicinal risk minimization" makes the network behave linearly between training points, smoothing its decision boundary. The payoffs, for near-zero cost and no architecture change: better generalization, honest calibration, resistance to label noise, and adversarial robustness. A default augmentation for ResNets and ViTs (often with CutMix). Worked math plus runnable code.
- [AlphaZero](https://vibeengines.com/paper/alphazero): The single algorithm that mastered Go, chess, and shogi from ZERO human data — pure self-play, same code for all three. A single deep net outputs a policy prior P(s,a) and a value v(s); Monte Carlo Tree Search uses them to look ahead, selecting moves by the PUCT rule: maximize Q(s,a) + c·P(s,a)·√(ΣN)/(1+N(s,a)) — exploit the mean value Q, explore high-prior under-visited moves via the bonus that fades with visits. Search yields an improved policy (visit counts), self-play yields outcomes z, and both train the net (loss = (z−v)² − π·log p). Generalized AlphaGo into a domain-agnostic recipe; the seed of MuZero and the self-play-plus-search paradigm. Worked math plus runnable code.
- [wav2vec 2.0](https://vibeengines.com/paper/wav2vec2): Self-supervised speech: learn from raw, untranscribed audio, then fine-tune on as little as TEN MINUTES of labels. A CNN encodes the waveform into latent frames; a span is masked; a Transformer context net must identify each masked frame's TRUE quantized latent among K distractors via a contrastive InfoNCE loss (cosine similarity / temperature): L = −log[exp(sim(c,q_true)/κ) / Σ exp(sim(c,q̃)/κ)]. Targets are discretized through a learned codebook (product quantization + Gumbel-softmax) so the model discovers phone-like units. Brought BERT-style masked pretraining and CLIP-style contrastive learning to audio; the basis of HuBERT and multilingual XLS-R. Worked math plus runnable code.
- [DeepSeek-V4](https://vibeengines.com/paper/deepseek-v4): The efficiency sequel to V3, aimed at the real cost of long context. A ~1.6T-parameter MoE (only ~49B active per token) that serves a 1M-token window at roughly a tenth of V3.2's KV cache. The mechanism is one idea on two faces — HYBRID sparse attention: compress each token's keys/values into a small latent (memory per token: ratio = d_c/width, context-invariant), then SELECT only the top-k blocks of size b to score against, freezing the scored-key count at k·b once n>k·b while dense attention keeps paying O(n²). The two discounts multiply: FLOPs ratio = (k·b/n)·(d_c/width). Reasoning is post-trained with ON-POLICY DISTILLATION — the student generates its own trajectories and a stronger teacher corrects those exact outputs — replacing R1's large-scale RL loop with a denser, more stable signal. Worked math plus runnable code.
- [Kimi K3](https://vibeengines.com/paper/kimi-k3): The sequel to Kimi K2, and a different bet: attack decode SPEED, not KV memory. A ~2.8T open MoE with a 1M-token context — reported as the largest open model to date — built on KIMI DELTA ATTENTION (KDA), a linear-attention delta rule. Softmax attention re-reads the whole KV cache every decode step (O(n) per token, so generation slows as context grows); KDA folds the past into ONE fixed-size recurrent state S (~d×d) and reads o=S·q in constant time regardless of length. The DELTA rule (S ← S − β·(S·k − v)·kᵀ) makes each write CORRECTIVE — overwrite a key's old value instead of accumulating it — which is what plain linear attention gets wrong (write (k,a) then (k,b): delta reads b, linear reads a+b, smeared). ATTENTION RESIDUALS keep a minority of full-attention layers for the sharp exact recall a fixed state blurs — a hybrid, not a wholesale swap. Worked math plus runnable code.
- [LLMs Get Lost in Multi-Turn Conversation](https://vibeengines.com/paper/llms-lost-multi-turn): The ICLR 2026 Outstanding Paper that measured a failure everyone had felt: give a top model a fully-specified task in ONE prompt (concat) and it shines; split the IDENTICAL requirements across several turns (sharded) and 15 leading LLMs fall apart — ~39% average drop. The decomposition is the punchline: APTITUDE (best-case ability) barely moves, but RELIABILITY craters — the spread between a model's best and worst runs roughly DOUBLES. The mechanism is premature commitment: handed partial info, the model guesses a full answer early, locks it in, and when a later turn contradicts it "gets lost and does not recover." A small decay model captures the shape — concat R=p (flat), sharded R=p·(1−q)^(turns−1) (geometric decay), so longer chats get less reliable and the whole loss lives in a reliability term while the ceiling p is untouched. Fixes: front-load the spec, or consolidate/recap a long chat back into one fresh full-spec message. Worked math plus runnable code.
- [Engram](https://vibeengines.com/paper/engram): The memory half of the long-context problem. Softmax attention answers a query by spreading a fixed probability budget over ALL tokens, so as the haystack grows the needle dilutes and recall degrades — you pay O(n) AND lose accuracy. Engram bolts a KEY-ADDRESSED memory onto the model: write a fact under a key, retrieve it in constant time O(1) regardless of context length, no scan and no dilution (a Python dict IS the abstraction). It is CONDITIONAL — a lightweight gate decides whether a position needs a long-range recall, so local tokens pay nothing and only recall tokens incur one O(1) lookup. Because retrieval is by identity not by out-competing every other token, needle-in-a-haystack recall stops falling with length (reported ~84.2→97). Underpins DeepSeek-V4 (cheap context that stays accurate); same explicit-memory family as Titans and MemGPT, baked into the model not bolted on by a harness. Worked math plus runnable code.
- [Qwen4-Coder](https://vibeengines.com/paper/qwen4-coder): An open, Apache-2.0 coding model that reportedly hits ~82% on SWE-Verified while running on a MacBook — the first open, Mac-runnable model past 80% there. The enabler is the mixture-of-experts SHAPE, not a bigger model: ~32B total parameters but only ~3B active per token, which splits the two costs everyone conflates. STORAGE is set by total params (all experts must be RAM-resident since the router may pick any) — 32B at 4-bit ≈ 16GB, fits a 24GB Mac (fp16 would be 64GB and fail); quantization is what makes it a laptop model. SPEED is set by ACTIVE params (decode is bandwidth-bound and reads only the routed ~3B experts) — so a 32B model decodes at 3B throughput. The mental model: "does it fit?" is answered by total×bits÷8; "is it fast enough?" by active params vs bandwidth — dense models tie these together, MoE pulls them apart. Sequel to Qwen3; validates the local-first coding-agent stack. Worked math plus runnable code.
- [GPT-5.6 System Card](https://vibeengines.com/paper/gpt-5-6-system-card): A modern system card is really a COMPUTE-ALLOCATION POLICY, not one model. TIERED ROUTING (reported Sol/Terra/Luna) sorts each query by difficulty — cheap fast tier by default, escalate the hard cases (the cascade cost math lives in the model-routing handbook — linked, not re-derived). ULTRA MODE spends test-time compute in PARALLEL: run several independent agents (reported 4) on the hardest task and a VERIFIER keeps any that solves, so the solve rate is 1−(1−p)^N. The fresh angle = why FOUR, not forty: the marginal value of the N-th agent is Δ(N)=(1−p)^(N−1)·p — geometric decay (p=0.6: +0.60/+0.24/+0.10/+0.04) while cost is linear in N, so there's a knee. Runnable proves best-of-N rises, marginal=(1−p)^(N−1)·p, diminishing returns, 4th≪1st, value/cost decreasing, and finds the knee. PREPAREDNESS: safety case must cover the STRONGEST config (top tier + full ultra), not the cheap default. Cross-links o1-system-card (scaling curve) + model-routing/ai-cost-engineering + self-consistency. Worked math plus runnable code.
- [Concept Circuits](https://vibeengines.com/paper/concept-circuits): The foundation of mechanistic interpretability — how to read a model. Neurons are POLYSEMANTIC (one unit fires for green AND legal text AND Python) because the model stores concepts as DIRECTIONS spread across many neurons, not one-per-neuron. SUPERPOSITION: a d-dim space holds only d orthogonal directions but VASTLY more near-orthogonal ones, so a model packs in more features than dimensions and accepts small interference (interference(i,j)=feature_i·feature_j: orthogonal=0, superposed small-nonzero; 3 unit vecs at 120° in 2-D → pairwise dot −0.5). It works because features are SPARSE — few active at once, so collisions rarely bite and a lone active feature reads back cleanly. ATTRIBUTION GRAPHS trace which features caused an output (contribution = output-direction · feature-direction) and chain them across layers into a CIRCUIT. Runnable proves orthonormal self=1/cross=0, 3 features in 2-D, unit length preserved, interference bounded 0.5, clean sparse readout. First interp content sitewide; pairs the coming mech-interp-for-engineers handbook. Worked math plus runnable code.

## Roadmaps
- [Prompt Engineering Roadmap](https://vibeengines.com/roadmap/prompt-engineering): A visual transit-map roadmap from tokens and CRISP through chain-of-thought, RAG, and agent prompting to production monitoring. 18 stations across 3 tracks — interactive, free, your own pace.
- [Data Structures & Algorithms Roadmap](https://vibeengines.com/roadmap/dsa-roadmap): A visual transit-map roadmap from Big-O and arrays through hashing, sorting, and trees to graphs, Dijkstra, A*, and dynamic programming. 18 stations across 3 tracks — seven of them fully playable. Interactive, free, your own pace.
- [AI Engineer Roadmap](https://vibeengines.com/roadmap/ai-engineer): A visual transit-map roadmap to become an AI engineer in 2026. From how LLMs work through embeddings, RAG, agents, and fine-tuning to evals, guardrails, inference serving, and observability. 18 stations across 3 tracks — Foundations, Build, Production.
- [MLOps Roadmap](https://vibeengines.com/roadmap/mlops): A visual transit-map roadmap for MLOps in 2026. From reproducibility, data versioning, and experiment tracking through training pipelines and model serving to monitoring, drift, governance, and LLMOps. 18 stations across 3 tracks — Foundations, Pipelines, Operations.
- [System Design Roadmap](https://vibeengines.com/roadmap/system-design): A visual transit-map roadmap for system design in 2026. From APIs, databases, caching, and load balancing through sharding, queues, consistent hashing, and consensus to end-to-end designs of Twitter, YouTube, and Uber. 18 stations across 3 tracks — Fundamentals, Building Blocks, Real Systems.
- [Generative AI Roadmap](https://vibeengines.com/roadmap/genai): A visual transit-map roadmap for generative AI in 2026. From how text and images are generated through diffusion, multimodal, sampling, and fine-tuning to evaluating, securing, and shipping generative products. 18 stations across 3 tracks — Foundations, Techniques, Production.
- [Backend Engineer Roadmap](https://vibeengines.com/roadmap/backend-engineer): A visual transit-map roadmap to become a backend engineer in 2026. From HTTP APIs, SQL, NoSQL, caching, and auth through API design, message queues, testing, and observability to Kubernetes, CI/CD, sharding, and reliability. 18 stations across 3 tracks — Foundations, Core Backend, Production.
- [Frontend Engineer Roadmap](https://vibeengines.com/roadmap/frontend-engineer): A visual transit-map roadmap to become a frontend engineer in 2026. From HTML, CSS, layout, and JavaScript through TypeScript, React, state, and data fetching to bundlers, rendering, Core Web Vitals, and deployment. 18 stations across 3 tracks — Foundations, Core Frontend, Production.
- [DevOps Roadmap](https://vibeengines.com/roadmap/devops): A visual transit-map roadmap to become a DevOps engineer in 2026. From Linux, networking, Git, and Docker through CI/CD, Terraform, Kubernetes, and secrets to observability, SRE, GitOps, and cost. 18 stations across 3 tracks — Foundations, Core DevOps, Production.
- [Data Engineer Roadmap](https://vibeengines.com/roadmap/data-engineer): A visual transit-map roadmap to become a data engineer in 2026. From SQL, Python, and data modeling through Spark, Kafka, Airflow, and dbt to data quality, governance, partitioning, and CDC. 18 stations across 3 tracks — Foundations, Core Data, Production.
- [Machine Learning Roadmap](https://vibeengines.com/roadmap/machine-learning): A visual transit-map roadmap to become a machine learning engineer in 2026. From math and feature engineering through regression, trees, neural networks, CNNs, and transformers to experiment tracking, MLOps, drift, and responsible AI. 18 stations across 3 tracks — Foundations, Core ML, Production.
- [Cloud / AWS Roadmap](https://vibeengines.com/roadmap/cloud-aws): A visual transit-map roadmap to learn cloud engineering on AWS in 2026. From EC2, S3, VPC, and IAM through serverless, containers, IaC, and messaging to Well-Architected, multi-region, cost optimization, and DevOps. 18 stations across 3 tracks — Foundations, Core AWS, Production.
- [AI Harness Roadmap](https://vibeengines.com/roadmap/ai-harness-engineer): A visual transit-map roadmap to build an AI harness — the runtime around a model that turns it into an agent. From the messages API, tokens, and structured output through tool calling, the agent loop, context management, memory, and sandboxing to permissions, subagents, evals, observability, and cost control. 18 stations across 3 tracks — Model I/O, the Agent Loop, Production.
- [Forward-Deployed Engineer Roadmap](https://vibeengines.com/roadmap/forward-deployed-engineer): A visual transit-map roadmap to the most in-demand AI role of 2026 — the engineer who ships AI where the customer lives. From rapid prototyping, enterprise RAG and integration glue through discovery, customer data wrangling, VPC deployment, security reviews and client evals to stakeholder craft, incidents, proving ROI, and scaling pilots into repeatable production. 18 stations across 3 tracks — The Craft, The Field, The Outcome.
- [Security Engineer Roadmap](https://vibeengines.com/roadmap/security-engineer): A visual transit-map roadmap to a security engineering career — from breaking systems to defending them. From the security mindset, cryptography, identity and web vulnerabilities through threat modeling, offensive security, cloud and container security, detection and incident response to DevSecOps, zero trust, securing AI/LLM systems and GRC. 18 stations across 3 tracks — Foundations, Offense & Defense, Modern Frontiers.
- [Platform Engineer Roadmap](https://vibeengines.com/roadmap/platform-engineer): A visual transit-map roadmap to platform engineering — building the platform everyone else ships on. From Linux, networking, containers and cloud through Kubernetes, infrastructure-as-code, CI/CD, GitOps and observability to SRE, internal developer platforms, golden paths, FinOps and platform-as-a-product thinking. 18 stations across 3 tracks — Foundations, The Platform, Scale & Reliability.
- [Data Scientist Roadmap](https://vibeengines.com/roadmap/data-scientist): A visual transit-map roadmap to data science — turning data into decisions. From statistics, Python, SQL and EDA through supervised and unsupervised ML, feature engineering, gradient boosting and deep learning to A/B testing, causal inference, communicating results, MLOps and doing data science in the LLM era. 18 stations across 3 tracks — Foundations, Machine Learning, Impact & the LLM Era.
- [SRE Roadmap](https://vibeengines.com/roadmap/sre): A visual transit-map roadmap to become a site reliability engineer in 2026. From Linux, networking and distributed systems through SLOs, error budgets, alerting, incident response and postmortems to reliability patterns, chaos engineering, Kubernetes reliability, automation and disaster recovery. 18 stations across 3 tracks — Foundations, Reliability Practice, Scale & Resilience.
- [Engineering Manager Roadmap](https://vibeengines.com/roadmap/engineering-manager): A visual transit-map roadmap to become an engineering manager in 2026. From the IC-to-manager shift, 1:1s, feedback and delegation through performance management, growth, difficult conversations and culture to strategy, stakeholders, org design and managing managers. 18 stations across 3 tracks — The Transition, Leading People, Leading the Org.
- [QA / SDET Roadmap](https://vibeengines.com/roadmap/qa-sdet): A visual transit-map roadmap to become a QA engineer or SDET in 2026. From the test pyramid, unit and integration testing and test design through UI and API automation, frameworks, CI pipelines and flaky-test control to performance, security, testing AI systems and the SDET career. 18 stations across 3 tracks — Testing Foundations, Automation, Advanced Quality.
- [Solutions Architect Roadmap](https://vibeengines.com/roadmap/solutions-architect): A visual transit-map roadmap to become a solutions architect in 2026. From cloud fundamentals, networking and data through the Well-Architected pillars, scalability, resilience, cost and integration patterns to requirements discovery, architecture decisions, stakeholder communication and the SA career. 18 stations across 3 tracks — Foundations, Designing Systems, The Craft.
- [Mobile Engineer Roadmap](https://vibeengines.com/roadmap/mobile-engineer): A visual transit-map roadmap to become a mobile engineer in 2026. From native vs cross-platform, a language, UI, state and navigation through storage, concurrency, platform APIs, testing and offline-first sync to architecture, mobile CI/CD, app-store release, crash reporting and the mobile career. 18 stations across 3 tracks — Foundations, Building Apps, Shipping.
- [AI Safety Engineer Roadmap](https://vibeengines.com/roadmap/ai-safety-engineer): A visual transit-map roadmap to become an AI safety engineer in 2026. From alignment, evaluation, interpretability and threat modeling through prompt injection, guardrails, data poisoning, adversarial robustness and agent safety to policy, model documentation, responsible deployment and scalable oversight. 18 stations across 3 tracks — Foundations, Securing AI Systems, Governance & Frontier.
- [Agentic AI Engineer Roadmap](https://vibeengines.com/roadmap/agentic-ai-engineer): A visual transit-map roadmap to become an agentic AI engineer in 2026 — the year's fastest-growing engineering title. From what an agent actually is, the agent loop, tool use, MCP and memory through planning, multi-agent orchestration, control planes, A2A interop, agentic coding and self-improvement to evals, long-horizon reliability, guardrails, security, supply chain and agentic payments. 18 stations across 3 tracks — Agent Foundations, Building Agents, Production & Safety.
- [AI Red-Teamer Roadmap](https://vibeengines.com/roadmap/ai-red-teamer): A visual transit-map roadmap to become an AI red-teamer in 2026 — the offensive side of AI security, explicitly distinct from the defensive AI-safety and classic security-engineer tracks. From the AI attack surface, threat modeling and red-team tooling through prompt injection, jailbreaks, data poisoning, model extraction and agent exploitation to injection defenses, gateways, supply-chain attacks, continuous red-teaming and responsible disclosure. 18 stations across 3 tracks — Foundations, Attack Techniques, Defense & Career.

## Free Interactive Tools
- [Consistent Hashing Visualizer](https://vibeengines.com/tools/consistent-hashing): An interactive consistent-hashing playground. Add and remove nodes, tune virtual nodes, and watch keys remap around the ring in real time — see exactly why consistent hashing moves only K/N keys instead of reshuffling everything, and how virtual nodes smooth out hotspots.
- [Interactive Capacity Estimator](https://vibeengines.com/tools/capacity-estimator): Slide DAU, requests per user, payload size and read/write ratio and watch QPS, storage per year, bandwidth, shard count and cache memory recompute live — every number with the formula behind it. The napkin math interviewers expect, made interactive.
- [RAG Chunking Playground](https://vibeengines.com/tools/rag-chunking): Drop in any text and compare chunking strategies — fixed-size, recursive, by-sentence, by-paragraph — with overlap highlighted and an estimated token count per chunk. Stop guessing your chunk size; see exactly how your RAG pipeline will split a document.
- [Context Budget & Cost Planner](https://vibeengines.com/tools/context-cost-planner): Add a system prompt, tool definitions, conversation history and retrieved context, then see your context window fill up and the cost per call — plus the bill at 1k and 1M requests — across model price tiers. An architecture planner, not a toy token counter.
- [Quorum (N/R/W) Explorer](https://vibeengines.com/tools/quorum-explorer): Dial the replica count and the read/write quorum sizes and see at a glance whether reads are guaranteed strongly consistent (R + W > N), how many node failures you can survive, and where you land on the latency–availability spectrum. The tunable-consistency intuition, made tactile.
- [Availability (Nines) Calculator](https://vibeengines.com/tools/availability-calculator): Chain dependencies in series and parallel and watch the combined availability — and the yearly downtime it implies — fall out. Unlike single-service "nines" calculators, this one models the dependency graph, so you see how one shaky component drags down the whole system.
- [LLM-as-Judge Rubric Builder](https://vibeengines.com/tools/llm-judge-builder): Define your evaluation criteria and a scoring scale, then generate a clean, copy-pasteable LLM-as-judge prompt you can drop into your eval pipeline — with the common pitfalls (position bias, verbosity bias, ties) called out. Turns eval theory into a prompt you can ship.
- [Tool-Schema Designer](https://vibeengines.com/tools/tool-schema-designer): Compose a tool/function definition field by field — name, description, parameters, required flags — and export valid tool-use JSON for the Claude and OpenAI formats, with the JSON Schema generated for you. Stop hand-writing function-calling schemas and fighting silent validation errors.
- [Percentile Calculator](https://vibeengines.com/tools/percentile-calculator): Drop in a list of latencies (or any numbers) and get p50, p90, p95 and p99 instantly, plus min, max and mean — with the sorted distribution drawn as a histogram and each percentile marked on it. See exactly why the average hides your worst requests and the tail is what users feel.
- [LLM Pricing Comparator](https://vibeengines.com/tools/model-pricing-comparator): Set input and output tokens per call and your monthly request volume, and instantly compare cost per call and cost per month across GPT-4o, Claude, Gemini and open models — sorted cheapest-first with the spread shown. See why output tokens dominate and how a 10× price gap between models turns into real dollars.
- [Bloom Filter Sizing](https://vibeengines.com/tools/bloom-filter-sizing): Enter how many items you expect and the false-positive rate you can tolerate, and get the optimal Bloom filter: bit-array size, memory footprint, number of hash functions, bits per item, and the actual FP rate you’ll hit. See why a Bloom filter needs only ~10 bits per item — no matter how many items — to answer membership at a fraction of a hash set’s memory.
- [Token Bucket Simulator](https://vibeengines.com/tools/token-bucket-simulator): A live token-bucket rate limiter you can play. Set the bucket capacity and refill rate, then send requests by hand or turn on auto traffic — watch the bucket drain when you burst, refill when you pause, and reject requests once it hits empty. The algorithm behind almost every production rate limiter, made tactile.
- [Context Window Visualizer](https://vibeengines.com/tools/context-window-visualizer): Set the tokens for your system prompt, tools, chat history, RAG context and output reserve, pick a model window (8K–1M), and watch a stacked bar fill it. The moment it overflows, the tool shows exactly how much compaction would have to trim from history and retrieved context to make the request fit.
- [Token Counter](https://vibeengines.com/tools/token-counter): Paste any prompt, document or code and get an instant token estimate, the cost of sending it as input across popular models (Claude, GPT-4o, Gemini, Llama), and how much of each context window — 8K to 1M — it consumes. Tuned heuristics for prose vs code, no signup, nothing leaves your browser.
- [GPU VRAM Calculator](https://vibeengines.com/tools/gpu-vram-calculator): Pick a model (Llama, Mistral, Qwen, Phi, Mixtral or custom architecture), a precision (FP16 / INT8 / INT4), a context length and batch size — and get the real VRAM requirement: weights, KV cache (GQA-aware), runtime overhead, and a fits-or-not verdict across common GPUs from a T4 to an H200.
- [Fine-Tuning Cost Estimator](https://vibeengines.com/tools/fine-tuning-cost-estimator): Pick a method (QLoRA / LoRA / full AdamW), model size, dataset and GPU, and get the napkin answer: training memory, how many cards you need to fit, GPU-hours from the 6·P·tokens FLOPs rule, wall-clock time and the rental bill — with the QLoRA-vs-full memory gap made painfully visible.
- [KV Cache Calculator](https://vibeengines.com/tools/kv-cache-calculator): Pick a model architecture (GQA-aware presets from published configs), a cache dtype (FP16/FP8/INT4) and a context length, and see the KV cache laid bare: bytes per token, gigabytes per sequence, the whole batch — and how many full-context users actually fit beside the weights on a 24/48/80/141 GB card.
- [Embedding Cost Calculator](https://vibeengines.com/tools/embedding-cost-calculator): Set your corpus (documents × average tokens), chunking (size + overlap), embedding model and vector dtype — and get the numbers that decide RAG budgets: one-time indexing cost, vector count, storage footprint from FP32 down to binary, and the monthly bill for query embeddings.
- [Latency Budget Builder](https://vibeengines.com/tools/latency-budget-builder): Assemble a chat request stage by stage — network, gateway, retrieval, rerank, prefill, decode — and watch the waterfall: time to first token, full response time, a stacked bar of where the milliseconds went, and which stage to attack first when the budget blows.
- [SLO Burn-Rate Calculator](https://vibeengines.com/tools/slo-burn-calculator): Pick an SLO (99% to 99.99%), a window, and your current error rate: get the error budget in minutes and failed requests, the burn-rate multiple, time-to-exhaustion at the current pace, and the Google-SRE multiwindow alert table with the rows that would fire highlighted.
- [Model Comparison Table](https://vibeengines.com/tools/model-comparison): Claude, GPT, Gemini, DeepSeek, Kimi and Llama side by side: context windows, list prices, open-vs-closed, and a blended per-token cost computed at your real input:output ratio — because a RAG app and a story generator should not read the same pricing table.
- [Training Compute Calculator](https://vibeengines.com/tools/training-compute-calculator): Put in a model size and a token budget and see the training compute it implies — the classic 6ND FLOPs, the GPU-hours and wall-clock time on your cluster, the dollar cost, and how your token budget compares to the Chinchilla compute-optimal 20× rule. Every number is editable, from GPU peak FLOP/s to model-FLOPs-utilization.
- [Little's Law Calculator](https://vibeengines.com/tools/littles-law-calculator): Little's Law ties the three numbers every capacity plan rests on: the average number of in-flight requests, the throughput, and the latency. Solve for whichever you don't know — size a connection pool from QPS and latency, back out the latency a queue depth implies, or find the throughput a fixed worker count can sustain. Includes a utilisation read-out so you can see when you're driving the system into the danger zone.
- [Prompt Caching Savings Calculator](https://vibeengines.com/tools/prompt-caching-calculator): Prompt caching is the biggest cost lever on repetitive LLM workloads — a shared system prompt or RAG context read on every call is charged at a fraction of the price once cached. Put in your prompt shape (cached prefix vs fresh tokens), a cache hit rate, and the provider's cache-write and cache-read multipliers, and see your effective cost per request and the percentage saved versus paying full price every time.
- [JWT Decoder](https://vibeengines.com/tools/jwt-decoder): A client-side JWT decoder. Paste a JSON Web Token and instantly see the decoded header and payload, with the standard claims (iss, sub, aud, exp, iat, nbf) explained and the expiry shown as a live countdown. Everything runs in your browser — the token is never sent anywhere, so it is safe to paste a real one.
- [CIDR Calculator](https://vibeengines.com/tools/cidr-calculator): An IPv4 subnet calculator. Enter a CIDR block like 10.0.0.0/24 and instantly see the network address, broadcast address, usable host range, total and usable host counts, the subnet mask and wildcard mask, and the binary breakdown. Handy for planning VPC subnets, firewall rules and route tables — all computed in your browser.
- [Unix Time Converter](https://vibeengines.com/tools/unix-time-converter): A Unix timestamp converter. Paste an epoch value (seconds or milliseconds — auto-detected) to get the human-readable date in both UTC and your local timezone, or pick a date to get the timestamp back. Shows the ISO 8601 string, relative time, and the current epoch ticking live. Runs entirely in your browser.
- [UUID & ULID Generator](https://vibeengines.com/tools/uuid-ulid-generator): A UUID and ULID generator. Produce cryptographically-random version-4 UUIDs or sortable ULIDs, one at a time or in bulk, with one-click copy. Explains when to reach for a random UUID versus a time-sortable ULID, and shows the structure of each. Uses the browser’s secure crypto — nothing is generated on or sent to a server.
- [Regex Tester](https://vibeengines.com/tools/regex-tester): An interactive regular-expression tester. Type a pattern and flags, paste your test text, and see all matches highlighted with their positions, plus every numbered and named capture group. Explains the flags and common tokens, and runs entirely in your browser so nothing is sent anywhere.
- [Base64 & URL Encoder](https://vibeengines.com/tools/base64-url-tools): A Base64 and URL encoding tool. Paste text to get its standard Base64, URL-safe Base64URL, and percent-encoded forms at once, or switch to decode to recover the original — all UTF-8 aware and computed in your browser. Handy for JWTs, data URIs, query strings and API debugging.
- [Chmod Calculator](https://vibeengines.com/tools/chmod-calculator): A Unix file-permission calculator. Toggle read, write and execute for owner, group and others to get the octal mode (like 755) and the symbolic string (rwxr-xr-x), or type an octal number to see exactly which permissions it grants. Explains what each bit means and the common modes to reach for.
- [Password Entropy Calculator](https://vibeengines.com/tools/password-entropy): A password strength calculator based on entropy. Type a password (analyzed only in your browser) to see the character pool it draws from, its entropy in bits, a strength rating, and an estimated time to crack at realistic offline attack speeds. Explains why length beats complexity and where the entropy model’s limits are.
- [Cron Expression Builder](https://vibeengines.com/tools/cron-builder): A cron expression builder and decoder. Type a five-field cron schedule and instantly get a plain-English description plus the next several times it would fire, or start from a common preset. Supports ranges, lists and step values, and explains what each of the five fields means — all computed in your browser.
- [SQL Formatter](https://vibeengines.com/tools/sql-formatter): A lightweight SQL formatter. Paste a cramped, one-line query and get it back with each major clause on its own line, keywords cased consistently, and conditions indented — so you can actually read and review it. Runs in your browser; it formats for readability rather than parsing the full SQL grammar.
- [Markdown Table Generator](https://vibeengines.com/tools/md-table-generator): A Markdown table generator. Paste comma- or tab-separated data and get a properly aligned Markdown table you can drop into a README, a pull request, or docs — with a live rendered preview and a choice of column alignment. Everything runs in your browser.
- [Diff Checker](https://vibeengines.com/tools/diff-checker): A text diff checker. Paste an original and a changed version to see a line-by-line comparison — additions, removals and unchanged lines highlighted — computed with a longest-common-subsequence diff, entirely in your browser. Handy for comparing configs, logs, JSON, or any two versions of text.
- [A/B Test Significance Calculator](https://vibeengines.com/tools/ab-significance-calculator): An A/B test significance calculator using a two-proportion z-test. Enter the visitors and conversions for a control and a variant to get each conversion rate, the relative uplift, the z-score and two-tailed p-value, and a clear verdict on whether the result is statistically significant. Explains what significance does and does not tell you.
- [Kafka Partition Calculator](https://vibeengines.com/tools/kafka-partition-calculator): A Kafka partition calculator. Enter your target throughput and the per-partition limits your producers and consumers can sustain, plus how many consumers you want to run in parallel, and get a recommended partition count with the reasoning — because partitions cap both throughput and consumer parallelism. Estimates topic storage from retention and replication too.
- [Connection Pool Sizer](https://vibeengines.com/tools/connection-pool-sizer): A database connection pool sizer built on Little’s Law. Enter your peak queries per second, average query latency, and how many application instances you run, and get the concurrency you actually need, a per-instance pool size with headroom, and a check against your database’s max-connections limit — so you neither starve requests nor exhaust the database.
- [Database Index Size Estimator](https://vibeengines.com/tools/db-index-size-estimator): A database index size estimator. Enter the row count, the size of the indexed key, and a fill factor to estimate the on-disk size of a B-tree index — including the row-pointer overhead and internal nodes — so you can anticipate the storage and memory cost of an index before adding it. Compares the cost of several indexes at once.
- [JSON Formatter & Diff](https://vibeengines.com/tools/json-format-diff): A JSON formatter, validator and diff tool. Paste JSON to validate it and pretty-print it, with clear error messages on invalid input. Paste a second document to see a key-sorted, value-level diff — so real changes stand out instead of formatting or key-order noise. Everything runs in your browser.
- [Cache ROI Calculator](https://vibeengines.com/tools/cache-roi-calculator): A cache ROI calculator. Enter your request rate, cache hit rate, and the latency of a hit versus a miss to see your effective average latency, how much faster that is than going to the origin every time, and how much backend load the cache removes. Add a per-origin-request cost to estimate the money saved.
- [Storage Growth Forecaster](https://vibeengines.com/tools/storage-growth-forecaster): A storage growth forecaster. Enter your current data size and either a daily ingest rate or a monthly growth percentage, set a replication factor, and see your projected size at 3, 6, 12 and 24 months — plus when you would cross a capacity threshold. Handy for capacity planning databases, logs, object stores and backups.
- [Rate Limit Designer](https://vibeengines.com/tools/rate-limit-designer): A rate limiter designer. Enter the sustained rate you want to allow and how big a burst to tolerate, and get concrete token-bucket parameters (refill rate and capacity), the effective peak burst, and how the choice compares to fixed-window and sliding-window approaches — including the boundary-burst pitfall of fixed windows.
- [Agent Loop Cost Estimator](https://vibeengines.com/tools/agent-loop-cost-estimator): An AI agent cost estimator. Enter the steps per task, the tokens added each step, and your model’s input/output prices to see the cost per task, per day and per month — and why re-sending a growing context each step makes cost scale with the square of the steps, not linearly. Shows where prompt caching helps.
- [Sharding Planner](https://vibeengines.com/tools/sharding-planner): A database sharding planner. Enter your total data size and query rate, and what a single shard can hold and serve, and get the number of shards you need — the larger of the storage and throughput requirements, with growth headroom — plus the per-shard load and a reminder of what resharding later costs.
- [Embedding Dimension Tradeoff](https://vibeengines.com/tools/embedding-dim-tradeoff): An embedding storage calculator. Enter how many vectors you have and compare the memory footprint across common embedding dimensions and quantization levels (float32, float16, int8) — so you can weigh retrieval quality against the RAM and cost of your vector index, and see what dimension reduction or quantization buys you.
- [Latency Numbers Explorer](https://vibeengines.com/tools/latency-numbers-interactive): An interactive version of the classic "latency numbers every programmer should know." Compare the real time of an L1 cache reference, a memory read, an SSD read, a same-datacenter round trip and a cross-continent round trip — then scale them all to human time (where one CPU cycle is a second) to feel just how enormous the gaps really are.
- [GPU Rental Price Reference](https://vibeengines.com/tools/gpu-rental-prices): A cloud GPU price reference and cost estimator. Compare approximate on-demand hourly rates for common GPUs (T4, L4, A10G, A100, H100) and estimate what a training or inference job costs from the GPU count and hours. Rates are approximate and drift over time — always confirm current pricing with your provider.
- [NPU Model-Fit Calculator](https://vibeengines.com/tools/npu-model-fit-calculator): An on-device AI planner keyed to the NPU, not the GPU. Enter your device’s TOPS (e.g. a 75-TOPS Snapdragon X2) and unified RAM, pick a model size and quantization, and see two things the VRAM-fit calculators miss: whether the weights fit in memory, and how fast the NPU can prefill a prompt — the compute-bound step that TOPS actually governs. Get an escalate-to-cloud verdict when a prompt is too long to stay responsive locally.
- [Agent Time-Horizon Explorer](https://vibeengines.com/tools/agent-time-horizon-explorer): An interactive projection of the METR “time horizon” trend — the length of task an AI agent can complete at 50% reliability, which has been doubling on a regular cadence. Set the current horizon and the doubling period, and the tool projects the calendar date when agents cross the one-hour, one-workday, one-week and beyond thresholds. Every assumption is a slider, so you can stress-test the optimistic and conservative cases yourself.
- [Skill Linter](https://vibeengines.com/tools/skill-linter): A client-side linter for agent skill files (SKILL.md). Paste your skill and it scores the structure a good skill needs — a clear name and description, an explicit “when to use” trigger, concrete examples, imperative step-by-step instructions, and a scoped length — against a 12-point rubric, with per-criterion feedback on what is missing. Everything runs in your browser; nothing is uploaded. Built to catch the quality gaps that separate a curated skill from the average public one.
- [EU AI Act Timeline](https://vibeengines.com/tools/eu-ai-act-timeline): An engineering-oriented timeline of the EU AI Act: the statutory milestones (entry into force, prohibitions, GPAI obligations, high-risk rules) and what each one asks a builder to produce — model cards, logging, risk documentation, human-oversight design. Filter by your system type to see which obligations land and when. This is a plain-language planning aid for engineers, not legal advice, and it flags where proposed changes (the Digital Omnibus) may move dates that are not yet settled.
- [AI Salary Explorer](https://vibeengines.com/tools/ai-salary-explorer): A quick, transparent estimate of total-compensation ranges for AI and software roles in 2026. Pick a role, level and company tier and it shows an indicative band, built from a public base rate and clearly-labelled tier and level multipliers rather than a black box. Calibrated so the anchors match reported figures — a senior big-tech AI engineer around the low-$200Ks, a frontier-lab senior in the high-six-figures. These are self-reported market ranges for orientation and negotiation prep, not an offer or advice — always verify live on a source like Levels.fyi.

## Cheatsheets (printable one-page references)
- [Big-O Complexity](https://vibeengines.com/cheatsheet/big-o)
- [LLM Sampling & Decoding](https://vibeengines.com/cheatsheet/llm-decoding)
- [HTTP Status Codes](https://vibeengines.com/cheatsheet/http-status)
- [System Design Napkin Math](https://vibeengines.com/cheatsheet/napkin-math)
- [The Agent Loop Cheatsheet](https://vibeengines.com/cheatsheet/agent-loop)
- [Loop Engineering](https://vibeengines.com/cheatsheet/loop-engineering)
- [Sorting Algorithms](https://vibeengines.com/cheatsheet/sorting-algorithms)
- [Graph Algorithms](https://vibeengines.com/cheatsheet/graph-algorithms)
- [Dynamic Programming Patterns](https://vibeengines.com/cheatsheet/dp-patterns)
- [Transformer Math](https://vibeengines.com/cheatsheet/transformer-math)
- [GPU Numbers Every AI Engineer Should Know](https://vibeengines.com/cheatsheet/gpu-numbers)
- [Prompt Patterns](https://vibeengines.com/cheatsheet/prompt-patterns)
- [Evals & Metrics](https://vibeengines.com/cheatsheet/evals-metrics)
- [MCP Quick Reference](https://vibeengines.com/cheatsheet/mcp)
- [Git Survival Guide](https://vibeengines.com/cheatsheet/git)
- [SQL Quick Reference](https://vibeengines.com/cheatsheet/sql)
- [Regex Without Tears](https://vibeengines.com/cheatsheet/regex)
- [Bash & The Terminal](https://vibeengines.com/cheatsheet/bash)
- [Pandas & NumPy](https://vibeengines.com/cheatsheet/pandas-numpy)
- [kubectl Quick Reference](https://vibeengines.com/cheatsheet/kubectl)
- [Docker Survival Guide](https://vibeengines.com/cheatsheet/docker)
- [Linux Debugging Toolkit](https://vibeengines.com/cheatsheet/linux-debug)
- [Network CLI Toolkit](https://vibeengines.com/cheatsheet/network-cli)
- [Vim Survival Guide](https://vibeengines.com/cheatsheet/vim)
- [tmux Quick Reference](https://vibeengines.com/cheatsheet/tmux)
- [curl Quick Reference](https://vibeengines.com/cheatsheet/curl)
- [jq Quick Reference](https://vibeengines.com/cheatsheet/jq)
- [psql Quick Reference](https://vibeengines.com/cheatsheet/psql)
- [redis-cli Quick Reference](https://vibeengines.com/cheatsheet/redis-cli)
- [Kafka CLI Quick Reference](https://vibeengines.com/cheatsheet/kafka-cli)
- [Python Standard Library](https://vibeengines.com/cheatsheet/python-stdlib)
- [TypeScript Types Quick Reference](https://vibeengines.com/cheatsheet/typescript)
- [React Hooks Quick Reference](https://vibeengines.com/cheatsheet/react-hooks)
- [CSS Flexbox & Grid](https://vibeengines.com/cheatsheet/css-flex-grid)
- [Data Structure Complexity](https://vibeengines.com/cheatsheet/ds-complexity)
- [HTTP Headers Quick Reference](https://vibeengines.com/cheatsheet/http-headers)
- [SQL Window Functions](https://vibeengines.com/cheatsheet/sql-window-functions)
- [Git Advanced (Rebase, Bisect, Worktree)](https://vibeengines.com/cheatsheet/git-advanced)
- [Keyboard Shortcuts (Editor & Terminal)](https://vibeengines.com/cheatsheet/shortcuts)
- [Claude Code (Agentic CLI)](https://vibeengines.com/cheatsheet/claude-code-agentic-cli)
- [API Security Checklist](https://vibeengines.com/cheatsheet/api-security-checklist)
- [The Forward Deployed Engineer Playbook](https://vibeengines.com/cheatsheet/fde-playbook)
- [Customer Discovery Questions](https://vibeengines.com/cheatsheet/customer-discovery-questions)
- [The Demo Checklist](https://vibeengines.com/cheatsheet/demo-checklist)
- [Integration Debugging Playbook](https://vibeengines.com/cheatsheet/integration-debugging)
- [Deployment Targets (Cloud → Air-Gapped)](https://vibeengines.com/cheatsheet/deployment-targets)
- [Security & Compliance Quick-Ref (FDE)](https://vibeengines.com/cheatsheet/security-compliance-quickref)
- [POC → Production Checklist](https://vibeengines.com/cheatsheet/poc-to-production-checklist)

## Glossary (AI & system-design terms, defined)
- [Attention](https://vibeengines.com/glossary/attention)
- [Transformer](https://vibeengines.com/glossary/transformer)
- [Token](https://vibeengines.com/glossary/token)
- [Tokenization](https://vibeengines.com/glossary/tokenization)
- [Embedding](https://vibeengines.com/glossary/embedding)
- [Context Window](https://vibeengines.com/glossary/context-window)
- [Agent](https://vibeengines.com/glossary/agent)
- [Loop Engineering](https://vibeengines.com/glossary/loop-engineering)
- [Tool Calling](https://vibeengines.com/glossary/tool-calling)
- [Model Context Protocol (MCP)](https://vibeengines.com/glossary/mcp)
- [Prompt Injection](https://vibeengines.com/glossary/prompt-injection)
- [Retrieval-Augmented Generation (RAG)](https://vibeengines.com/glossary/rag)
- [Vector Database](https://vibeengines.com/glossary/vector-database)
- [Cosine Similarity](https://vibeengines.com/glossary/cosine-similarity)
- [Hallucination](https://vibeengines.com/glossary/hallucination)
- [LLM-as-a-Judge](https://vibeengines.com/glossary/llm-as-judge)
- [Temperature](https://vibeengines.com/glossary/temperature)
- [Softmax](https://vibeengines.com/glossary/softmax)
- [Cross-Entropy Loss](https://vibeengines.com/glossary/cross-entropy)
- [Fine-Tuning](https://vibeengines.com/glossary/fine-tuning)
- [Prompt Caching](https://vibeengines.com/glossary/prompt-caching)
- [Mixture of Experts (MoE)](https://vibeengines.com/glossary/mixture-of-experts)
- [Chain of Thought](https://vibeengines.com/glossary/chain-of-thought)
- [CAP Theorem](https://vibeengines.com/glossary/cap-theorem)
- [Consistent Hashing](https://vibeengines.com/glossary/consistent-hashing)
- [Idempotency](https://vibeengines.com/glossary/idempotency)
- [Rate Limiting](https://vibeengines.com/glossary/rate-limiting)
- [Sharding](https://vibeengines.com/glossary/sharding)
- [Bloom Filter](https://vibeengines.com/glossary/bloom-filter)
- [Quorum (N/R/W)](https://vibeengines.com/glossary/quorum)
- [Eventual Consistency](https://vibeengines.com/glossary/eventual-consistency)
- [Backpressure](https://vibeengines.com/glossary/backpressure)
- [Cache Invalidation](https://vibeengines.com/glossary/cache-invalidation)
- [p99 Latency](https://vibeengines.com/glossary/p99-latency)
- [Context Engineering](https://vibeengines.com/glossary/context-engineering)
- [KV Cache](https://vibeengines.com/glossary/kv-cache)
- [Quantization](https://vibeengines.com/glossary/quantization)
- [Distillation](https://vibeengines.com/glossary/distillation)
- [Speculative Decoding](https://vibeengines.com/glossary/speculative-decoding)
- [LoRA](https://vibeengines.com/glossary/lora)
- [RLHF](https://vibeengines.com/glossary/rlhf)
- [DPO](https://vibeengines.com/glossary/dpo)
- [GRPO](https://vibeengines.com/glossary/grpo)
- [Test-Time Compute](https://vibeengines.com/glossary/test-time-compute)
- [Guardrails](https://vibeengines.com/glossary/guardrails)
- [Jailbreak](https://vibeengines.com/glossary/jailbreak)
- [System Prompt](https://vibeengines.com/glossary/system-prompt)
- [Structured Outputs](https://vibeengines.com/glossary/structured-outputs)
- [Few-Shot Prompting](https://vibeengines.com/glossary/few-shot)
- [Top-p Sampling](https://vibeengines.com/glossary/top-p)
- [Beam Search](https://vibeengines.com/glossary/beam-search)
- [Perplexity](https://vibeengines.com/glossary/perplexity)
- [Grounding](https://vibeengines.com/glossary/grounding)
- [Continuous Batching](https://vibeengines.com/glossary/batching)
- [Time to First Token](https://vibeengines.com/glossary/ttft)
- [Agent Skills](https://vibeengines.com/glossary/agent-skills)
- [Harness](https://vibeengines.com/glossary/harness)
- [World Model](https://vibeengines.com/glossary/world-model)
- [Multimodal Model](https://vibeengines.com/glossary/multimodal)
- [Chunking](https://vibeengines.com/glossary/chunking)
- [BM25](https://vibeengines.com/glossary/bm25)
- [Hybrid Search](https://vibeengines.com/glossary/hybrid-search)
- [Reranking](https://vibeengines.com/glossary/reranking)
- [HNSW](https://vibeengines.com/glossary/hnsw)
- [Raft](https://vibeengines.com/glossary/raft)
- [Leader Election](https://vibeengines.com/glossary/leader-election)
- [Two-Phase Commit](https://vibeengines.com/glossary/two-phase-commit)
- [Saga Pattern](https://vibeengines.com/glossary/saga-pattern)
- [Outbox Pattern](https://vibeengines.com/glossary/outbox-pattern)
- [Change Data Capture](https://vibeengines.com/glossary/cdc)
- [Write-Ahead Log](https://vibeengines.com/glossary/wal)
- [LSM Tree](https://vibeengines.com/glossary/lsm-tree)
- [B-Tree](https://vibeengines.com/glossary/b-tree)
- [Gossip Protocol](https://vibeengines.com/glossary/gossip-protocol)
- [Vector Clock](https://vibeengines.com/glossary/vector-clock)
- [A2A Protocol](https://vibeengines.com/glossary/a2a)
- [SWE-bench](https://vibeengines.com/glossary/swe-bench)
- [Vibe Coding](https://vibeengines.com/glossary/vibe-coding)
- [Circuit Breaker](https://vibeengines.com/glossary/circuit-breaker)
- [Tensor Parallelism](https://vibeengines.com/glossary/tensor-parallelism)
- [Pipeline Parallelism](https://vibeengines.com/glossary/pipeline-parallelism)
- [Data Parallelism](https://vibeengines.com/glossary/data-parallelism)
- [ZeRO / FSDP](https://vibeengines.com/glossary/zero-redundancy-optimizer)
- [Gradient Checkpointing](https://vibeengines.com/glossary/gradient-checkpointing)
- [Mixed Precision Training](https://vibeengines.com/glossary/mixed-precision)
- [Learning Rate Schedule](https://vibeengines.com/glossary/learning-rate-schedule)
- [Gradient Clipping](https://vibeengines.com/glossary/gradient-clipping)
- [Catastrophic Forgetting](https://vibeengines.com/glossary/catastrophic-forgetting)
- [Scaling Laws](https://vibeengines.com/glossary/scaling-laws)
- [Inference](https://vibeengines.com/glossary/inference)
- [Continuous Batching](https://vibeengines.com/glossary/continuous-batching)
- [PagedAttention](https://vibeengines.com/glossary/paged-attention)
- [RoPE (Rotary Position Embedding)](https://vibeengines.com/glossary/rope)
- [FlashAttention](https://vibeengines.com/glossary/flash-attention)
- [Layer Normalization](https://vibeengines.com/glossary/layer-normalization)
- [Residual Connection](https://vibeengines.com/glossary/residual-connection)
- [Model Parallelism](https://vibeengines.com/glossary/model-parallelism)
- [Red-Teaming](https://vibeengines.com/glossary/red-teaming)
- [Prompt Leaking](https://vibeengines.com/glossary/prompt-leaking)
- [Data Poisoning](https://vibeengines.com/glossary/data-poisoning)
- [Model Extraction](https://vibeengines.com/glossary/model-extraction)
- [PII Redaction](https://vibeengines.com/glossary/pii-redaction)
- [Differential Privacy](https://vibeengines.com/glossary/differential-privacy)
- [Zero-Trust Architecture](https://vibeengines.com/glossary/zero-trust-architecture)
- [Principle of Least Privilege](https://vibeengines.com/glossary/least-privilege)
- [RBAC (Role-Based Access Control)](https://vibeengines.com/glossary/rbac)
- [Secrets Management](https://vibeengines.com/glossary/secrets-management)
- [Service Mesh](https://vibeengines.com/glossary/service-mesh)
- [Sidecar Pattern](https://vibeengines.com/glossary/sidecar-pattern)
- [API Gateway](https://vibeengines.com/glossary/api-gateway)
- [Service Discovery](https://vibeengines.com/glossary/service-discovery)
- [Health Check](https://vibeengines.com/glossary/health-check)
- [Canary Release](https://vibeengines.com/glossary/canary-release)
- [Blue-Green Deployment](https://vibeengines.com/glossary/blue-green-deployment)
- [Chaos Engineering](https://vibeengines.com/glossary/chaos-engineering)
- [Distributed Tracing](https://vibeengines.com/glossary/distributed-tracing)
- [Thundering Herd](https://vibeengines.com/glossary/thundering-herd)
- [Load Shedding](https://vibeengines.com/glossary/load-shedding)
- [Load Balancer](https://vibeengines.com/glossary/load-balancer)
- [x402](https://vibeengines.com/glossary/x402)
- [AP2 (Agent Payments Protocol)](https://vibeengines.com/glossary/ap2)
- [Mandate](https://vibeengines.com/glossary/mandate)
- [Attribution Graph](https://vibeengines.com/glossary/attribution-graph)
- [Feature (SAE)](https://vibeengines.com/glossary/sae-feature)
- [Verifier](https://vibeengines.com/glossary/verifier)
- [Rollout](https://vibeengines.com/glossary/rollout)
- [Environment Hub](https://vibeengines.com/glossary/environment-hub)
- [Data Foundry](https://vibeengines.com/glossary/data-foundry)
- [Time Horizon (50%)](https://vibeengines.com/glossary/time-horizon)
- [Diffusion LLM](https://vibeengines.com/glossary/diffusion-llm)
- [Block Diffusion](https://vibeengines.com/glossary/block-diffusion)
- [Engram](https://vibeengines.com/glossary/engram)
- [Effort Level](https://vibeengines.com/glossary/effort-level)
- [Spec-Driven Development](https://vibeengines.com/glossary/spec-driven-development)
- [Agentic Browser](https://vibeengines.com/glossary/agentic-browser)
- [On-Policy Distillation](https://vibeengines.com/glossary/on-policy-distillation)
- [Query Fan-Out](https://vibeengines.com/glossary/query-fan-out)

## About
- [About Vibe Engines](https://vibeengines.com/about)
- [Open for AI — citation & attribution policy](https://vibeengines.com/open-for-ai)
- [Contact](https://vibeengines.com/contact)