ScaffoldKit + DevKit Bundle vs Docker Dev Containers vs GitHub Codespaces: Where Should Your Dev Environment Live in 2026?

Every new project starts the same way: hours of setup. Install the runtime, configure the linter, wire up the Dockerfile, hand-craft the dotfiles, hope the YAML is right. Do that ten times a year and you have lost days of work to tasks that add zero product value.

In 2026 there are three mainstream answers to “where should my dev environment live”: a local-first tooling stack you configure once (the ScaffoldKit + DevKit approach), containerized dev environments that run in Docker on your own machine, or cloud-based environments that stream from a remote VM. They are not interchangeable, and the right choice depends on how you work, what you build, and who pays the bill.

This post compares the three honestly: what each approach does well, where it hurts, and what it actually costs.

What the three approaches actually are

Local-first tooling means your environment lives in your shell config and your project scaffolding. You install a CLI scaffolder that generates production-ready project skeletons, and a dotfiles package that configures your terminal, Git aliases, and Docker helpers once. Everything runs on your laptop, works offline, and costs a flat one-time fee. The Ezra Labs bundle is the concrete example: ScaffoldKit (the project scaffolder, $39 alone) plus DevKit (the environment starter pack, $9 alone), sold together for $45 — a one-time purchase with free updates, on Linux, macOS, and Windows (WSL).

Docker Dev Containers push the environment into a container definition. A devcontainer.json file plus a Dockerfile describes the exact toolchain, and VS Code (or another IDE) opens the project inside that container. Every contributor gets the identical environment because the definition is committed to the repo. Docker Engine is free and open source on Linux, and Docker Desktop is free for individual developers and small businesses, so the local tooling cost is close to zero — the cost is the time you spend writing and debugging container definitions, and the disk and RAM your containers consume.

GitHub Codespaces is the cloud option: a dev container that runs on GitHub’s infrastructure and streams to your browser or IDE. There is nothing to install locally, and you can work from any machine. It is billed per compute hour and per gigabyte of storage: 2-core compute runs about $0.18 per hour, and storage is about $0.07 per GB-month. GitHub Free includes 120 core-hours per month (about 60 hours of 2-core runtime) plus 15 GB of storage; GitHub Pro includes 180 core-hours plus 20 GB. Go over the included quota and the metered rates apply — and the meter runs while the environment is open, even if you are idle.

Where local-first tooling wins

The local-first approach has two structural advantages: it is a one-time cost, and it never depends on a third-party service.

Predictable pricing. The bundle is $45 once. Codespaces is a recurring meter: even with the free quota, a team of five burning through 120 core-hours a month each will hit overage billing, and the per-minute meter charges while environments sit open. Docker Dev Containers are locally free but the setup time is real — writing a correct devcontainer for a non-trivial stack takes an afternoon the first time, and debugging a broken container image is a skill of its own.

It works everywhere, including offline. A scaffolded project plus configured dotfiles runs on any machine with the tools installed. You are not locked to a cloud provider’s availability, and you do not need a network connection to start work. For a freelancer on a client site with dodgy Wi-Fi, that matters.

Scaffolding is a different job than containerizing. A dev container answers “what versions and services does this project need?” — it does not answer “what should the project structure look like?” ScaffoldKit answers the second question: it generates complete, production-ready project directories for Python (FastAPI), Node.js (Express), and Go, each with a multi-stage Dockerfile and docker-compose.yml, GitHub Actions CI/CD, testing frameworks (Jest + Supertest, pytest, Go testing setup), linting presets (ESLint, Prettier, ruff, golangci-lint), environment files, a Makefile, and an .editorconfig and .gitignore. DevKit then handles the machine layer: terminal dotfiles, Git aliases like git-cleanup and git-sync, and Docker helpers like docker-cleanup and docker-prune.

The two tools answer the two questions that slow down every new project: “what’s the project structure?” and “what’s my environment?” That is why they ship together.

Where Docker Dev Containers win

If your pain is team consistency — different laptops producing different behavior — dev containers are the strongest answer. The container definition is version-controlled, so “works on my machine” becomes “works in the container.” That is a genuine win for teams of any size, and the container ecosystem is mature.

The trade-offs: container definitions are another thing to maintain, local containers consume significant disk and RAM, and Docker Desktop’s free tier is limited to individuals and small businesses (companies above the size threshold need paid subscriptions). Also, a container gives you the runtime environment but not the human environment — your shell config, aliases, and Git shortcuts still live outside the container unless you wire them in yourself.

Where GitHub Codespaces win

The cloud pitch is real: zero local setup, work from any device, and environments that match the repo definition automatically. If you switch machines often, or if a team member’s laptop dies mid-sprint, a Codespace is the fastest way back to productive.

The costs are the meter, the data, and the dependency. Billing runs while environments are open — an idle 2-core environment left running overnight burns roughly $1.44 of compute. Your code and tooling live on GitHub’s infrastructure, so an outage or a network problem stops work. And for organizations, the per-developer bill scales with every hour of usage, which makes cloud environments an operating expense rather than an asset.

The honest comparison

• One-time cost: local-first tooling (bundle $45 once) beats Codespaces’ per-hour meter and Docker Desktop’s paid tiers for larger companies.
• Team consistency: dev containers win — committed definitions mean identical environments.
• Fastest start on a new machine: Codespaces wins if you have a network; the local bundle wins if you do not.
• Offline capability: local approaches (tooling or containers) win outright.
• Setup effort: the bundle is one install and one command (scaffoldkit init my-project --stack=fastapi, then make dev). Dev containers require writing and debugging a definition. Codespaces requires configuring the environment definition and a payment method for overage protection.
• Project quality: ScaffoldKit bakes in CI/CD, tests, linting, and Docker setup at generation time, so the project skeleton is production-ready before you write your first feature.

The verdict

If you are a freelancer, an engineer who sets up a new laptop more than once a year, or a small team that wants consistency without a platform team, the local-first bundle is the best value: one payment, works offline, and the scaffolder eliminates the most error-prone part of starting anything new. The workflow — install DevKit once, then scaffoldkit init for every new repo — keeps your tooling consistent across machines and projects, which is exactly what a developer environment should be.

Choose dev containers when your team’s core problem is environment drift on shared codebases. Choose Codespaces when you genuinely live across machines and your budget can absorb a recurring meter.

For most developers, the math is simple: the ScaffoldKit + DevKit Bundle costs $45 once, and it pays for itself the first time it saves you from re-creating your .zshrc from memory. If you already own the scaffolder, DevKit is the $9 environment starter pack that completes the setup. And if you just want to browse everything, the Ezra Labs shop has the full lineup.