Vibe Engines
YouTube
REFERENCE · GROUPED BY THE JOB

Cheatsheets, on shelves.

49 dense one-pagers for the things you look up constantly — complexity, decoding parameters, status codes, kubectl, napkin math, the agent loop. They sit on 15 shelves, each one the set you would have open at the same time, and the search reaches inside them: all 934 rows are indexed, so typing 429, top-p or git bisect finds the sheet that lists it even when the sheet's own title says none of those things.

49Sheets
15Shelves
934Lines, all searchable
$0Free · printable
Start hereSystem Design Napkin MathThe latency numbers, constants, and powers of ten for back-of-the-envelope estimates. It is the one sheet on this page with units on it — every other estimate you make is a sum of these numbers, so it is the one worth knowing by heart rather than looking up.Open it →
49 sheets

Building with models

The knobs, the loop and the arithmetic — the four numbers you keep re-deriving when a model is in the critical path.

The knobs on a model

What temperature actually changes, how to write the prompt, how to tell whether it got better — and, at the bottom, the arithmetic all three rest on.

4 sheets72 lines
  1. LLM Sampling & DecodingMost reached forEvery knob that shapes how a language model picks its next token — and sensible presets.19 lines
  2. Prompt PatternsThe dozen prompting techniques that actually move quality, with the one-line version of when to use each.15 lines
  3. Evals & MetricsEvery metric you need to evaluate LLMs, RAG and agents — what it measures and when it lies.19 lines
  4. Transformer MathThe napkin formulas behind every scaling, memory and cost conversation — params, FLOPs, KV cache, VRAM.19 lines

The agent loop

The loop itself, the protocol it calls tools over, the CLI that runs one for you, and the engineering discipline around all of it.

4 sheets78 lines
  1. The Agent Loop CheatsheetMost reached forThe runtime of an AI agent on one page — the loop, context, failure modes, and defenses.18 lines
  2. MCP Quick ReferenceThe Model Context Protocol on one page — primitives, transports, message flow, security rules.15 lines
  3. Claude Code (Agentic CLI)The moves that make Claude Code fast — slash commands, file references, plan mode, memory, subagents, MCP, and headless runs.16 lines
  4. Loop EngineeringRunning agents without being the keyboard — loop types, guards, building blocks, and failure modes on one page.29 lines

The numbers and the arrays

What one GPU can actually do, and the library you reshape everything with first.

2 sheets36 lines
  1. GPU Numbers Every AI Engineer Should KnowMost reached forVRAM, bandwidth, TFLOPs and rental prices for the cards that matter — plus the rules of thumb they imply.15 lines
  2. Pandas & NumPyThe data-wrangling operations every ML notebook runs on — selection, groupby, joins, reshaping, vectorization.21 lines

Living in the terminal

Everything you type rather than click. Grouped by the session you are in, not by which vendor shipped the binary.

The shell you sit in

The four you have open right now — the shell, the editor, the multiplexer, and the keys that move you between them.

4 sheets76 lines
  1. Bash & The TerminalMost reached forPipes, process control, the text-tool trinity and the shell one-liners that replace small programs.22 lines
  2. Vim Survival GuideEnough Vim to edit confidently on any server — modes, motions, and the operator+motion grammar that makes it click.17 lines
  3. tmux Quick ReferenceKeep sessions alive across disconnects and split your terminal like a pro. Everything is prefix (Ctrl-b) then a key.17 lines
  4. Keyboard Shortcuts (Editor & Terminal)The muscle-memory keys that make you faster in VS Code, the shell, and the browser devtools — the ones worth memorizing.20 lines

Git, daily and rarely

The commands you type every hour, then the ones you type once a quarter and have to look up every single time.

2 sheets42 lines
  1. Git Survival GuideMost reached forThe commands you actually reach for — daily flow, undo anything, branches, and the ones you google every time.23 lines
  2. Git Advanced (Rebase, Bisect, Worktree)Beyond add/commit/push — rewrite history cleanly, hunt a bug with binary search, and juggle branches without stashing.19 lines

Reshape it on the command line

Match the text, filter the JSON, and when neither is enough, the standard library that is already installed.

3 sheets51 lines
  1. Regex Without TearsMost reached forThe 20% of regular expressions that solves 95% of problems — tokens, anchors, groups, lookarounds, flags.19 lines
  2. jq Quick ReferenceSlice, filter, and reshape JSON on the command line. Pipe curl into jq and stop eye-parsing giant payloads.15 lines
  3. Python Standard LibraryThe batteries-included modules that mean you rarely need a dependency — collections, itertools, functools, pathlib, and more.17 lines

Containers and clusters

One box, then a thousand of them — and the same three verbs either way.

2 sheets45 lines
  1. Docker Survival GuideMost reached forThe container commands you reach for daily — build, run, debug, clean up — plus the Dockerfile lines that actually matter.22 lines
  2. kubectl Quick ReferenceThe Kubernetes commands you reach for during deploys, debugging and 2am incidents — organized by situation.23 lines

When the box is misbehaving

What is eating the CPU, and where the packet actually stopped. The two questions every incident starts as.

2 sheets37 lines
  1. Linux Debugging ToolkitMost reached forWhen a process is slow, stuck, or leaking — the commands that tell you what it is actually doing: strace, lsof, perf, and friends.19 lines
  2. Network CLI ToolkitDiagnose DNS, connections, and packets from the terminal — dig, ss, tcpdump, ip, and nc, with the flags that get answers fast.18 lines

Data and the wire

What the store will give you, what the request is actually carrying, and what the browser does with the answer.

The stores you shell into

