Section

cloud-devops

Kind

Editorial

Reading time

5 min

Updated

8 September 2026

Making 'It Works On My Machine' Reproducible With Development Containers

The "works on my machine" reasoning is a familiar just-so story, a placeholder for the harder-and-harder-to-pin-down "but here's why." An every-day confession often sounds defensive, and with development containers, it can sound like that even when there's something more serious to check.

"Developer containers" are lightweight containers combined with an orchestration tool for a developer workflow. When we say "developer", we mean "produce and test", not "other stakeholders". The case is about reproducing a development environment, not simulating a customer one.

A development container addressable environment takes a runtime, tools, libraries and a volume mounted working set, and leaves the rest for traditional static tools. So the container doesn't package up the entire desktop image and all settings, just the software stack needed for a specific project. Outputs are persistent beyond the development container's existence, in line with the codebase.

Each working member can use their preferred development machines, and still use the same container environments. Members can refuse this container use, though, if they believe issues may result from the host machine's attributes, like a Windows implementation detail or a hardware graphics chip. So the container eliminates "the project" from the picture, but not the host and account.

What a dev container actually defines

Developer containers are meant to make environments close to repeatable with minimal initial setup. The Development Container Specification, is part of an open standard called the Development Container Specification. It describes development containers as environments for coding applications, defined in a machine-readable format, that can be generated or fetched.

The spec sets what's in a development environment, but lets the development container producers do the implementation. It gives container producers choices, allowing flexibility in implementation.

A development environment can have one or more development containers and any needed side-car containers, usually for performance rather than function. Each user can kind of tailor the configuration, with masks instead of mounts and tools instead of settings. Because container builds can share layers and environments can share containers, the team may save resources. Each team member doesn't need their own dedicated build space, though schedules may collide.

Each localization grabs new or modified files for that project or team, even nested repos, while holding environment gotchas and builds in a volume. Read/write tools look local, even though they're actually looking at the base image. That may be less noticeable in code that doesn't need to read its own writes, but for effectiveness, dev containers need the local toolchains to be full.

Production machines and dev machines operate independently; likewise dev containers and the editor local to the developer. While the container may change, even to a different host OS, the user interface stays where it was. The user isn't trapped in VBScript.

What the spec is trying to solve for teams

[A factual claim on how much time a team loses per build without dev containers, and how much time the approach takes to reach zero, if it does; needs a vendor benchmark or a well-documented jump.]

The Development Container Approach was meant to scale to a development group, not to a whole company or org. It was built for development that's iterative, where the original engine is available to look at in the same way.

Development containers let a development team have custom tooling without needing a VM, or without needing a snapshot-based environment that you can't be sure won't change. The automation layer lets you tool things easily, recasting tooling issues into environment issues, with fast setups and easy supervision.

[Fact about automated or recommended testing in development containers, if the contributors to the spec or the devcontainers implementation have provided this as a recommendation.]

The spec includes ways to run an application in the development container, to separate tools or libraries from the codebase, and to aid in continuous integration and testing.

How the VS Code workflow is wired

[Tech pipelines example of development container usage, if a company has shared their spaghetti or flow diagram, as long as it's from an approved source and not the vendor.]

Visual Studio Code, an editor from Microsoft, is the annotated example of a compliant implementation of the Development Container Spec. When you import a repository that includes a devcontainer.json file, you have an option to open the code in a development container.

The folder structure devcontainer is the new structure. Files that include devcontainer.json are expected, along with an optional Dockerfile or docker-compose.yml to do containerizations. Extensions, develop command, remote extensions, and so on are optional.

[A factual reason why.devcontainer is used, which can include reasoning that starts with "since" or "because"; not a vendor source, but needs to be factually accurate.]

The devcontainer.json file contains settings that orchestrate the dev container lifecycle.

What still remains outside the container

There are several possible failure points for containers, because they can only go so far in containerizing the developer. Some fall outside this approach, some are in the hands of the user, and some are generated singly by the host.

Access to credentials, like tokens or passwords, can create friction. If there's no standard support, users can opt for a briefcase-carry method, now a deprecated commute choice.

OS-level defects, like file-watching limits or differing case sensitivity, seem like edge cases, but might be the grease on the griddle, making the code unstable or inaccurate. Changes might be unreachable, because some packages are only available for some operating systems.

The spec focuses on directly supporting the development toolchain and runtimes, not the entire developer experience.

Cold starts or cache misses can cut into the cycle time of a continuous integration or continuous delivery approach, because when the new layers aren't ready, the coded resources reset. There's a productivity squeeze.

Where this is most likely to fail

Containers can fail in different ways, depending on the host operating system used. On Windows, issues may arise from different directories, file paths, or line endings.

Another possible failure point is with cold starts or cache misses. If the base image is not already available, or if the cache needs to be reset, it can take longer to start up a development container. This can be a problem for teams that need fast iteration.

Containers can also fail due to missing or unsupported integrations, such as with an IDE or a code editor. This can happen if the container does not have the necessary tools or runtime dependencies, or if there is an issue with the integration itself.