DEV Community: Lucky Slevin Kelevra

The Missing Manual for Developers Just Got Significantly Better

Lucky Slevin Kelevra — Sun, 12 Jul 2026 12:35:04 +0000

If you've ever shipped code for years but still felt shaky on why things actually work the way they do — or struggled to explain legacy systems, survive your first on-call, or prepare for system design interviews — you're not alone. Most tutorials teach you how to use tools. Very few teach you how the underlying systems really behave.

The Missing Manual is one of the best free resources trying to fix that. It offers clear, in-depth guides that explain how software actually works — from how your computer boots to how databases handle concurrency, how the web renders, and how AI models are trained.

350+ guides across 27 topics. Free forever. No account required.

And in the last few weeks, it received a wave of meaningful updates that make it even more practical.

Hands-On Practice That Actually Checks Your Work

The biggest new addition is Practice — a set of browser-based coding lessons where you write real code and get instant feedback.

You can now work through dedicated modules for:

SQL (queries against a real in-browser database)
JavaScript
Python
TypeScript
Regex
Git (real commands in an in-browser terminal)
Postgres (advanced features like JSONB, upsert, etc.)
Math and Physics (plugging numbers into actual formulas)

Each module has its own overview page and lesson sidebar so you can see exactly what's left and jump around easily. No setup, no accounts, no "download this repo and install these dependencies." Just open the page and start coding. The three-panel playground (task + editor + results) makes it feel like a focused, low-friction coding environment.

This is the kind of deliberate practice that actually builds intuition.

Better Retention and Personal Learning Tools

Learning is useless if you forget everything a month later. The site has always had a Review system (spaced repetition cards generated from guides and quizzes). Now it includes:

Optional review reminders so you actually get nudged when cards are due
Practice streaks visible on the Review page

There's also a new private notes feature: highlight any passage in a guide and add your own notes. Only you can see them. It's like having a personal margin in every guide for the connections and questions that matter to you.

The Human Side of the Job (Finally Treated Seriously)

One of my favorite additions is the new Working as a Developer category. It covers things that are rarely taught well:

Code Review Etiquette
Reading Legacy Code
Asking Good Questions
Your First On-Call
Technical Interviews

These guides acknowledge that being a good developer isn't just about technical knowledge — it's also about communication, judgment, and navigating real work situations.

Content That Closes Real Gaps

Web Fundamentals got 10 new guides covering HTML, CSS, layout, the DOM, forms, rendering, responsive design, accessibility, and browser storage.
Advanced capstone guides were added to Logic, Physics, Security, No-Code, Web Fundamentals, Working with AI, and Programming Concepts.
New "front-door" guides for Tools & Frameworks explain what tooling actually is and how to choose your first framework without getting overwhelmed.

Quality-of-Life Improvements That Matter

Every guide now has a direct "Edit on GitHub" link so you can quickly fix typos or suggest improvements.
You can download any guide as an EPUB for your e-reader.
The lofi player (great for deep focus) is now much more usable on mobile with a proper full-screen sheet.
Word Search expanded from 6 topic packs to 22 (Networking, Databases, Math, Physics, and more).
The AI tutor now shows which guides it referenced for an answer and lets you ask "why?" when you get a quiz question wrong.
There's a new public backlog where you can vote on what should be written next, based on actual reader searches and requests.

Why This Matters

In an era where AI can write a lot of code for us, the developers who will thrive are those who deeply understand the systems they're working with. The Missing Manual is one of the few places building that kind of foundational understanding without requiring a computer science degree or a $200 textbook.

It's not trying to be another framework tutorial site. It's trying to be the manual that was missing when you needed to understand what was actually happening under the abstractions.

If you've ever thought "I wish someone would just explain this clearly," there's a decent chance they already have — or will soon, thanks to the public backlog.

Try it here: The Missing Manual

Start with the Practice section if you want to get your hands dirty immediately: https://themissingmanual.dev/practice

Or browse the new Working as a Developer guides if you're looking for wisdom beyond syntax.

What topic do you wish had a really good "missing manual" for? The team seems genuinely interested in building what people actually need.

A better kind of memory for your AI Agents

Lucky Slevin Kelevra — Sat, 04 Jul 2026 01:35:11 +0000

Everyone is excited about Claude + Obsidian right now.
It feels like progress. You keep notes in one place and feed them to your AI. It's convenient.
But it's not memory.
Real memory doesn't just store what you wrote. It remembers for you across every AI you use. It understands what matters today versus what mattered last year. It connects ideas by meaning instead of keywords.
And it protects what's private without you babysitting every prompt.
Obsidian + Claude is still just a smarter notebook plus context stuffing.
You end up repeating yourself. You leak details you didn't mean to share. And you pay token taxes to re-read entire documents every single time. The memory still lives half in the cloud vendor's world, not fully yours.

That's why I built something different.

