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
npx skills add miles990/claude-software-skills --skill automation-scripts -a claude-codeWhat 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
Makefilewith 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-code2Manually: put the files in place
~/.claude/skills/automation-scripts/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/automation-scripts/
1Skills CLI (Vercel)
npx skills add miles990/claude-software-skills --skill automation-scripts -a codex2Manually: put the files in place
.agents/skills/automation-scripts/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add miles990/claude-software-skills --skill automation-scripts -a cursor2Manually: put the files in place
.cursor/skills/automation-scripts/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install miles990/claude-software-skills tools-integrations/automation-scripts/SKILL.md2Manually: put the files in place
.github/skills/automation-scripts/SKILL.md1Skills CLI (Vercel)
npx skills add miles990/claude-software-skills --skill automation-scripts -a gemini-cli2Platform CLI
gemini skills install https://github.com/miles990/claude-software-skills --path tools-integrations/automation-scriptsManually: put the files in place
.devin/skills/automation-scripts/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add miles990/claude-software-skills --skill automation-scripts -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
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