What it is in one line
Designing Data-Intensive Applications' hardest ideas, drawn as interactive comics — not illustrations with captions, but a three-layer reader: read the concept, meet the real machine, push the whole system until it breaks.
Who built it
Samuel Xing (GitHub: SamuelXing), a personal project. Nearly every commit carries "Co-Authored-By: Claude Opus" (Opus 4.8/5, 1M context). The human's job is veto and correction — the history shows a "basic view" marked built-and-rejected and "Sam did not like the thing."
Read: one of the most honest specimens of human-plus-model co-writing. The model produces volume; the human does the editing — deleting what is wrong, fixing what is off, setting the standard. The commit history exposes the whole workflow, and that exposure is the project's best documentation.
What it actually does
- Layer one: concept comics — tail latency, B-trees vs LSM, leader & followers, consistent hashing, isolation levels, Raft and more: 12 concepts drawn as short comics
- Layer two: machine deep-dives — 6 of them: Kafka, Postgres, Redis, RabbitMQ, S3, the web/app tier; which ideas each machine is assembled from and where it breaks
- Layer three: system simulations — 2 simulators where requests flow through real services as particles; when arrivals outrun capacity, queues pile up and nodes glow red
- A built-in capacity calculator: put in a workload, get machine counts back, every number traceable to the division that produced it
- Book two, "The Papers That Broke the Database," in progress — 1 of 18 chapters live
Inside the content sits an explicit design system (from the design-skill docs in the repo):
Step.think {q,a} — Socratic question, answer hidden behind a "Reveal"
Comic.inTheWild — 4 real production problems, collapsed by default
Comic.tradeoffs — real decision frameworks, labeled with plain verb tags
The governing principle, one line: depth of thinking != density of prose.
What old behavior it replaces
To understand why tail latency eats 63% of your requests, the old paths were reading 600 pages of the book or scraping scattered blog posts. Both are one-way: reading is passive, and even 3Blue1Brown-style video leaves you able to recite the conclusion but not test it.
The three-layer structure turns "reading" into "read-see-break": concepts via comics, then meet the concept inside Kafka/Postgres, then push it to failure yourself in the simulator. The shift is learning as reception becoming learning as verification.
Business model
Not disclosed. No paywall, no pricing page. The repo license splits "MIT for code, comics and prose reserved" — the content is the asset, and it is not monetized yet.
Read: this behaves like a personal work rather than a business. The real return is the reputation and attention that publishing the methodology buys. The notable decision is the license split — code open, content reserved. The content is the scarce thing; the code is not.
Hard numbers
- HN: 7 points, 0 comments (2026-08-13)
- GitHub: 82 commits, 173 tests, 58 routes
- Book one: 12 concept comics + 6 machine deep-dives + 2 simulations; book two at 1/18 chapters
- A star link on the site points to github.com/SamuelXing/systems-comic; star count not recorded here
Four-way read
| Dimension |
Call |
| Founder-product fit |
The author is a distributed-systems person drawing what he actually knows; not a layman relaying |
| Product insight |
The three-layer read-see-break structure plus three explicit design mechanisms turns educational content from passive consumption into active verification |
| Execution quality |
173 tests, per-page OG cards, clean commit history — more disciplined engineering than most HN submissions |
| Timing |
Educational content is shifting from text-plus-video toward interactive, but tooling is still early; this is an open window |
The call
This is one of the most copyable "AI co-created educational content" workflows around, precisely because the method is exposed in commits and tests rather than asserted.
Three transferable rules:
- Content comes in three layers — concept (comic/metaphor), artifact (real system/case), verification (simulation/exercise). Most educational products stop after layer one.
- Make the design mechanisms explicit — questioning (
Step.think), real cases (inTheWild), tradeoffs (tradeoffs) are reusable components, not per-article improvisation.
- The model owns volume, the human owns the bar — the human vetoes, fixes, and sets the principle "depth of thinking != density of prose." Quality is capped by the person; speed is provided by the model.
The cost: this mode is expensive in human review. Twelve comics sit behind 82 commits and 173 tests; it is not fast. It proves "person plus model" can produce high-quality educational content — not that "the model can auto-produce" it.
What to watch next
① The update cadence of book two (18 chapters) — a sustained project or a one-shot
② Whether anyone publicly copies the mechanisms, especially the Step.think Q&A component
③ Any sign of paid or subscription features — monetizing the content asset would confirm the model holds
What you can take from it
Product logic: give "hard-to-understand content" a three-layer structure — a metaphor layer for intuition, an artifact layer that touches the real world, and a verification layer where the reader overturns the conclusion themselves. A marketer can rewrite a technical whitepaper into this structure.
Pricing structure: none. Not disclosed. The "code open, content reserved" license split is itself a product decision worth stealing.
Verdict
Worth watching. The most solid project in this batch: the method is fully exposed, reproducible, and book two is already testing whether it scales. Write down the three-layer structure and the three mechanisms, and reuse them when building anything knowledge-based.