It's a private, local memory layer you own completely.
One encrypted file on your machine. No accounts, no telemetry, no vendor lock-in.
Tell any connected AI once that you drink oat milk, live in Berlin, or that your cat is Pixel, every AI remembers, forever. Memories are linked by meaning, not strings. "What do I drink?" surfaces the right answer even if the wording has changed. "Where do I live today?" ignores last year's Lisbon entry. A local firewall sits in front of every AI call. It redacts sensitive information, respects your private flags, and gives you a signed receipt of exactly what was shared. You can watch live which memories are being touched.
For documents, it uses structured understanding (we call it SemGraph).
Drop in a 50-page note. The AI reads a cheap outline first, then only the relevant section. Same quality answers at roughly 29% of the tokens.
You can open the memory graph, explore it, edit it, delete anything or ask AI agent to do so.

The black box, turned glass.

This isn't another note-taking hack. It's the memory layer your AIs have been missing: private, semantic, cheap to read, and fully under your control. If you're tired of renting fragments of context from different providers and want memory that actually feels like yours, I'd love to show you what we've built.

🚀Launching soon

Early access list will be opened soon for those who want the real thing.

Big update on The Missing Manual

Lucky Slevin Kelevra — Fri, 03 Jul 2026 23:22:59 +0000

🚀Big update on The Missing Manual
I just added a free AI Tutor to every single guide and learning path on
The Missing Manual
No paywall. No account. No limits.
Whether you're: Just starting from zero - Going deep into how computers, networks, databases, or AI actually work - Or trying to finally make things stick...

Completely free, forever. Happy learning! 💡
P.S. Interactive Animated Explainers are coming very soon!

What nobody tells you about the N+1 query problem

Lucky Slevin Kelevra — Thu, 02 Jul 2026 21:07:37 +0000

Your app was fast in dev. Then it shipped, and one screen started timing out. The bug is not in the code you wrote. It is in the code your ORM wrote for you, one row at a time.

This is the N+1 query problem, and it is the most common way a working backend quietly turns slow. Here is the mental model nobody hands you, and how to fix it without memorizing one library's API.

Why this trips people up

Tutorials teach you the ORM syntax. They rarely teach you what the ORM actually does on the wire. Docs assume you already know that "lazy loading" is a database query. So you write the natural-looking loop and ship a time bomb.

The core idea is simple and easy to miss. When you fetch a list of objects and then touch a relation on each one, most ORMs run a fresh query for that relation every single time. Ten rows means eleven queries. A thousand rows means a thousand and one. Each query on its own is cheap. The round trips are not. Your laptop runs the ten-row version instantly, so you never feel it. Production, with real data, is where it bites you at 3am.

There is a second reason it hides so well. The code looks innocent. Accessing order.customer reads like a field, not like a network call. Nobody reviews it and thinks "database round trip." They think "property access." That is the trap.

How it actually works

Say you have orders, and each order belongs to a customer. You want to list the order number and the customer name. The natural code looks like this:

orders = Order.all()
for order in orders:
    print(order.number, order.customer.name)

That order.customer access reads like a field. It is a query. Order.all() is query number one. Then every order.customer.name is another query. So for N orders you run N+1 queries, and most of them fetch a single row you could have joined.

On the wire, the loop above produces this:

SELECT * FROM orders;                  -- query 1, the list
SELECT * FROM customers WHERE id = 42; -- query 2, first row's customer
SELECT * FROM customers WHERE id = 43; -- query 3, second row's customer
-- ...and so on, one per row

The fix is eager loading: tell the ORM to fetch the relation up front, in the first query or one extra query, instead of one query per row. Every major ORM has it, under different names:

Django: Order.objects.select_related('customer') (a JOIN, one query)
Rails: Order.includes(:customer) (one extra query, not one per row)
SQLAlchemy: session.query(Order).options(joinedload(Order.customer))
Prisma: prisma.order.findMany({ include: { customer: true } })
EF Core: dbContext.Orders.Include(o => o.Customer)

The naming changes. The idea is identical: load the relation eagerly, not lazily.

There are two flavors and the choice matters. A JOIN folds the relation into the first query, so you pay one round trip. Use it for one-to-one and many-to-one relations, where each parent has exactly one related row. A batched WHERE id IN (...) query runs one extra query that pulls all the related rows at once. Use it for collections, where a parent has many children, because a JOIN on a collection multiplies rows and ships the same parent over and over.

What to do about it

Make the problem visible. Turn on query logging in dev and watch the count for a single request. If one page prints forty queries, you have an N+1, or several.
Eager load the relations you actually display. Use a JOIN (one query) for one-to-one and many-to-one relations. Use a batched WHERE id IN (...) query (one extra query) for collections, so you do not multiply rows.
Watch for the fix that makes a new problem. Joining a collection multiplies rows, so one parent can come back many times. ORMs dedupe in memory, but the database still ships the bloat over the wire. For collections, prefer the batched IN approach over a raw JOIN.
Measure before you optimize. An N+1 that runs twenty times a day is a smaller fire than one that runs inside a hot loop two hundred times a second. Fix the ones on the hot path first.

Be honest about the catch: eager loading is not free either. Pulling relations you never render is its own waste. Eager load what you show, not everything the model knows.

A worked example

Before the fix, loading fifty orders with their customer names runs fifty-one queries. The first fetches the orders. The next fifty each fetch one customer by id. On a local database with empty tables that is instant. On a shared production database under load it is the request that times out.

