Skip to main content
skill CX Codex

automation-scripts — Claude Code skill: scripts and setup

automation-scripts is a Claude Code skill for building automation scripts and task runners. It activates for requests about Makefiles, npm scripts, and development workflows.

MIT 152 installs ★ 26 updated 2026-01-20

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add miles990/claude-software-skills --skill automation-scripts -a claude-code
Open on GitHub

What automation-scripts does

automation-scripts provides patterns for npm scripts, Makefiles, and Bash scripts used in development workflows. Its examples cover build, test, lint, database, and cleanup commands.

The Bash samples include project builds and deployment through Docker and Kubernetes. The deployment script checks rollout status and runs a health check; Slack notifications use the SLACK_WEBHOOK_URL variable.

What it helps with

  • add npm commands for builds and checks
  • define project tasks in a Makefile
  • write a Bash script for builds or deployments

Example prompts for the agent

  • Add lint, test, and build commands to package.json.
  • Create a Makefile with test and cleanup targets.
  • Write a Bash deployment script using Docker and Kubernetes.

How to install automation-scripts

1Skills CLI (Vercel)

npx skills add miles990/claude-software-skills --skill automation-scripts -a claude-code

2Manually: put the files in place

~/.claude/skills/automation-scripts/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/automation-scripts/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about automation-scripts

How do I install automation-scripts in Claude Code?

Run npx skills add miles990/claude-software-skills --skill automation-scripts -a claude-code. The skill file is at ~/.claude/skills/automation-scripts/SKILL.md.

What does automation-scripts do?

It helps create automation scripts, task-runner commands, and development workflow patterns. The examples use npm, Makefiles, and Bash.

What tasks do the automation-scripts examples cover?

They include builds, tests, linting, database operations, artifact cleanup, and deployment with Docker and Kubernetes.

Source text

SKILL.md · MIT
---
name: automation-scripts
description: Build automation, task runners, and scripting tools
domain: tools-integrations
version: 1.0.0
tags: [make, npm-scripts, bash, automation, turbo, nx]
triggers:
  keywords:
    primary: [automation, script, makefile, npm script, task runner, turbo, nx]
    secondary: [build, gulp, grunt, husky, lint-staged, pre-commit]
  context_boost: [workflow, ci, build, tooling]
  context_penalty: [frontend, ui, design]
  priority: medium
---

# Automation & Scripts

## Overview

Build automation, task runners, and scripting patterns for development workflows.

---

## npm Scripts

### Package.json Scripts

```json
{
  "scripts": {
    "dev": "next dev",
    "build": "next build",
    "start": "next start",
    "lint": "eslint . --ext .ts,.tsx",
    "lint:fix": "eslint . --ext .ts,.tsx --fix",
    "type-check": "tsc --noEmit",
    "test": "vitest",
    "test:watch": "vitest --watch",
    "test:coverage": "vitest --coverage",
    "test:e2e": "playwright test",
    "format": "prettier --write .",
    "format:check": "prettier --check .",
    "db:migrate": "prisma migrate deploy",
    "db:generate": "prisma generate",
    "db:seed": "tsx prisma/seed.ts",
    "db:studio": "prisma studio",
    "prepare": "husky install",
    "precommit": "lint-staged",
    "validate": "npm run type-check && npm run lint && npm run test",
    "clean": "rm -rf .next node_modules/.cache",
    "analyze": "ANALYZE=true next build"
  }
}
```

### Script Composition

```json
{
  "scripts": {
    "check:all": "npm-run-all --parallel lint type-check test:unit",
    "build:all": "npm-run-all clean build test:e2e",
    "ci": "npm-run-all --serial lint type-check test build",
    "prerelease": "npm run validate",
    "release": "standard-version",
    "postrelease": "git push --follow-tags"
  }
}
```

---

## Makefile

