Docker Expert
Overview
The Docker Expert skill produces optimized, production-ready Dockerfiles and Docker Compose configurations for any application stack. It applies container best practices: minimal base images (Alpine, Distroless, slim variants), multi-stage builds to minimize final image size, non-root user execution for security, strategic layer ordering to maximize cache reuse, .dockerignore files to exclude unnecessary build context, and health check definitions for orchestrator integration. The skill handles single-service containerization and multi-service local development environments with Docker Compose, including networking, volumes, secrets, and environment variable management.
When to Use
- Writing a new Dockerfile for any application (Node.js, Python, Java, Go, Ruby, etc.)
- Reducing Docker image size with multi-stage builds and minimal base images
- Applying container security hardening (non-root user, read-only filesystem, dropped capabilities)
- Configuring a
docker-compose.yml for local development with databases, caches, and app services
- Writing
.dockerignore files to reduce build context size and prevent secret leakage
- Adding
HEALTHCHECK instructions for container health monitoring
- Troubleshooting slow builds, large images, or container startup failures
- Converting a non-containerized app to run in Docker for the first time
When NOT to Use
- Writing Kubernetes manifests or Helm charts (use the kubernetes-helper skill)
- Provisioning managed container services (AWS ECS, Google Cloud Run, Azure Container Apps)
- Designing CI/CD pipelines that build and push Docker images (use the ci-cd-helper skill)
- Setting up container registries (ECR, GCR, GHCR) from scratch
- Orchestrating containers at scale in production (use Kubernetes)
Quick Reference
| Task |
Approach |
| Minimize image size |
Use multi-stage build; copy only compiled artifacts to a minimal final stage (Alpine/Distroless) |
| Run as non-root |
Add RUN addgroup -S app && adduser -S app -G app then USER app before CMD |
| Maximize layer cache |
Order instructions: COPY lockfile → RUN install → COPY source code |
| Exclude build context files |
Create .dockerignore listing node_modules/, .git/, *.log, .env, dist/ |
| Health check |
HEALTHCHECK --interval=30s --timeout=5s --retries=3 CMD curl -f http://localhost:8080/health |
| Multi-service dev env |
Use docker-compose.yml with depends_on:, named volumes, and a shared network |
| Pin base image versions |
Use node:20.14.0-alpine3.19 not node:latest for reproducible builds |
Instructions
Identify the application stack and runtime — Confirm the language, framework, package manager, and build output format (e.g., "Node.js 20 with npm, Express app, no build step" or "Python 3.11 with Poetry, FastAPI, no compiled artifacts"). This determines the appropriate base image family.
Choose the base image strategy — Select the smallest suitable base image: use language-specific Alpine or slim variants for interpreted languages (e.g., python:3.11-slim, node:20-alpine). For compiled languages (Go, Rust), use a full build image for the build stage and gcr.io/distroless/static or scratch for the final stage.
Design a multi-stage build — Use at minimum a builder stage (full SDK image for installing dependencies and compiling) and a runner stage (minimal image for running the app). Copy only production artifacts from builder to runner: COPY --from=builder /app/dist ./dist.
Optimize layer caching — Order COPY and RUN instructions from least-frequently-changed to most-frequently-changed. Always copy the dependency manifest first, run the install, then copy source code. This ensures a dependency cache hit on every commit that only changes source code.
Harden for security — Create a dedicated non-root user and group; switch to it with USER before the CMD or ENTRYPOINT. Avoid running as root. Consider adding --cap-drop=ALL and --read-only at runtime for sensitive services.
Write a .dockerignore file — Exclude: .git/, node_modules/ (or language equivalent), *.log, .env*, dist/, coverage/, IDE config files (.vscode/, .idea/), and any files with secrets. A small build context speeds up builds and prevents accidental secret inclusion.
Define environment variables correctly — Use ENV for runtime configuration defaults that are safe to bake into the image. Use ARG for build-time variables that should not persist in the final image. Never use ENV or ARG for secrets — pass secrets at runtime via --env-file or Docker secrets.
Add a HEALTHCHECK instruction — Define a health check command so Docker and orchestrators can detect when the container is ready and unhealthy. Use the application's own health endpoint or a lightweight check (wget -qO- http://localhost:PORT/health).
Configure Docker Compose for multi-service environments — Define services, expose ports, configure named volumes for persistent data, and link services via a shared named network. Use depends_on: condition: service_healthy to enforce startup ordering.
Validate and document the setup — Provide the build command (docker build -t myapp:latest .), run command (docker run -p 3000:3000 myapp:latest), and Compose command (docker compose up -d). Note any required environment variables and how to supply them securely.
Examples
Example 1: Production-Optimized Node.js Dockerfile
Input: "Write a production Dockerfile for a Node.js 20 Express app using npm. The app runs on port 3000. Include multi-stage build, non-root user, health check, and .dockerignore."
Output:
# .dockerignore
node_modules/
npm-debug.log*
.git/
.gitignore
.env*
dist/
coverage/
.nyc_output/
*.md
.vscode/
.idea/
# Dockerfile
# ── Stage 1: Install dependencies ────────────────────────────────────────────
FROM node:20-alpine3.19 AS deps
WORKDIR /app
# Copy manifests first to leverage layer cache — reinstall only when deps change
COPY package.json package-lock.json ./
RUN npm ci --omit=dev # Install production deps only; --omit=dev skips devDependencies
# ── Stage 2: Build (if applicable — e.g., TypeScript, webpack) ───────────────
FROM node:20-alpine3.19 AS builder
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci # Install ALL deps (including devDependencies) for build step
COPY . .
RUN npm run build # Compiles TS, runs webpack, etc. Remove if no build step.
# ── Stage 3: Production runtime ──────────────────────────────────────────────
FROM node:20-alpine3.19 AS runner
# Create a dedicated non-root user for security
RUN addgroup -S appgroup && adduser -S appuser -G appgroup
WORKDIR /app
# Copy production node_modules from deps stage
COPY --from=deps /app/node_modules ./node_modules
# Copy built application from builder stage
COPY --from=builder /app/dist ./dist
COPY package.json ./
# Switch to non-root user before starting the app
USER appuser
EXPOSE 3000
# Health check — orchestrators use this to know when the app is ready
HEALTHCHECK --interval=30s --timeout=5s --start-period=15s --retries=3 \
CMD wget -qO- http://localhost:3000/health || exit 1
# Use exec form (array) to ensure signals (SIGTERM) reach the Node process
CMD ["node", "dist/server.js"]
# Build
docker build -t myapp:latest .
# Run (pass secrets via --env-file, never bake them into the image)
docker run -d \
-p 3000:3000 \
--env-file .env.production \
--read-only \
--tmpfs /tmp \
--name myapp \
myapp:latest
Result: Final image is ~180 MB (vs ~1.1 GB with a full Node image and no multi-stage build). Runs as non-root appuser. Health check enables Kubernetes/Docker Swarm readiness detection.
Example 2: Python Flask App with Docker Compose (App + Postgres + Redis)
Input: "Set up Docker Compose for a Python 3.11 Flask app (using pip and requirements.txt) with a Postgres 15 database and Redis 7 cache. The Flask app should hot-reload in development."
Output:
# Dockerfile (development — hot reload via Flask dev server)
FROM python:3.11-slim AS base
# Install system dependencies required by psycopg2 and other packages
RUN apt-get update && apt-get install -y --no-install-recommends \
gcc libpq-dev curl \
&& rm -rf /var/lib/apt/lists/*
# Create non-root user
RUN groupadd -r flaskuser && useradd -r -g flaskuser flaskuser
WORKDIR /app
# Install Python dependencies (cached layer — only reinstalls when requirements.txt changes)
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
# Copy application source
COPY . .
RUN chown -R flaskuser:flaskuser /app
USER flaskuser
EXPOSE 5000
HEALTHCHECK --interval=20s --timeout=5s --start-period=10s --retries=3 \
CMD curl -f http://localhost:5000/health || exit 1
CMD ["flask", "run", "--host=0.0.0.0"]
# docker-compose.yml
version: '3.9'
services:
app:
build:
context: .
dockerfile: Dockerfile
container_name: flask-app
ports:
- "5000:5000"
environment:
FLASK_ENV: development
FLASK_APP: app:create_app
DATABASE_URL: postgresql://postgres:${POSTGRES_PASSWORD}@db:5432/${POSTGRES_DB}
REDIS_URL: redis://redis:6379/0
env_file:
- .env.development # Contains POSTGRES_PASSWORD, SECRET_KEY, etc.
volumes:
- .:/app # Mount source for hot-reload in development
depends_on:
db:
condition: service_healthy
redis:
condition: service_healthy
networks:
- backend
db:
image: postgres:15-alpine
container_name: flask-db
environment:
POSTGRES_DB: ${POSTGRES_DB:-myapp}
POSTGRES_USER: postgres
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
volumes:
- postgres_data:/var/lib/postgresql/data
- ./db/init.sql:/docker-entrypoint-initdb.d/init.sql:ro
healthcheck:
test: ["CMD-SHELL", "pg_isready -U postgres"]
interval: 10s
timeout: 5s
retries: 5
networks:
- backend
redis:
image: redis:7-alpine
container_name: flask-redis
command: ["redis-server", "--save", "60", "1", "--loglevel", "warning"]
volumes:
- redis_data:/data
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 10s
timeout: 5s
retries: 3
networks:
- backend
volumes:
postgres_data:
redis_data:
networks:
backend:
driver: bridge
# Start all services
docker compose up -d
# View logs
docker compose logs -f app
# Run database migrations
docker compose exec app flask db upgrade
# Tear down (keep volumes)
docker compose down
# Tear down and delete all data volumes
docker compose down -v
Best Practices
- Always pin base image versions (
node:20.14.0-alpine3.19 not node:latest) for reproducible builds
- Use multi-stage builds for every app that has a build step — the difference in final image size is dramatic
- Run containers as a non-root user in every environment, including development
- Copy dependency manifests before source code to maximize Docker layer cache utilization
- Always include a
.dockerignore file — without it, node_modules/ or .git/ can be sent as build context
- Use
HEALTHCHECK in every production Dockerfile so orchestrators can detect unhealthy containers
- Prefer
CMD in exec form (["node", "server.js"]) over shell form (node server.js) so signals propagate correctly
Common Mistakes
- Using
COPY . . before installing dependencies — breaks layer caching; every source change triggers a full reinstall
- Running containers as root (default if
USER is not set) — significant security vulnerability
- Using
:latest tags for base images — leads to non-reproducible builds as upstream images update
- Storing secrets in
ENV instructions — they are visible in docker inspect and image layers
- Not using
--no-cache-dir for pip install — wastes image space on cached wheel files
- Installing development tools (curl, vim, git) in production images — increases attack surface and image size
- Forgetting to clean up apt/apk cache in the same
RUN layer that installs packages
Tips & Tricks
- Use
docker image history myapp:latest to see each layer's size and identify what to optimize
- Use
docker buildx build --platform linux/amd64,linux/arm64 to build multi-architecture images for Apple Silicon and cloud compatibility
- Use Docker's
--build-arg with ARG to pass build-time configuration (e.g., environment name, version tag) without baking it into ENV
- Use
docker compose watch (Compose v2.22+) for smarter file-watching hot reload that avoids volume mount pitfalls
- Add
--squash or use BuildKit's --mount=type=cache to further optimize image size and build speed
- Use
docker scout cves myapp:latest to scan your built image for known CVEs before pushing
- In multi-stage builds, name stages with
AS name and reference them in COPY --from=name for clarity and build targeting
Related Skills
1---2name: docker-expert3description: "Use this skill when writing optimized Dockerfiles, multi-stage builds, Docker Compose configurations, or applying container security and performance best practices. Triggers: 'write a Dockerfile for', 'optimize my Docker image', 'set up Docker Compose for', 'containerize my app'. Not for writing Kubernetes manifests, provisioning cloud container services (ECS, Cloud Run), or designing CI/CD pipelines."4version: 1.0.05author: community6tags: [devops, docker, containers, docker-compose]7license: MIT8metadata:9 source: https://skillmd.com/skills/xcrrr/docker-expert10---1112# Docker Expert1314## Overview15The Docker Expert skill produces optimized, production-ready Dockerfiles and Docker Compose configurations for any application stack. It applies container best practices: minimal base images (Alpine, Distroless, slim variants), multi-stage builds to minimize final image size, non-root user execution for security, strategic layer ordering to maximize cache reuse, `.dockerignore` files to exclude unnecessary build context, and health check definitions for orchestrator integration. The skill handles single-service containerization and multi-service local development environments with Docker Compose, including networking, volumes, secrets, and environment variable management.1617## When to Use18- Writing a new Dockerfile for any application (Node.js, Python, Java, Go, Ruby, etc.)19- Reducing Docker image size with multi-stage builds and minimal base images20- Applying container security hardening (non-root user, read-only filesystem, dropped capabilities)21- Configuring a `docker-compose.yml` for local development with databases, caches, and app services22- Writing `.dockerignore` files to reduce build context size and prevent secret leakage23- Adding `HEALTHCHECK` instructions for container health monitoring24- Troubleshooting slow builds, large images, or container startup failures25- Converting a non-containerized app to run in Docker for the first time2627## When NOT to Use28- Writing Kubernetes manifests or Helm charts (use the kubernetes-helper skill)29- Provisioning managed container services (AWS ECS, Google Cloud Run, Azure Container Apps)30- Designing CI/CD pipelines that build and push Docker images (use the ci-cd-helper skill)31- Setting up container registries (ECR, GCR, GHCR) from scratch32- Orchestrating containers at scale in production (use Kubernetes)3334## Quick Reference35| Task | Approach |36|------|----------|37| Minimize image size | Use multi-stage build; copy only compiled artifacts to a minimal final stage (Alpine/Distroless) |38| Run as non-root | Add `RUN addgroup -S app && adduser -S app -G app` then `USER app` before `CMD` |39| Maximize layer cache | Order instructions: `COPY` lockfile → `RUN install` → `COPY` source code |40| Exclude build context files | Create `.dockerignore` listing `node_modules/`, `.git/`, `*.log`, `.env`, `dist/` |41| Health check | `HEALTHCHECK --interval=30s --timeout=5s --retries=3 CMD curl -f http://localhost:8080/health` |42| Multi-service dev env | Use `docker-compose.yml` with `depends_on:`, named volumes, and a shared network |43| Pin base image versions | Use `node:20.14.0-alpine3.19` not `node:latest` for reproducible builds |4445## Instructions46471. **Identify the application stack and runtime** — Confirm the language, framework, package manager, and build output format (e.g., "Node.js 20 with npm, Express app, no build step" or "Python 3.11 with Poetry, FastAPI, no compiled artifacts"). This determines the appropriate base image family.48492. **Choose the base image strategy** — Select the smallest suitable base image: use language-specific Alpine or slim variants for interpreted languages (e.g., `python:3.11-slim`, `node:20-alpine`). For compiled languages (Go, Rust), use a full build image for the build stage and `gcr.io/distroless/static` or `scratch` for the final stage.50513. **Design a multi-stage build** — Use at minimum a `builder` stage (full SDK image for installing dependencies and compiling) and a `runner` stage (minimal image for running the app). Copy only production artifacts from builder to runner: `COPY --from=builder /app/dist ./dist`.52534. **Optimize layer caching** — Order `COPY` and `RUN` instructions from least-frequently-changed to most-frequently-changed. Always copy the dependency manifest first, run the install, then copy source code. This ensures a dependency cache hit on every commit that only changes source code.54555. **Harden for security** — Create a dedicated non-root user and group; switch to it with `USER` before the `CMD` or `ENTRYPOINT`. Avoid running as `root`. Consider adding `--cap-drop=ALL` and `--read-only` at runtime for sensitive services.56576. **Write a `.dockerignore` file** — Exclude: `.git/`, `node_modules/` (or language equivalent), `*.log`, `.env*`, `dist/`, `coverage/`, IDE config files (`.vscode/`, `.idea/`), and any files with secrets. A small build context speeds up builds and prevents accidental secret inclusion.58597. **Define environment variables correctly** — Use `ENV` for runtime configuration defaults that are safe to bake into the image. Use `ARG` for build-time variables that should not persist in the final image. Never use `ENV` or `ARG` for secrets — pass secrets at runtime via `--env-file` or Docker secrets.60618. **Add a `HEALTHCHECK` instruction** — Define a health check command so Docker and orchestrators can detect when the container is ready and unhealthy. Use the application's own health endpoint or a lightweight check (`wget -qO- http://localhost:PORT/health`).62639. **Configure Docker Compose for multi-service environments** — Define services, expose ports, configure named volumes for persistent data, and link services via a shared named network. Use `depends_on: condition: service_healthy` to enforce startup ordering.646510. **Validate and document the setup** — Provide the build command (`docker build -t myapp:latest .`), run command (`docker run -p 3000:3000 myapp:latest`), and Compose command (`docker compose up -d`). Note any required environment variables and how to supply them securely.6667## Examples6869### Example 1: Production-Optimized Node.js Dockerfile70**Input:** "Write a production Dockerfile for a Node.js 20 Express app using npm. The app runs on port 3000. Include multi-stage build, non-root user, health check, and .dockerignore."7172**Output:**73```dockerfile74# .dockerignore75node_modules/76npm-debug.log*77.git/78.gitignore79.env*80dist/81coverage/82.nyc_output/83*.md84.vscode/85.idea/86```8788```dockerfile89# Dockerfile90# ── Stage 1: Install dependencies ────────────────────────────────────────────91FROM node:20-alpine3.19 AS deps9293WORKDIR /app9495# Copy manifests first to leverage layer cache — reinstall only when deps change96COPY package.json package-lock.json ./97RUN npm ci --omit=dev # Install production deps only; --omit=dev skips devDependencies9899# ── Stage 2: Build (if applicable — e.g., TypeScript, webpack) ───────────────100FROM node:20-alpine3.19 AS builder101102WORKDIR /app103COPY package.json package-lock.json ./104RUN npm ci # Install ALL deps (including devDependencies) for build step105COPY . .106RUN npm run build # Compiles TS, runs webpack, etc. Remove if no build step.107108# ── Stage 3: Production runtime ──────────────────────────────────────────────109FROM node:20-alpine3.19 AS runner110111# Create a dedicated non-root user for security112RUN addgroup -S appgroup && adduser -S appuser -G appgroup113114WORKDIR /app115116# Copy production node_modules from deps stage117COPY --from=deps /app/node_modules ./node_modules118# Copy built application from builder stage119COPY --from=builder /app/dist ./dist120COPY package.json ./121122# Switch to non-root user before starting the app123USER appuser124125EXPOSE 3000126127# Health check — orchestrators use this to know when the app is ready128HEALTHCHECK --interval=30s --timeout=5s --start-period=15s --retries=3 \129 CMD wget -qO- http://localhost:3000/health || exit 1130131# Use exec form (array) to ensure signals (SIGTERM) reach the Node process132CMD ["node", "dist/server.js"]133```134135```bash136# Build137docker build -t myapp:latest .138139# Run (pass secrets via --env-file, never bake them into the image)140docker run -d \141 -p 3000:3000 \142 --env-file .env.production \143 --read-only \144 --tmpfs /tmp \145 --name myapp \146 myapp:latest147```148149**Result:** Final image is ~180 MB (vs ~1.1 GB with a full Node image and no multi-stage build). Runs as non-root `appuser`. Health check enables Kubernetes/Docker Swarm readiness detection.150151### Example 2: Python Flask App with Docker Compose (App + Postgres + Redis)152**Input:** "Set up Docker Compose for a Python 3.11 Flask app (using pip and requirements.txt) with a Postgres 15 database and Redis 7 cache. The Flask app should hot-reload in development."153154**Output:**155```dockerfile156# Dockerfile (development — hot reload via Flask dev server)157FROM python:3.11-slim AS base158159# Install system dependencies required by psycopg2 and other packages160RUN apt-get update && apt-get install -y --no-install-recommends \161 gcc libpq-dev curl \162 && rm -rf /var/lib/apt/lists/*163164# Create non-root user165RUN groupadd -r flaskuser && useradd -r -g flaskuser flaskuser166167WORKDIR /app168169# Install Python dependencies (cached layer — only reinstalls when requirements.txt changes)170COPY requirements.txt .171RUN pip install --no-cache-dir -r requirements.txt172173# Copy application source174COPY . .175RUN chown -R flaskuser:flaskuser /app176177USER flaskuser178179EXPOSE 5000180181HEALTHCHECK --interval=20s --timeout=5s --start-period=10s --retries=3 \182 CMD curl -f http://localhost:5000/health || exit 1183184CMD ["flask", "run", "--host=0.0.0.0"]185```186187```yaml188# docker-compose.yml189version: '3.9'190191services:192 app:193 build:194 context: .195 dockerfile: Dockerfile196 container_name: flask-app197 ports:198 - "5000:5000"199 environment:200 FLASK_ENV: development201 FLASK_APP: app:create_app202 DATABASE_URL: postgresql://postgres:${POSTGRES_PASSWORD}@db:5432/${POSTGRES_DB}203 REDIS_URL: redis://redis:6379/0204 env_file:205 - .env.development # Contains POSTGRES_PASSWORD, SECRET_KEY, etc.206 volumes:207 - .:/app # Mount source for hot-reload in development208 depends_on:209 db:210 condition: service_healthy211 redis:212 condition: service_healthy213 networks:214 - backend215216 db:217 image: postgres:15-alpine218 container_name: flask-db219 environment:220 POSTGRES_DB: ${POSTGRES_DB:-myapp}221 POSTGRES_USER: postgres222 POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}223 volumes:224 - postgres_data:/var/lib/postgresql/data225 - ./db/init.sql:/docker-entrypoint-initdb.d/init.sql:ro226 healthcheck:227 test: ["CMD-SHELL", "pg_isready -U postgres"]228 interval: 10s229 timeout: 5s230 retries: 5231 networks:232 - backend233234 redis:235 image: redis:7-alpine236 container_name: flask-redis237 command: ["redis-server", "--save", "60", "1", "--loglevel", "warning"]238 volumes:239 - redis_data:/data240 healthcheck:241 test: ["CMD", "redis-cli", "ping"]242 interval: 10s243 timeout: 5s244 retries: 3245 networks:246 - backend247248volumes:249 postgres_data:250 redis_data:251252networks:253 backend:254 driver: bridge255```256257```bash258# Start all services259docker compose up -d260261# View logs262docker compose logs -f app263264# Run database migrations265docker compose exec app flask db upgrade266267# Tear down (keep volumes)268docker compose down269270# Tear down and delete all data volumes271docker compose down -v272```273274## Best Practices275- Always pin base image versions (`node:20.14.0-alpine3.19` not `node:latest`) for reproducible builds276- Use multi-stage builds for every app that has a build step — the difference in final image size is dramatic277- Run containers as a non-root user in every environment, including development278- Copy dependency manifests before source code to maximize Docker layer cache utilization279- Always include a `.dockerignore` file — without it, `node_modules/` or `.git/` can be sent as build context280- Use `HEALTHCHECK` in every production Dockerfile so orchestrators can detect unhealthy containers281- Prefer `CMD` in exec form (`["node", "server.js"]`) over shell form (`node server.js`) so signals propagate correctly282283## Common Mistakes284- Using `COPY . .` before installing dependencies — breaks layer caching; every source change triggers a full reinstall285- Running containers as root (default if `USER` is not set) — significant security vulnerability286- Using `:latest` tags for base images — leads to non-reproducible builds as upstream images update287- Storing secrets in `ENV` instructions — they are visible in `docker inspect` and image layers288- Not using `--no-cache-dir` for `pip install` — wastes image space on cached wheel files289- Installing development tools (curl, vim, git) in production images — increases attack surface and image size290- Forgetting to clean up apt/apk cache in the same `RUN` layer that installs packages291292## Tips & Tricks293- Use `docker image history myapp:latest` to see each layer's size and identify what to optimize294- Use `docker buildx build --platform linux/amd64,linux/arm64` to build multi-architecture images for Apple Silicon and cloud compatibility295- Use Docker's `--build-arg` with `ARG` to pass build-time configuration (e.g., environment name, version tag) without baking it into `ENV`296- Use `docker compose watch` (Compose v2.22+) for smarter file-watching hot reload that avoids volume mount pitfalls297- Add `--squash` or use BuildKit's `--mount=type=cache` to further optimize image size and build speed298- Use `docker scout cves myapp:latest` to scan your built image for known CVEs before pushing299- In multi-stage builds, name stages with `AS name` and reference them in `COPY --from=name` for clarity and build targeting300301## Related Skills302- [ci-cd-helper](../ci-cd-helper/SKILL.md)303- [kubernetes-helper](../kubernetes-helper/SKILL.md)304- [security-auditor](../security-auditor/SKILL.md)