The query language first, then the harder half of it, then the three prompts you actually type it at.

5 sheets95 lines
  1. SQL Quick ReferenceMost reached forJoins, aggregation, window functions and the query-shape patterns interviews and dashboards both live on.19 lines
  2. SQL Window FunctionsThe analytics superpower most people skip: compute running totals, rankings, and row-to-row comparisons without collapsing your rows.19 lines
  3. psql Quick ReferenceThe PostgreSQL CLI’s backslash meta-commands — inspect schemas, time queries, and stay productive without a GUI.22 lines
  4. redis-cli Quick ReferenceThe commands and data-structure verbs you use against Redis — strings, hashes, lists, sets, sorted sets, and TTLs.17 lines
  5. Kafka CLI Quick ReferenceCreate topics, produce and consume messages, and inspect consumer-group lag from the command line.18 lines

The request and its answer

Send it by hand, read the code it came back with, read the headers around it — then check you have not left the door open.

4 sheets69 lines
  1. curl Quick ReferenceMost reached forTalk to any HTTP API from the terminal — headers, bodies, auth, downloads, and the flags that make debugging painless.17 lines
  2. HTTP Status CodesThe response codes worth memorizing, grouped by class, with when to use each.18 lines
  3. HTTP Headers Quick ReferenceThe request and response headers that control caching, content, auth, CORS, and security — what each one does and sane values.17 lines
  4. API Security ChecklistThe controls that keep an API from becoming a breach — auth, authorization, input handling, transport, and the OWASP API Top-10 traps.17 lines

What the browser does with it

The type system, the hooks, and the layout model — in the order a component needs them.

3 sheets51 lines
  1. TypeScript Types Quick ReferenceMost reached forThe type-system features you actually use — unions, generics, utility types, narrowing, and the syntax that trips people up.18 lines
  2. React Hooks Quick ReferenceEvery core hook, what it is for, and the rules and gotchas that cause most React bugs.15 lines
  3. CSS Flexbox & GridStop guessing at layout. The properties that actually center, distribute, and arrange things — flexbox for one dimension, grid for two.18 lines

The ground under the code

What an operation costs — asymptotically, structurally, and in the real milliseconds and bytes a machine spends.

What an operation costs

The growth rate, the structure that gives you that growth rate, and then the only one with units on it — real milliseconds and real bytes.

3 sheets59 lines
  1. Big-O ComplexityMost reached forTime and space complexity of the data structures and algorithms you use every day.17 lines
  2. Data Structure ComplexityThe full time/space table for every structure you reach for — average and worst case, at a glance. The interview reference.20 lines
  3. System Design Napkin MathThe latency numbers, constants, and powers of ten for back-of-the-envelope estimates.22 lines

The classics, by pattern

Sorts, graph traversals and the dynamic-programming shapes — recalled as patterns rather than re-derived under interview pressure.

3 sheets55 lines
  1. Sorting AlgorithmsMost reached forEvery common sort at a glance — time, space, stability, and which one to reach for.19 lines
  2. Graph AlgorithmsTraversal, shortest paths, and spanning trees — with the one to reach for in each case.17 lines
  3. Dynamic Programming PatternsThe DP recipe, the classic templates, and how to recognize a DP problem in the wild.19 lines

In front of the customer

The forward-deployed half of the job: the questions you ask in the room, and everything between a demo and a production deployment.

Questions asked in a room

The shape of the job, what to ask a customer before scoping anything, what a demo has to survive — and what they will ask you.

4 sheets101 lines
  1. The Forward Deployed Engineer PlaybookMost reached forThe whole role on one sheet — discover the problem, prototype fast, integrate, deploy in the customer’s world, demo, harden, hand off.15 lines
  2. Customer Discovery QuestionsThe questions that surface the real problem, the constraints, and the definition of success — before you write a line of code.17 lines
  3. The Demo ChecklistA demo is a performance, not a code review. Prep it, run it, and recover from live failure — then follow up while it’s hot.16 lines
  4. The FDE Interview Question BankFifty-plus reported Forward Deployed Engineer interview questions across all nine round archetypes — each with the model answer shape and a link to practise it.53 lines

From demo to deployed

The integration that broke, the environment it has to run in, the compliance answer, and the checklist that says it is really done.

4 sheets67 lines
  1. Integration Debugging PlaybookMost reached forWhen the API call, webhook, or auth handshake fails at the customer’s edge — the systematic checklist that finds it fast.17 lines
  2. Deployment Targets (Cloud → Air-Gapped)Where will it actually run? The tradeoffs across SaaS, the customer’s cloud/VPC, on-prem, and air-gapped — and what each costs you.19 lines
  3. Security & Compliance Quick-Ref (FDE)Enough to earn a security team’s "yes": what SOC 2 / HIPAA / GDPR actually ask, how to handle data and secrets, and what reviews check.15 lines
  4. POC → Production ChecklistThe gate a demo must clear to become a system people depend on: reliability, observability, security, and a real handoff.16 lines

Built for the lookup, not the lesson.

When you already know it

A cheatsheet is for the thing you understand but can't recall on the spot — the exact flag, the complexity of that operation, the status code, the p99 you should expect. Reach for it mid-task, grab the one line, get back to work.

When you're still learning it

If a row raises more questions than it answers, that's the signal to go deeper — most sheets link out to the handbook, lab, or system design that explains the idea in full. Skim the sheet first, then follow the thread.

Why the shelves are ordered this way

Everywhere else on this site, rung N assumes rung N-1 — those are things you work through. A cheatsheet isn't: it's consulted mid-task. So a shelf is ordered by how often you reach for it, which is why git opens its shelf and git rebase closes it.