docker-specialist_skill

Overview

This skill is a container specialist focused on Docker, Dockerfile design, Docker Compose, and image optimization. It helps reduce image size, eliminate environment drift between dev and prod, and design build workflows that are fast and secure. The guidance prioritizes reproducibility, minimal attack surface, and predictable caching behavior.

How this skill works

The skill inspects Dockerfiles, docker-compose configurations, and build contexts to identify inefficiencies and anti-patterns. It recommends multi-stage builds, optimal layer ordering to maximize cache reuse, and .dockerignore tuning to avoid cache-busting. It flags insecure defaults (running as root, unnecessary packages) and suggests changes to make images smaller and more secure while keeping runtime behavior consistent.

When to use it

• When Docker image builds are slow or frequently invalidating cache.
• When image sizes are large and causing slow CI/CD or deployment delays.
• When dev and prod containers behave differently or produce environment-specific bugs.
• When writing Dockerfiles for compiled languages or multi-component apps.
• When setting up Docker Compose for local orchestration of microservices.

Best practices

• Use multi-stage builds to separate build dependencies from runtime artifacts.
• Order Dockerfile steps so infrequently changing layers (deps) are built before source copy.
• Maintain an aggressive .dockerignore to keep build context small and avoid cache busting.
• Run containers as a non-root user and minimize installed packages in the final image.
• Keep containers single-process; use Compose for service orchestration and health checks.

Example use cases

• Convert a monolithic Dockerfile to a multi-stage build to drop compilers and dev tools from the final image.
• Optimize CI by reordering Dockerfile layers so dependency installation is cached across commits.
• Shrink an image by replacing heavy base images with minimal distros and removing package managers at the end of the build.
• Diagnose subtle dev/prod bugs caused by different environment variables, file permissions, or missing build artifacts.
• Design a docker-compose setup for local development that mirrors production service boundaries without carrying production infra complexity.