❮ Blog · Announcement · Nix
July 7, 2026 — 5 min read
Learn Nix on a real VM that's yours to break, with chapters built around the failures everyone hits and checks that inspect what actually ran on the box.
Nix does something almost no other tool does. It turns packages, development environments, and builds into versioned code. NixOS carries the same idea all the way to the machine: configuration, services, and system state described in files, then rebuilt from that description. Once that clicks, it's hard to unsee. Reproducibility stops being a slogan; every environment or machine you can't rebuild from a file starts to look like technical debt.
The catch is getting there. The documentation is terse. The answers are scattered across two decades of forum threads, blog posts, and tutorials, many of them written before flakes. Almost every example assumes context you don't have yet. The power is obvious from day one. The path from "I installed it" to "I actually get this" is not.
LabCraft is a guided Nix lab environment built around that gap. You get a real VM, work through chapters on the machine itself, and each step is checked against what actually happened on the box. It is not a quiz. It is not an emulator in a browser tab. It is a machine you can break, repair, rebuild, and understand.
That means the course can teach the messy parts directly. A lab can ask you to
run nix, watch it fail because your shell is not loading the right profile,
fix the environment, and then prove the repair by checking the commands that
actually ran. You are not memorizing an answer. You are learning what a broken
Nix setup looks like from the inside.
I know why that matters, because I've walked that path. I met Nix in 2020, on a team that used it as the backbone of every build. After years of Chef and Ansible, the pitch clicked in about a minute. The learning curve took much longer. Grit helped for sure. But what actually got me through was much rarer: colleagues who had been at this for years, just a Slack message away. Every wall I hit, they had hit before, and they didn't just hand me fixes. They looked at my broken build and explained what the system was doing underneath, while all I could see was the error. That's the difference between an answer and understanding. I would not have gotten fluent without it.
Most people learning Nix don't have colleagues like that. Every organization I've championed Nix at has followed the same pattern. People without a firm footing in the shell bounce off the curve. So do some who have one. The ones who persist get through the way I did: they lean on the few engineers who already speak Nix. That works. It worked for me. But it puts the load on a handful of people, and it spends the organization's most expensive hours on questions a good learning path would have answered.
LabCraft is my attempt to build that colleague at the next desk, for everyone learning Nix without one. The first course is for engineers who can work in a terminal and edit files, but do not yet have the Nix mental model that makes its errors legible.
Why Nix is hard, and worth it
Nix isn't hard by accident. It changes ideas you already have habits around. Packages and configurations become immutable artifacts instead of files strewn across the system. Builds become pure functions of their inputs instead of scripts that mutate a machine. An environment becomes something you compose and throw away instead of something you install and maintain.
That's why reading about it only gets you so far. You can follow every word of a
flakes explainer and still freeze the first time your own build dies with
infinite recursion encountered.
AI hasn't changed this. A model will write your flake in seconds, and it can often patch a broken build. What it can't do is understand the system for you. That judgment still comes from seeing failures, forming a model, testing it, and knowing why the fix worked. That's the work LabCraft is built around.
You learn Nix where it fails
Everyone who learns Nix hits the same walls. The install finishes and nix
still isn't on your PATH. The tutorial says nix run and your shell says
experimental feature 'nix-command' is disabled. Your build fails with an error
that seems to assume you already know the answer it's pointing at.
Most people hit these moments alone, at the worst possible time. Many walk away.
LabCraft puts those failures directly in the path. You meet them where they naturally occur, with enough context to understand what the system is telling you. Work through an error once in a place built for it, and it stops being a wall. It starts being information.
What you actually get
You get a real machine: a VM with its own kernel, not an emulator in a browser tab. Push it as far as you like. Nothing you care about is on the line. When you finish a step, the check looks at the commands that actually ran on the machine and how they exited, not a quiz answer. Each step builds on the one before it instead of dropping you at a blank prompt.
The labs are held to a standard too, the one Nix itself teaches. A course about reproducible systems goes stale the way unpinned dependencies do. Upstream moves, and the instructions quietly stop matching the tools.
So the course is built like the thing it teaches. The labs pin the versions they teach, and the course content is tested as code: every change is validated in CI before it reaches a learner. That matters because a stale tutorial doesn't just waste your time. It leaves you unable to tell whether a failure is your mistake or the tutorial's.
Why Nix first
Nix is a language, package manager, build system, and operating-system foundation all tangled together. That is why it is powerful, and why beginners get lost. If LabCraft can make Nix approachable without sanding off what makes it powerful, it can teach almost anything in infrastructure.
So it starts here. Where it goes next depends on what people want.
LabCraft is opening in small batches. The first seats are for the Nix course, with access paced while the VM capacity, checks, and content settle. If you want in on the first wave, put your name down below and I'll start inviting people as seats become available.