docker-compose-generator

name	Docker Compose Generator
description	Generates production-ready docker-compose.yml files for any application stack.
category	devops
tags	["docker","containers","devops","infrastructure"]
author	simplyutils

Docker Compose Generator

What this skill does

This skill directs the agent to gather information about your application stack and produce a production-ready docker-compose.yml file. It includes health checks, named volumes, custom networks, environment variable placeholders, restart policies, and sensible resource limits — all things that are easy to miss when writing a Compose file from scratch.

Use this when bootstrapping a new project, when converting an existing app to run in containers, or when you want a solid starting point to customize from.

How to use

Claude Code / Cline

Copy this file to .agents/skills/docker-compose-generator/SKILL.md in your project root.

Then ask:

• "Use the Docker Compose Generator skill to create a docker-compose.yml for my Node.js app with PostgreSQL and Redis."
• "I have a Python FastAPI backend, a React frontend, and a Postgres database. Use the Docker Compose Generator skill."

The agent will ask clarifying questions before generating the file if your description is incomplete.

Cursor / Codex

Paste the instructions from the section below into your session along with a description of your stack.

The Prompt / Instructions for the Agent

When asked to generate a docker-compose.yml, follow these steps:

1. Gather requirements. If not already provided, ask for:

   • The application services (e.g., web server, worker, frontend build)
   • The data stores (PostgreSQL, MySQL, MongoDB, Redis, etc.) and their versions
   • The runtime environment (Node.js, Python, Go, etc.) and version
   • Whether this is for development or production (they differ significantly)
   • Any custom ports, domains, or volume paths

2. Apply these rules to every service:

   • Always set a restart policy (unless-stopped for production, on-failure for dev)
   • Add a healthcheck for every database or cache service
   • Use named volumes (not bind mounts) for persistent data in production
   • Use a custom named network — do not rely on the default bridge network
   • Put secrets and credentials in environment variables with ${VAR_NAME} placeholders, never hardcoded values
   • Set depends_on with condition: service_healthy for services that require a healthy DB before starting

3. For development configs, also:

   • Add bind-mount source code for hot reloading (e.g., ./src:/app/src)
   • Expose debug ports (e.g., 9229 for Node.js inspector)
   • Add a .env.example reminder comment

4. For production configs, also:

   • Add deploy.resources.limits for memory and CPU
   • Do not expose database ports to the host unless explicitly requested
   • Use read_only: true on containers where the filesystem does not need to be writable

5. Output:

   • The docker-compose.yml in a fenced code block
   • A .env.example snippet showing all required variables
   • A brief "Next steps" section (e.g., how to start, how to view logs)

Example

Input to Agent:

"Use the Docker Compose Generator skill. I have a Node.js Express API (port 3000), a PostgreSQL 16 database, and a Redis 7 cache. This is for production."

Output from Agent:

# docker-compose.yml
version: '3.9'

services:
  api:
    build: .
    restart: unless-stopped
    ports:
      - "3000:3000"
    environment:
      - DATABASE_URL=${DATABASE_URL}
      - REDIS_URL=${REDIS_URL}
      - NODE_ENV=production
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
    networks:
      - app-network
    deploy:
      resources:
        limits:
          cpus: '1.0'
          memory: 512M

  postgres:
    image: postgres:16-alpine
    restart: unless-stopped
    environment:
      - POSTGRES_DB=${POSTGRES_DB}
      - POSTGRES_USER=${POSTGRES_USER}
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
    volumes:
      - postgres-data:/var/lib/postgresql/data
    networks:
      - app-network
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
      interval: 10s
      timeout: 5s
      retries: 5

  redis:
    image: redis:7-alpine
    restart: unless-stopped
    command: redis-server --appendonly yes
    volumes:
      - redis-data:/data
    networks:
      - app-network
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5

volumes:
  postgres-data:
  redis-data:

networks:
  app-network:
    driver: bridge

.env.example

DATABASE_URL=postgresql://user:password@postgres:5432/myapp
REDIS_URL=redis://redis:6379
POSTGRES_DB=myapp
POSTGRES_USER=user
POSTGRES_PASSWORD=changeme

Next steps

1. Copy .env.example to .env and fill in real values
2. docker compose up -d to start all services
3. docker compose logs -f api to tail API logs

Notes

• The generated file is a starting point — review resource limits and port exposure before deploying.
• The skill does not write a Dockerfile for your application image. It assumes your Dockerfile already exists in the project root, or will ask you to create one.
• For multi-environment setups, consider generating separate docker-compose.override.yml files for dev and staging. Ask the agent to do this explicitly.
• Always rotate any credentials in .env.example before using them in a real environment.