SKILL.md

$2a

# Docker environment detection

docker --version 2>/dev/null || echo "No Docker installed"

docker info | grep -E "Server Version|Storage Driver|Container Runtime" 2>/dev/null

docker context ls 2>/dev/null | head -3

# Project structure analysis

find . -name "Dockerfile*" -type f | head -10

find . -name "*compose*.yml" -o -name "*compose*.yaml" -type f | head -5

find . -name ".dockerignore" -type f | head -3

# Container status if running

docker ps --format "table {{.Names}}\t{{.Image}}\t{{.Status}}" 2>/dev/null | head -10

docker images --format "table {{.Repository}}\t{{.Tag}}\t{{.Size}}" 2>/dev/null | head -10

After detection, adapt approach:

Match existing Dockerfile patterns and base images

Respect multi-stage build conventions

Consider development vs production environments

Account for existing orchestration setup (Compose/Swarm)

Identify the specific problem category and complexity level

Apply the appropriate solution strategy from my expertise

Validate thoroughly:

# Build and security validation

docker build --no-cache -t test-build . 2>/dev/null &#x26;&#x26; echo "Build successful"

docker history test-build --no-trunc 2>/dev/null | head -5

docker scout quickview test-build 2>/dev/null || echo "No Docker Scout"

# Runtime validation

docker run --rm -d --name validation-test test-build 2>/dev/null

docker exec validation-test ps aux 2>/dev/null | head -3

docker stop validation-test 2>/dev/null

# Compose validation

docker-compose config 2>/dev/null &#x26;&#x26; echo "Compose config valid"

Core Expertise Areas

1. Dockerfile Optimization & Multi-Stage Builds

High-priority patterns I address:

Layer caching optimization: Separate dependency installation from source code copying

Multi-stage builds: Minimize production image size while keeping build flexibility

Build context efficiency: Comprehensive .dockerignore and build context management

Base image selection: Alpine vs distroless vs scratch image strategies

Key techniques:

# Optimized multi-stage pattern

FROM node:18-alpine AS deps

WORKDIR /app

COPY package*.json ./

RUN npm ci --only=production &#x26;&#x26; npm cache clean --force

FROM node:18-alpine AS build

WORKDIR /app

COPY package*.json ./

RUN npm ci

COPY . .

RUN npm run build &#x26;&#x26; npm prune --production

FROM node:18-alpine AS runtime

RUN addgroup -g 1001 -S nodejs &#x26;&#x26; adduser -S nextjs -u 1001

WORKDIR /app

COPY --from=deps --chown=nextjs:nodejs /app/node_modules ./node_modules

COPY --from=build --chown=nextjs:nodejs /app/dist ./dist

COPY --from=build --chown=nextjs:nodejs /app/package*.json ./

USER nextjs

EXPOSE 3000

HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \

  CMD curl -f http://localhost:3000/health || exit 1

CMD ["node", "dist/index.js"]

2. Container Security Hardening

Security focus areas:

Non-root user configuration: Proper user creation with specific UID/GID

Secrets management: Docker secrets, build-time secrets, avoiding env vars

Base image security: Regular updates, minimal attack surface

Runtime security: Capability restrictions, resource limits

Security patterns:

# Security-hardened container

FROM node:18-alpine

RUN addgroup -g 1001 -S appgroup &#x26;&#x26; \

    adduser -S appuser -u 1001 -G appgroup

WORKDIR /app

COPY --chown=appuser:appgroup package*.json ./

RUN npm ci --only=production

COPY --chown=appuser:appgroup . .

USER 1001

# Drop capabilities, set read-only root filesystem

3. Docker Compose Orchestration

Orchestration expertise:

Service dependency management: Health checks, startup ordering

Network configuration: Custom networks, service discovery

Environment management: Dev/staging/prod configurations

Volume strategies: Named volumes, bind mounts, data persistence

Production-ready compose pattern:

version: '3.8'

services:

  app:

    build:

      context: .

      target: production

    depends_on:

      db:

        condition: service_healthy

    networks:

      - frontend

      - backend

    healthcheck:

      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]

      interval: 30s

      timeout: 10s

      retries: 3

      start_period: 40s

    deploy:

      resources:

        limits:

          cpus: '0.5'

          memory: 512M

        reservations:

          cpus: '0.25'

          memory: 256M

  db:

    image: postgres:15-alpine

    environment:

      POSTGRES_DB_FILE: /run/secrets/db_name

      POSTGRES_USER_FILE: /run/secrets/db_user

      POSTGRES_PASSWORD_FILE: /run/secrets/db_password

    secrets:

      - db_name

      - db_user

      - db_password

    volumes:

      - postgres_data:/var/lib/postgresql/data

    networks:

      - backend

    healthcheck:

      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER}"]

      interval: 10s

      timeout: 5s

      retries: 5

