Dockerfile Optimizer

Analyzes and optimizes Dockerfiles to reduce image size, improve build time, and enhance security. Use when optimizing Docker images, reducing build times, or improving Dockerfile structure.

armanzeroeight Updated Sep 10, 2026

Install

Press C to copy

$ npx skillmds@latest add armanzeroeight/dockerfile-optimizer

Installs into ~/.claude/skills (or .claude/skills inside a project). Restart Claude Code to pick it up.

＋ Add to plugin

README badge

[![SkillMD](https://skillmd.com/badge/armanzeroeight/dockerfile-optimizer.svg)](https://skillmd.com/skills/armanzeroeight/dockerfile-optimizer)

Trust & safety

Audits pending

Not yet audited · commit 7c122f0

Permissions this skill uses

Makes network calls
The instructions fetch remote URLs or call external services.

Works with: Claude Code Claude.ai OpenAI Codex +

File contents

Dockerfile Optimizer

Optimize Docker images for size, speed, and security.

Quick Start

Analyze current Dockerfile:

docker build -t myapp .
docker images myapp
# Note the size, then optimize

Instructions

Step 1: Analyze Current Dockerfile

Review for optimization opportunities:

Base image choice
Layer structure
Build dependencies
Caching strategy
Security practices

Step 2: Optimize Base Image

Choose minimal base:

# Before: Large base
FROM ubuntu:22.04  # ~77MB

# After: Minimal base
FROM alpine:3.18   # ~7MB
# or
FROM node:18-alpine  # ~170MB vs node:18 ~990MB

Use specific tags:

# Bad: Unpredictable
FROM node:latest

# Good: Specific version
FROM node:18.17-alpine3.18

Step 3: Implement Multi-Stage Builds

For compiled languages:

# Before: Single stage
FROM golang:1.21
WORKDIR /app
COPY . .
RUN go build -o app
CMD ["./app"]
# Result: ~800MB

# After: Multi-stage
FROM golang:1.21-alpine AS builder
WORKDIR /app
COPY . .
RUN go build -o app

FROM alpine:3.18
COPY --from=builder /app/app /app
CMD ["/app"]
# Result: ~15MB

Step 4: Optimize Layer Caching

Order by change frequency:

# Bad: Code changes invalidate all layers
FROM node:18-alpine
COPY . .
RUN npm install
CMD ["node", "server.js"]

# Good: Dependencies cached separately
FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .
CMD ["node", "server.js"]

Step 5: Combine and Minimize Layers

Reduce layer count:

# Before: Multiple layers
RUN apt-get update
RUN apt-get install -y curl
RUN apt-get install -y git
RUN apt-get clean

# After: Single layer
RUN apt-get update && \
    apt-get install -y curl git && \
    apt-get clean && \
    rm -rf /var/lib/apt/lists/*

Step 6: Use .dockerignore

Create .dockerignore:

node_modules
npm-debug.log
.git
.gitignore
README.md
.env
.DS_Store
*.md
.vscode
.idea
dist
build
coverage

Step 7: Remove Build Dependencies

Clean up after install:

# Python example
RUN pip install --no-cache-dir -r requirements.txt

# Node example
RUN npm ci --only=production && npm cache clean --force

# Alpine example
RUN apk add --no-cache curl && \
    apk del build-dependencies

Step 8: Add Security Improvements

Run as non-root:

# Create user
RUN addgroup -g 1001 -S appuser && \
    adduser -u 1001 -S appuser -G appuser

# Switch to user
USER appuser

# Or use existing user
USER nobody

Step 9: Verify Optimization

Check image size:

docker images myapp
docker history myapp

Analyze layers:

docker history myapp --no-trunc

Use dive tool:

dive myapp

Optimization Patterns

Node.js Optimization:

FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production

FROM node:18-alpine
WORKDIR /app
COPY --from=builder /app/node_modules ./node_modules
COPY . .
USER node
EXPOSE 3000
CMD ["node", "server.js"]

Python Optimization:

FROM python:3.11-slim AS builder
WORKDIR /app
COPY requirements.txt .
RUN pip install --user --no-cache-dir -r requirements.txt

FROM python:3.11-slim
WORKDIR /app
COPY --from=builder /root/.local /root/.local
COPY . .
ENV PATH=/root/.local/bin:$PATH
USER nobody
CMD ["python", "app.py"]

Go Optimization:

FROM golang:1.21-alpine AS builder
WORKDIR /app
COPY go.* ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o app .

FROM scratch
COPY --from=builder /app/app /app
COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
EXPOSE 8080
CMD ["/app"]

Common Issues

Issue: Large image size

Use alpine or slim base images
Implement multi-stage builds
Remove build dependencies
Use .dockerignore

Issue: Slow builds

Optimize layer caching
Order commands by change frequency
Use build cache mounts
Parallelize where possible

Issue: Security vulnerabilities

Use minimal base images
Keep images updated
Run as non-root
Scan with security tools

Issue: Build cache not working

Check command order
Avoid COPY . . early
Use specific COPY commands
Check .dockerignore

Advanced

For detailed information, see:

Multi-Stage Builds - Advanced multi-stage patterns
Layer Caching - Caching strategies and optimization
Base Images - Base image selection guide

---name: dockerfile-optimizerdescription: Analyzes and optimizes Dockerfiles to reduce image size, improve build time, and enhance security. Use when optimizing Docker images, reducing build times, or improving Dockerfile structure.---# Dockerfile OptimizerOptimize Docker images for size, speed, and security.## Quick StartAnalyze current Dockerfile:```bashdocker build -t myapp .docker images myapp# Note the size, then optimize```## Instructions### Step 1: Analyze Current DockerfileReview for optimization opportunities:- Base image choice- Layer structure- Build dependencies- Caching strategy- Security practices### Step 2: Optimize Base Image**Choose minimal base**:```dockerfile# Before: Large baseFROM ubuntu:22.04 # ~77MB# After: Minimal baseFROM alpine:3.18 # ~7MB# orFROM node:18-alpine # ~170MB vs node:18 ~990MB```**Use specific tags**:```dockerfile# Bad: UnpredictableFROM node:latest# Good: Specific versionFROM node:18.17-alpine3.18```### Step 3: Implement Multi-Stage Builds**For compiled languages**:```dockerfile# Before: Single stageFROM golang:1.21WORKDIR /appCOPY . .RUN go build -o appCMD ["./app"]# Result: ~800MB# After: Multi-stageFROM golang:1.21-alpine AS builderWORKDIR /appCOPY . .RUN go build -o appFROM alpine:3.18COPY --from=builder /app/app /appCMD ["/app"]# Result: ~15MB```### Step 4: Optimize Layer Caching**Order by change frequency**:```dockerfile# Bad: Code changes invalidate all layersFROM node:18-alpineCOPY . .RUN npm installCMD ["node", "server.js"]# Good: Dependencies cached separatelyFROM node:18-alpineWORKDIR /appCOPY package*.json ./RUN npm ci --only=productionCOPY . .CMD ["node", "server.js"]```### Step 5: Combine and Minimize Layers**Reduce layer count**:```dockerfile# Before: Multiple layersRUN apt-get updateRUN apt-get install -y curlRUN apt-get install -y gitRUN apt-get clean# After: Single layerRUN apt-get update && \ apt-get install -y curl git && \ apt-get clean && \ rm -rf /var/lib/apt/lists/*```### Step 6: Use .dockerignoreCreate `.dockerignore`:```node_modulesnpm-debug.log.git.gitignoreREADME.md.env.DS_Store*.md.vscode.ideadistbuildcoverage```### Step 7: Remove Build Dependencies**Clean up after install**:```dockerfile# Python exampleRUN pip install --no-cache-dir -r requirements.txt# Node exampleRUN npm ci --only=production && npm cache clean --force# Alpine exampleRUN apk add --no-cache curl && \ apk del build-dependencies```### Step 8: Add Security Improvements**Run as non-root**:```dockerfile# Create userRUN addgroup -g 1001 -S appuser && \ adduser -u 1001 -S appuser -G appuser# Switch to userUSER appuser# Or use existing userUSER nobody```### Step 9: Verify Optimization**Check image size**:```bashdocker images myappdocker history myapp```**Analyze layers**:```bashdocker history myapp --no-trunc```**Use dive tool**:```bashdive myapp```## Optimization Patterns**Node.js Optimization**:```dockerfileFROM node:18-alpine AS builderWORKDIR /appCOPY package*.json ./RUN npm ci --only=productionFROM node:18-alpineWORKDIR /appCOPY --from=builder /app/node_modules ./node_modulesCOPY . .USER nodeEXPOSE 3000CMD ["node", "server.js"]```**Python Optimization**:```dockerfileFROM python:3.11-slim AS builderWORKDIR /appCOPY requirements.txt .RUN pip install --user --no-cache-dir -r requirements.txtFROM python:3.11-slimWORKDIR /appCOPY --from=builder /root/.local /root/.localCOPY . .ENV PATH=/root/.local/bin:$PATHUSER nobodyCMD ["python", "app.py"]```**Go Optimization**:```dockerfileFROM golang:1.21-alpine AS builderWORKDIR /appCOPY go.* ./RUN go mod downloadCOPY . .RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o app .FROM scratchCOPY --from=builder /app/app /appCOPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/EXPOSE 8080CMD ["/app"]```## Common Issues**Issue: Large image size**- Use alpine or slim base images- Implement multi-stage builds- Remove build dependencies- Use .dockerignore**Issue: Slow builds**- Optimize layer caching- Order commands by change frequency- Use build cache mounts- Parallelize where possible**Issue: Security vulnerabilities**- Use minimal base images- Keep images updated- Run as non-root- Scan with security tools**Issue: Build cache not working**- Check command order- Avoid COPY . . early- Use specific COPY commands- Check .dockerignore## AdvancedFor detailed information, see:- [Multi-Stage Builds](reference/multi-stage.md) - Advanced multi-stage patterns- [Layer Caching](reference/caching.md) - Caching strategies and optimization- [Base Images](reference/base-images.md) - Base image selection guide

armanzeroeight/fastagent-plugins/tree/main/plugins/docker-toolkit/skills/dockerfile-optimizer commit 7c122f0cab

Frequently asked questions

npx skillmds@latest add armanzeroeight/dockerfile-optimizer