```makefile
# Makefile
.PHONY: dev build test lint clean deploy help

# Default target
.DEFAULT_GOAL := help

# Variables
NODE_ENV ?= development
DOCKER_TAG ?= latest
PROJECT_NAME := myapp

# Development
dev: ## Start development server
	npm run dev

install: ## Install dependencies
	npm ci

# Build
build: ## Build for production
	npm run build

build-docker: ## Build Docker image
	docker build -t $(PROJECT_NAME):$(DOCKER_TAG) .

# Testing
test: ## Run all tests
	npm run test

test-watch: ## Run tests in watch mode
	npm run test:watch

test-coverage: ## Run tests with coverage
	npm run test:coverage

test-e2e: ## Run E2E tests
	npm run test:e2e

# Linting & Formatting
lint: ## Run linter
	npm run lint

lint-fix: ## Fix linting issues
	npm run lint:fix

format: ## Format code
	npm run format

type-check: ## Run type checking
	npm run type-check

# Database
db-migrate: ## Run database migrations
	npm run db:migrate

db-seed: ## Seed database
	npm run db:seed

db-reset: ## Reset database
	npm run db:reset

# Docker
docker-up: ## Start Docker services
	docker-compose up -d

docker-down: ## Stop Docker services
	docker-compose down

docker-logs: ## Show Docker logs
	docker-compose logs -f

# Deployment
deploy-staging: ## Deploy to staging
	./scripts/deploy.sh staging

deploy-prod: ## Deploy to production
	./scripts/deploy.sh production

# Cleanup
clean: ## Clean build artifacts
	rm -rf dist .next coverage node_modules/.cache
	npm run clean

clean-all: clean ## Clean everything including node_modules
	rm -rf node_modules

# CI/CD
ci: lint type-check test build ## Run CI pipeline

# Help
help: ## Show this help message
	@echo "Usage: make [target]"
	@echo ""
	@echo "Targets:"
	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "  \033[36m%-20s\033[0m %s\n", $$1, $$2}'
```

---

## Bash Scripts

### Build Script

```bash
#!/bin/bash
# scripts/build.sh

set -e  # Exit on error
set -o pipefail  # Exit on pipe failure

# Colors
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color

# Logging functions
log_info() { echo -e "${GREEN}[INFO]${NC} $1"; }
log_warn() { echo -e "${YELLOW}[WARN]${NC} $1"; }
log_error() { echo -e "${RED}[ERROR]${NC} $1"; }

# Configuration
BUILD_DIR="dist"
NODE_ENV="${NODE_ENV:-production}"

# Functions
clean() {
    log_info "Cleaning build directory..."
    rm -rf "$BUILD_DIR"
}

install_deps() {
    log_info "Installing dependencies..."
    npm ci
}

lint() {
    log_info "Running linter..."
    npm run lint
}

type_check() {
    log_info "Running type check..."
    npm run type-check
}

test() {
    log_info "Running tests..."
    npm run test -- --run
}

build() {
    log_info "Building for ${NODE_ENV}..."
    NODE_ENV=$NODE_ENV npm run build
}

# Main
main() {
    local start_time=$(date +%s)

    log_info "Starting build process..."

    clean
    install_deps
    lint
    type_check
    test
    build

    local end_time=$(date +%s)
    local duration=$((end_time - start_time))

    log_info "Build completed in ${duration}s"
}

# Run
main "$@"
```

### Deployment Script

```bash
#!/bin/bash
# scripts/deploy.sh

set -e

ENVIRONMENT="${1:-staging}"
VERSION="${2:-$(git rev-parse --short HEAD)}"

log() { echo "[$(date +'%Y-%m-%d %H:%M:%S')] $1"; }

validate_environment() {
    case "$ENVIRONMENT" in
        staging|production)
            log "Deploying to $ENVIRONMENT"
            ;;
        *)
            log "Error: Invalid environment '$ENVIRONMENT'"
            log "Usage: $0 [staging|production] [version]"
            exit 1
            ;;
    esac
}

confirm_production() {
    if [ "$ENVIRONMENT" = "production" ]; then
        read -p "Are you sure you want to deploy to production? (yes/no) " -r
        if [ "$REPLY" != "yes" ]; then
            log "Deployment cancelled"
            exit 0
        fi
    fi
}

build_image() {
    log "Building Docker image..."
    docker build -t "myapp:$VERSION" .
    docker tag "myapp:$VERSION" "registry.example.com/myapp:$VERSION"
}

push_image() {
    log "Pushing image to registry..."
    docker push "registry.example.com/myapp:$VERSION"
}

deploy_kubernetes() {
    log "Deploying to Kubernetes..."

    # Update image tag in deployment
    kubectl set image deployment/myapp \
        myapp="registry.example.com/myapp:$VERSION" \
        -n "$ENVIRONMENT"

    # Wait for rollout
    kubectl rollout status deployment/myapp -n "$ENVIRONMENT" --timeout=5m
}

run_smoke_tests() {
    log "Running smoke tests..."

    local url
    case "$ENVIRONMENT" in
        staging)    url="https://staging.example.com" ;;
        production) url="https://example.com" ;;
    esac

    # Health check
    if curl -sf "$url/health" > /dev/null; then
        log "Health check passed"
    else
        log "Health check failed!"
        exit 1
    fi
}

notify_slack() {
    local status="$1"
    local webhook_url="$SLACK_WEBHOOK_URL"

    curl -X POST -H 'Content-type: application/json' \
        --data "{\"text\":\"Deployment to $ENVIRONMENT: $status (version: $VERSION)\"}" \
        "$webhook_url"
}

main() {
    validate_environment
    confirm_production

    log "Starting deployment of version $VERSION to $ENVIRONMENT"

    build_image
    push_image
    deploy_kubernetes
    run_smoke_tests

    notify_slack "Success"
    log "Deployment completed successfully"
}

# Error handling
trap 'notify_slack "Failed"; log "Deployment failed!"' ERR

main
```

