Run Your AI Coding Agent in Dev Containers - Complete Beginner's Guide

Key Takeaways

• Dev Containers create isolated, reproducible development environments that include all dependencies for a project
• You need two things to use dev containers: the Dev Containers VS Code extension and a container runtime like Docker Desktop
• The .devcontainer/devcontainer.json file defines everything needed: base image, extensions, port forwarding, and post-create commands
• AI coding agents execute commands inside the container, creating a safe sandbox separated from your local machine
• Port forwarding automatically exposes services running in the container to your local machine
• GitHub Codespaces uses the same dev container configuration to spin up cloud-based development environments
• You can have project-specific environments (Node, Python, .NET, Go) without installing those dependencies on your host machine

Summary

The Problem Dev Containers Solve

Developers often work on multiple projects with different technology stacks. Installing Node, Python, .NET, Go, and their respective dependencies all on one machine creates conflicts and clutter. Additionally, when AI coding agents execute commands, there's a security concern about what they can access on your local system.

Dev Containers solve both problems by creating self-contained, isolated environments that bundle all project-specific dependencies, run on any machine with Docker, keep your host machine clean, and provide a secure sandbox for AI agents to execute code.

Setting Up Your First Dev Container

Prerequisites:

1. Install the Dev Containers extension in VS Code
2. Have Docker Desktop (or another container runtime) running

Quick Start with Samples:

1. Open the Remote Explorer in VS Code
2. Try a sample container (C++, Go, .NET, Node available)
3. VS Code clones the repo and downloads the container image automatically

The presenter demonstrates with a Go sample project. After the container starts, the terminal runs inside the container (shows Linux environment), extensions are split between "Locally Installed" and "Dev Container" sections, and running go version confirms Go is installed in the container, not on the host.

Understanding devcontainer.json

The configuration file at .devcontainer/devcontainer.json defines:

{
  "name": "Node.js",
  "image": "mcr.microsoft.com/devcontainers/javascript-node:22",
  "forwardPorts": [5173],
  "postCreateCommand": "npm install",
  "customizations": {
    "vscode": {
      "extensions": ["dbaeumer.vscode-eslint"]
    }
  }
}

Key configuration options:

• image: Base container image to use
• dockerFile: Alternative to image—use a custom Dockerfile
• forwardPorts: Ports to expose from container to host
• postCreateCommand: Commands to run after container creation (e.g., npm install)
• customizations.vscode.extensions: VS Code extensions to install in the container

Running AI Agents Inside Dev Containers

When you use GitHub Copilot or other AI coding agents inside a dev container:

• All commands execute in the isolated container environment
• File operations stay within the container's filesystem
• The agent can't accidentally modify your host system
• You get a "safe experimentation" zone

The presenter demonstrates asking the agent to explain the Go project and add a new /env route—all happening safely inside the container.

Adding Dev Containers to Existing Projects

1. Open your project in VS Code
2. Click bottom-left corner → "Add Dev Container Configuration Files"
3. Choose where to store: user data folder or workspace (choose workspace to commit to git)
4. Select a template (Copilot suggests based on your project type)
5. Choose runtime version and optional features
6. Let Copilot customize the configuration based on your package.json

The presenter adds a Node.js dev container to their "MCP Badge Creator" project, and Copilot automatically configures port forwarding for the Vite dev server, post-create command for npm install, and relevant VS Code extensions.

GitHub Codespaces Integration

The same devcontainer.json works with GitHub Codespaces:

1. Push your dev container config to your repository
2. On GitHub, click "Code" → "Codespaces" → "Create codespace"
3. GitHub builds the container in the cloud
4. You get a full VS Code experience in your browser
5. Ports are automatically forwarded through GitHub's infrastructure

This enables instant development environments on any device, no local Docker required, team members get identical environments, and works from tablets, Chromebooks, or borrowed computers.

Notable Quotes

"Wouldn't it be awesome if either when I'm coding or an agent is executing commands that everything is happening completely separated off from my machine, creating a safe environment for me to do any type of work in any experimentation?"

"Not only do they enable you to create an on-the-go development environment, they can literally boot up on nearly any machine in minutes, but everything is completely self-contained inside of that container, making it a clean separation from your local machine."

Chapters

References

• Original Video on YouTube
• Dev Containers Specification
• VS Code Dev Containers Documentation
• Mentioned: Docker Desktop, VS Code Dev Containers Extension, GitHub Codespaces, GitHub Copilot, Vite