networks:

  frontend:

    driver: bridge

  backend:

    driver: bridge

    internal: true

volumes:

  postgres_data:

secrets:

  db_name:

    external: true

  db_user:

    external: true

  db_password:

    external: true

4. Image Size Optimization

Size reduction strategies:

Distroless images: Minimal runtime environments

Build artifact optimization: Remove build tools and cache

Layer consolidation: Combine RUN commands strategically

Multi-stage artifact copying: Only copy necessary files

Optimization techniques:

# Minimal production image

FROM gcr.io/distroless/nodejs18-debian11

COPY --from=build /app/dist /app

COPY --from=build /app/node_modules /app/node_modules

WORKDIR /app

EXPOSE 3000

CMD ["index.js"]

5. Development Workflow Integration

Development patterns:

Hot reloading setup: Volume mounting and file watching

Debug configuration: Port exposure and debugging tools

Testing integration: Test-specific containers and environments

Development containers: Remote development container support via CLI tools

Development workflow:

# Development override

services:

  app:

    build:

      context: .

      target: development

    volumes:

      - .:/app

      - /app/node_modules

      - /app/dist

    environment:

      - NODE_ENV=development

      - DEBUG=app:*

    ports:

      - "9229:9229"  # Debug port

    command: npm run dev

6. Performance & Resource Management

Performance optimization:

Resource limits: CPU, memory constraints for stability

Build performance: Parallel builds, cache utilization

Runtime performance: Process management, signal handling

Monitoring integration: Health checks, metrics exposure

Resource management:

services:

  app:

    deploy:

      resources:

        limits:

          cpus: '1.0'

          memory: 1G

        reservations:

          cpus: '0.5'

          memory: 512M

      restart_policy:

        condition: on-failure

        delay: 5s

        max_attempts: 3

        window: 120s

Advanced Problem-Solving Patterns

Cross-Platform Builds

# Multi-architecture builds

docker buildx create --name multiarch-builder --use

docker buildx build --platform linux/amd64,linux/arm64 \

  -t myapp:latest --push .

Build Cache Optimization

# Mount build cache for package managers

FROM node:18-alpine AS deps

WORKDIR /app

COPY package*.json ./

RUN --mount=type=cache,target=/root/.npm \

    npm ci --only=production

Secrets Management

# Build-time secrets (BuildKit)

FROM alpine

RUN --mount=type=secret,id=api_key \

    API_KEY=$(cat /run/secrets/api_key) &#x26;&#x26; \

    # Use API_KEY for build process

Health Check Strategies

# Sophisticated health monitoring

COPY health-check.sh /usr/local/bin/

RUN chmod +x /usr/local/bin/health-check.sh

HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \

  CMD ["/usr/local/bin/health-check.sh"]

Code Review Checklist

When reviewing Docker configurations, focus on:

Dockerfile Optimization & Multi-Stage Builds

Dependencies copied before source code for optimal layer caching

Multi-stage builds separate build and runtime environments

Production stage only includes necessary artifacts

Build context optimized with comprehensive .dockerignore

Base image selection appropriate (Alpine vs distroless vs scratch)

RUN commands consolidated to minimize layers where beneficial

Container Security Hardening

Non-root user created with specific UID/GID (not default)

Container runs as non-root user (USER directive)

Secrets managed properly (not in ENV vars or layers)

Base images kept up-to-date and scanned for vulnerabilities

Minimal attack surface (only necessary packages installed)

Health checks implemented for container monitoring

Docker Compose & Orchestration

Service dependencies properly defined with health checks

Custom networks configured for service isolation

Environment-specific configurations separated (dev/prod)

Volume strategies appropriate for data persistence needs

Resource limits defined to prevent resource exhaustion

Restart policies configured for production resilience

Image Size & Performance

Final image size optimized (avoid unnecessary files/tools)

Build cache optimization implemented

Multi-architecture builds considered if needed

Artifact copying selective (only required files)

Package manager cache cleaned in same RUN layer

Development Workflow Integration

Development targets separate from production

Hot reloading configured properly with volume mounts

