What’s New
The latest from Vibe Engines.
Everything freshly published — new handbooks, learning paths, roadmaps, system-design breakdowns, papers and interactive tools — newest first. Bookmark this page; the site grows most weeks.
Latest Handbooks
Browse all Handbooks →- HandbookOptimistic 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.
- HandbookOrchestration 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.
- HandbookBatch vs Real-Time 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.
- HandbookSQL 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.
- HandbookCross-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.
- HandbookQuantization 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.
Latest Learning Paths
Browse all Learning Paths →- Learning PathAI for Product ManagersA 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.
- Learning PathThe Papers BootcampThe 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.
- Learning PathDistributed Systems Deep DiveThe 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.
- Learning PathThe 4-Week Interview SprintA 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.
- Learning PathSystem Design in 30 DaysA 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.
- Learning PathBuild an LLM From ScratchNo 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.
Latest Roadmaps
Browse all Roadmaps →- RoadmapAI Safety Engineer Roadmap.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.
- RoadmapMobile Engineer Roadmap.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.
- RoadmapSolutions Architect Roadmap.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.
- RoadmapQA / SDET Roadmap.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.
- RoadmapEngineering Manager Roadmap.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.
- RoadmapSRE Roadmap.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.
Latest System Designs
Browse all System Designs →- System DesignDesign an Audit Logging & Compliance TrailBuild 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.
- System DesignDesign Multi-Tenant Customer IsolationServe 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.
- System DesignDesign a Customer Data Integration PipelineBuild 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.
- System DesignDesign Webhook Ingestion at ScaleBuild 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.
- System DesignDesign an Online JudgeBuild 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.
- System DesignDesign an Email SystemBuild 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.
Latest AI System Designs
Browse all AI System Designs →- AI System DesignDesign Secure Document Ingestion + RAGBuild 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.
- AI System DesignDeploy an LLM in a Customer’s EnvironmentDeploy 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.
- AI System DesignDesign an AI Video Dubbing SystemBuild 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.
- AI System DesignDesign an Edge Inference FleetBuild 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.
- AI System DesignDesign a Personal Knowledge AssistantBuild 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.
- AI System DesignDesign a CI Test-Generation AgentBuild 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.
Latest Paper Breakdowns
Browse all Paper Breakdowns →- Paperwav2vec 2.0Self-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.
- PaperAlphaZeroThe 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.
- PapermixupThe 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.
- PaperSelf-InstructHow 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.
- PaperDDIMDenoising 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.
- PaperThe Lottery Ticket HypothesisThe 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.
Latest Tools
Browse all Tools →- ToolGPU Rental Price ReferenceA 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.
- ToolLatency Numbers ExplorerAn 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.
- ToolEmbedding Dimension TradeoffAn 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.
- ToolSharding PlannerA 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.
- ToolAgent Loop Cost EstimatorAn 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.
- ToolRate Limit DesignerA 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.