---

## Monorepo Tools

### Turborepo

```json
// turbo.json
{
  "$schema": "https://turbo.build/schema.json",
  "globalDependencies": ["**/.env.*local"],
  "pipeline": {
    "build": {
      "dependsOn": ["^build"],
      "outputs": ["dist/**", ".next/**"]
    },
    "lint": {
      "outputs": []
    },
    "test": {
      "dependsOn": ["build"],
      "outputs": ["coverage/**"]
    },
    "dev": {
      "cache": false,
      "persistent": true
    },
    "deploy": {
      "dependsOn": ["build", "test", "lint"],
      "outputs": []
    }
  }
}
```

```bash
# Run build in all packages
turbo build

# Run dev in specific packages
turbo dev --filter=web --filter=api

# Run with caching
turbo build --cache-dir=.turbo

# Dry run to see what would execute
turbo build --dry-run
```

### Nx

```json
// nx.json
{
  "targetDefaults": {
    "build": {
      "dependsOn": ["^build"],
      "inputs": ["production", "^production"]
    },
    "test": {
      "inputs": ["default", "^production"]
    }
  },
  "namedInputs": {
    "default": ["{projectRoot}/**/*"],
    "production": [
      "default",
      "!{projectRoot}/**/*.spec.ts",
      "!{projectRoot}/tsconfig.spec.json"
    ]
  }
}
```

```bash
# Run affected tests
nx affected:test

# Build specific project
nx build my-app

# Run task graph
nx graph

# Generate new library
nx generate @nx/js:library shared-utils
```

---

## Task Automation

### Gulp

```javascript
// gulpfile.js
const gulp = require('gulp');
const sass = require('gulp-sass')(require('sass'));
const autoprefixer = require('gulp-autoprefixer');
const cleanCSS = require('gulp-clean-css');
const terser = require('gulp-terser');
const imagemin = require('gulp-imagemin');
const del = require('del');

// Clean
gulp.task('clean', () => del(['dist']));

// Styles
gulp.task('styles', () =>
  gulp.src('src/styles/**/*.scss')
    .pipe(sass().on('error', sass.logError))
    .pipe(autoprefixer())
    .pipe(cleanCSS())
    .pipe(gulp.dest('dist/css'))
);

// Scripts
gulp.task('scripts', () =>
  gulp.src('src/js/**/*.js')
    .pipe(terser())
    .pipe(gulp.dest('dist/js'))
);

// Images
gulp.task('images', () =>
  gulp.src('src/images/**/*')
    .pipe(imagemin())
    .pipe(gulp.dest('dist/images'))
);

// Watch
gulp.task('watch', () => {
  gulp.watch('src/styles/**/*.scss', gulp.series('styles'));
  gulp.watch('src/js/**/*.js', gulp.series('scripts'));
  gulp.watch('src/images/**/*', gulp.series('images'));
});

// Build
gulp.task('build', gulp.series(
  'clean',
  gulp.parallel('styles', 'scripts', 'images')
));

// Default
gulp.task('default', gulp.series('build', 'watch'));
```

---

## Pre-commit Hooks

```javascript
// lint-staged.config.js
module.exports = {
  '*.{js,jsx,ts,tsx}': [
    'eslint --fix',
    'prettier --write',
    'vitest related --run',
  ],
  '*.{json,md,yml,yaml}': [
    'prettier --write',
  ],
  '*.css': [
    'stylelint --fix',
    'prettier --write',
  ],
};
```

```yaml
# .github/workflows/ci.yml
name: CI

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'

      - name: Install dependencies
        run: npm ci

      - name: Lint
        run: npm run lint

      - name: Type check
        run: npm run type-check

      - name: Test
        run: npm run test -- --run --coverage

      - name: Build
        run: npm run build
```

---

## Related Skills

- [[devops-cicd]] - CI/CD pipelines
- [[git-workflows]] - Git automation
- [[development-environment]] - Dev setup

© miles990 · MIT · miles990/claude-software-skills

Similar skills

All skills for Automation and no-code: n8n, Zapier, Make →

From the same set13

The whole set →

Project sponsors

Companies that keep this analytics open