Debug ports exposed when needed

Environment variables properly configured for different stages

Testing containers isolated from production builds

Networking & Service Discovery

Port exposure limited to necessary services

Service naming follows conventions for discovery

Network security implemented (internal networks for backend)

Load balancing considerations addressed

Health check endpoints implemented and tested

Common Issue Diagnostics

Build Performance Issues

Symptoms: Slow builds (10+ minutes), frequent cache invalidation

Root causes: Poor layer ordering, large build context, no caching strategy

Solutions: Multi-stage builds, .dockerignore optimization, dependency caching

Security Vulnerabilities

Symptoms: Security scan failures, exposed secrets, root execution

Root causes: Outdated base images, hardcoded secrets, default user

Solutions: Regular base updates, secrets management, non-root configuration

Image Size Problems

Symptoms: Images over 1GB, deployment slowness

Root causes: Unnecessary files, build tools in production, poor base selection

Solutions: Distroless images, multi-stage optimization, artifact selection

Networking Issues

Symptoms: Service communication failures, DNS resolution errors

Root causes: Missing networks, port conflicts, service naming

Solutions: Custom networks, health checks, proper service discovery

Development Workflow Problems

Symptoms: Hot reload failures, debugging difficulties, slow iteration

Root causes: Volume mounting issues, port configuration, environment mismatch

Solutions: Development-specific targets, proper volume strategy, debug configuration

Integration & Handoff Guidelines

When to recommend other experts:

Kubernetes orchestration → kubernetes-expert: Pod management, services, ingress

CI/CD pipeline issues → github-actions-expert: Build automation, deployment workflows

Database containerization → database-expert: Complex persistence, backup strategies

Application-specific optimization → Language experts: Code-level performance issues

Infrastructure automation → devops-expert: Terraform, cloud-specific deployments

Collaboration patterns:

Provide Docker foundation for DevOps deployment automation

Create optimized base images for language-specific experts

Establish container standards for CI/CD integration

Define security baselines for production orchestration

I provide comprehensive Docker containerization expertise with focus on practical optimization, security hardening, and production-ready patterns. My solutions emphasize performance, maintainability, and security best practices for modern container workflows.

When to Use

This skill is applicable to execute the workflow or actions described in the overview.

Limitations

Use this skill only when the task clearly matches the scope described above.

Do not treat the output as a substitute for environment-specific validation, testing, or expert review.

Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.

docker-expert

SKILL.md

Core Expertise Areas

1. Dockerfile Optimization & Multi-Stage Builds

2. Container Security Hardening

3. Docker Compose Orchestration

4. Image Size Optimization

5. Development Workflow Integration

6. Performance & Resource Management

Advanced Problem-Solving Patterns

Cross-Platform Builds

Build Cache Optimization

Secrets Management

Health Check Strategies

Code Review Checklist

Dockerfile Optimization & Multi-Stage Builds

Container Security Hardening

Docker Compose & Orchestration

Image Size & Performance

Development Workflow Integration

Networking & Service Discovery

Common Issue Diagnostics

Build Performance Issues

Security Vulnerabilities

Image Size Problems

Networking Issues

Development Workflow Problems

Integration & Handoff Guidelines

When to Use

Limitations

Stop writing automation&scrapers

docker-expert

SKILL.md

Core Expertise Areas

1. Dockerfile Optimization &#x26; Multi-Stage Builds

2. Container Security Hardening

3. Docker Compose Orchestration

4. Image Size Optimization

5. Development Workflow Integration

6. Performance &#x26; Resource Management

Advanced Problem-Solving Patterns

Cross-Platform Builds

Build Cache Optimization

Secrets Management

Health Check Strategies

Code Review Checklist

Dockerfile Optimization &#x26; Multi-Stage Builds

Container Security Hardening

Docker Compose &#x26; Orchestration

Image Size &#x26; Performance

Development Workflow Integration

Networking &#x26; Service Discovery

Common Issue Diagnostics

Build Performance Issues

Security Vulnerabilities

Image Size Problems

Networking Issues

Development Workflow Problems

Integration &#x26; Handoff Guidelines

When to Use

Limitations

Let your agent run on any real-world website

Related skills

Stop writing automation&scrapers

1. Dockerfile Optimization & Multi-Stage Builds

6. Performance & Resource Management

Dockerfile Optimization & Multi-Stage Builds

Docker Compose & Orchestration

Image Size & Performance

Networking & Service Discovery

Integration & Handoff Guidelines