After the fix, the same page runs one query with a JOIN:

SELECT orders.*, customers.*
FROM orders
JOIN customers ON customers.id = orders.customer_id;

Same data on screen, one round trip instead of fifty-one. That is the whole win.

Go deeper

The full, free walkthrough (no signup) is here:
The Missing Manual

And every guide page has a free AI Tutor you can ask follow-up questions, right there on the page. If your stack's eager-load syntax is not in the list above, ask it.

Stop writing loops that run a query per row. Your future self, the one on call, will thank you.

A local AI chat app in a single HTML file. No build, no sign-up.

Lucky Slevin Kelevra — Sun, 28 Jun 2026 18:46:15 +0000

A local-first AI chat app in a single HTML file. No build, no sign-up.

Models it supports:

On-device: Chrome's built-in Gemini Nano / Gemma. Fully offline,
nothing leaves your machine.
Ollama: any model you've pulled locally.
Cloud: OpenRouter, Groq, Cerebras, Mistral. Free/Paid tiers work.

Each chat remembers its own model, and you can run one prompt on two models side by side to compare them.

What you can do:
• Attach images, audio, PDFs, and text/code files and ask about them
• On-device tools: translate (16 languages), summarize, proofread, rewrite, expand a note into a draft
• Voice input and read-aloud
• Personas and saved prompts, with "/" slash commands
• Command palette, multiple conversations with search / pin / rename
• Markdown with tables and code blocks, edit-and-resend, regenerate

Conversations live in your browser (IndexedDB), API keys stay local, with one-file backup export/import. It also installs as an PWA.

There's a Learn button in the header too. It opens The Missing Manual a free web site I run for learning programming, tech, math, and logic. Free and No ads.

GitHub: X-Chat
Learn: The Missing Manual

The Missing Manual: 160+ free Dev guides on debugging, Programming, infrastructure, AI and more

Lucky Slevin Kelevra — Wed, 24 Jun 2026 21:21:18 +0000

There's a specific kind of bad documentation that I think we've all suffered through.

You search for "what is a goroutine" or "how do database transactions work" and you get one of two things: either a six-page academic paper that assumes you already know the answer, or a tutorial so watered-down it covers nothing real.

What you actually want is someone like that senior engineer at your company the one who, when you finally work up the nerve to ask a dumb question, sits down and actually explains the thing. Not just the what, but the why. Not just the happy path, but the part where you'll get confused at 2am and what to do about it.

I've been building that resource. It's called The Missing Manual.

Here's the pitch in one sentence: it's a free, growing library of developer guides written like advice from a battle-hardened friend who genuinely wants you to understand the thing, not just copy the code.

Some examples of what's in there right now:

Reading a Stack Trace at 2am — starts with "that wall of text is not an attack, it's a map," then teaches you the four-step method that works in Python, JavaScript, Java, or whatever you're using. Includes the site-packages/ vs your-own-code trick that turns 40-line traces into 2-line ones.
Go From Zero - covers the basics, but also the deep stuff that most Go tutorials skip: what the GMP scheduler actually does, how escape analysis decides what lives on the heap, why goroutines are cheap in a way OS threads aren't. Mental-model-first, the whole way through.
Docker Without the Magic - doesn't just show you docker run. Explains what a namespace and a cgroup actually are, so when Docker does something weird, you have somewhere to start.
Why Is My Query Slow? - the real answer, including EXPLAIN, index cardinality, the N+1 problem, and what "using index" in a query plan actually means vs what you want it to mean.

There are 160+ guides across debugging, databases, infrastructure, networking, APIs, AI/ML, performance, and programming languages, coding playgrounds,quizzes, learning path and games for brain

A few things I deliberately tried to avoid:

No "In this tutorial, we will..."
No explaining what you're about to explain. Read the error type and message. Here's what it looks like. Here's what it means. Done.
No skipping the hard bit. Every good piece of documentation has a moment where the author clearly said "this part is complicated, I'll wave my hands." I tried to find those moments and sit in them longer, not shorter.
No pretending the path is clean. The stack trace guide has a war story about a teammate who spent 20 minutes reading a trace top to bottom, convinced the bug was deep in the ORM, when it was three lines from the bottom in their own file. The lesson lands better with the story.

The platform itself runs on a Rust back-end (axum + Tantivy full-text search) and a SvelteKit front-end and using Cloudflare's AI Search for more natural language search.

The search actually works and you can type "goroutine leak" or "explain joins" and land where you need to.

It's free. No account required to read. No paywall.

If you've ever had the experience of finally understanding something properly because someone explained it the right way, not just showed you the command, that's what I'm going for.

The Missing Manual

Drop a comment with a topic you've always wanted explained like this. I'm actively adding guides and the request list genuinely shapes what gets built next.

Tips for reading: jump straight to the phase you need. Every guide is organized into phases and marked with difficulty badges (Beginner → Advanced), so you can skip the sections you already know and focus on what's most relevant to you.

Also, please share your feedback. Every suggestion, correction, and idea helps shape the final product I'm working to build.