30 Claude Prompts That Write Bash Scripts

You are a DevOps engineer who writes safe, repeatable Bash deploy scripts. <context> I need one self-contained Bash script that deploys my app from my local machine to a remote server: build locally, package, upload, extract, and restart the service. I will save and run it as deploy.sh. </context> <inputs> - Local project directory and build command: [PATH, E.G. npm run build OR NONE] - Files to include and exclude in the tarball: [INCLUDE / EXCLUDE LISTS] - Remote target: [USER@HOST, DEST PATH] - Restart command on the server: [E.G. systemctl restart myapp, OR docker service update] - Post-deploy health check URL: [URL OR NONE] </inputs> <task> Write a Bash script that runs the build, creates a versioned tarball (excluding node_modules/.git/etc.), scp's it to the server, extracts it into the destination, runs the restart command over SSH, then hits the health check URL and rolls back messaging if it fails. Log each phase with a version tag and timestamps. Comment the packaging and the health-gate. </task> <constraints> - #!/usr/bin/env bash, set -euo pipefail. - Abort the whole deploy if the build fails; never upload a broken build. - Do not capture log output into the scp target variable; keep the tarball path clean. Verify the health check returns success before declaring the deploy done. </constraints> <format> Return the full script in one code block, then explain how to add a rollback to the previous release and where to inject secrets safely. </format>

You are a systems engineer who writes idempotent server provisioning scripts. <context> I need one self-contained Bash script that takes a fresh Linux server from bare to ready: packages, a non-root user, SSH hardening, firewall, and my base tooling. It must be safe to re-run. </context> <inputs> - Distro: [UBUNTU/DEBIAN / RHEL/ALMA] - Packages to install: [LIST, E.G. git, curl, ufw, fail2ban, docker] - New sudo user to create: [USERNAME + PUBLIC KEY] - SSH hardening: [DISABLE ROOT LOGIN, DISABLE PASSWORD AUTH — YES/NO] - Firewall ports to open: [E.G. 22, 80, 443] </inputs> <task> Write a Bash script that updates the package index, installs the packages, creates the sudo user with the provided public key, applies the SSH hardening to sshd_config (backing it up first), configures the firewall to allow the listed ports and enable it, and prints a summary of what changed. Make every step idempotent (check-before-change) so re-running is safe. Comment each hardening change. </task> <constraints> - #!/usr/bin/env bash, set -euo pipefail. - Must run as root or via sudo; detect and warn if not. - Never lock yourself out: only apply SSH password-auth changes after the new user and key are confirmed working; back up sshd_config before editing. </constraints> <format> Return the full script in one code block, then explain the safe order to test SSH access before closing password login and how to re-run it. </format>

You are a Bash and Docker automation engineer. <context> I need one self-contained Bash script that deploys a new version of a Docker container with minimal downtime and waits until it is healthy before finishing. </context> <inputs> - Image name and how it is built or pulled: [IMAGE:TAG, BUILD FROM DOCKERFILE / docker pull] - Container or service name: [NAME] - Run mode: [docker run / docker compose / docker service update (swarm)] - Health check: [CONTAINER HEALTHCHECK / curl AN ENDPOINT / PORT OPEN] - Env vars to pass: [LIST OR REFERENCE AN ENV FILE] </inputs> <task> Write a Bash script that builds or pulls the image with a version tag, starts the new container/service using the chosen run mode, waits in a loop (with timeout) until the health check passes, and only then removes the old container or confirms convergence. On health-check timeout, print logs and exit non-zero. Comment the tagging and the health-wait loop. </task> <constraints> - #!/usr/bin/env bash, set -euo pipefail. - Never delete the old container before the new one is confirmed healthy. - Bound the health-wait with a max timeout; do not loop forever. Verify docker is available up front. </constraints> <format> Return the full script in one code block, then explain how to roll back to the previous image tag and how to prune old images safely afterward. </format>

You are a developer-experience engineer who writes onboarding scripts. <context> New teammates waste a day setting up. I need one self-contained Bash script that gets a dev machine from clone to running in one command, idempotently. </context> <inputs> - OS support target: [MACOS / LINUX / BOTH] - Tools and versions to install: [E.G. node 20, python 3.12, docker, a package manager] - Repo tasks: [INSTALL DEPS, COPY .env.example TO .env, RUN MIGRATIONS, SEED] - Version manager preference: [nvm/asdf/pyenv OR SYSTEM PACKAGES] - Final check: [E.G. npm run dev STARTS, OR A SMOKE TEST] </inputs> <task> Write a Bash script that detects the OS, installs the required tools via the appropriate package manager (Homebrew on macOS, apt on Debian/Ubuntu), sets up the version manager and language versions, installs project dependencies, prepares the .env file if missing, runs migrations/seed, and finishes with the smoke check. Skip anything already present (idempotent) and print a clear next-steps summary. Comment the OS-detection and each install step. </task> <constraints> - #!/usr/bin/env bash, set -euo pipefail. - Check for each tool before installing; never clobber an existing .env. - Fail with an actionable message if a required tool cannot be installed automatically. </constraints> <format> Return the full script in one code block, then explain how to keep it idempotent as the stack grows and how to make it re-runnable after a pull. </format>

You are a release engineer who writes git-driven deploy scripts. <context> I need one self-contained Bash script that deploys the latest code on a server by fetching a git branch, building, restarting, and keeping the ability to roll back to the previous commit instantly. </context> <inputs> - Repo path on the server: [PATH] - Branch to deploy: [E.G. main] - Build/install command: [E.G. npm ci && npm run build] - Restart command: [E.G. systemctl restart app / pm2 reload] - Health check: [URL OR COMMAND, AND TIMEOUT] </inputs> <task> Write a Bash script that records the current commit SHA (for rollback), fetches and hard-resets to origin/BRANCH, runs the build, restarts the service, and runs the health check. If the health check fails, automatically reset back to the recorded SHA, rebuild, restart, and report the rollback. Log each phase with the SHA. Support a manual --rollback flag that reverts to the last recorded good SHA. Comment the rollback bookkeeping. </task> <constraints> - #!/usr/bin/env bash, set -euo pipefail. - Fail fast if the working tree is dirty or the branch does not exist. - Persist the last-known-good SHA to a file so --rollback works across separate invocations. </constraints> <format> Return the full script in one code block, then explain the deploy-then-verify-then-keep-or-revert flow and how to test the rollback path safely. </format>

You are a Bash scripting engineer who writes maintenance cron jobs. <context> An app writes logs that grow forever. I need one self-contained Bash script, meant to run from cron, that rotates and compresses logs and deletes ones past a retention window. </context> <inputs> - Log directory and pattern: [PATH, E.G. *.log] - Rotate when a file exceeds: [SIZE, E.G. 50M — OR ROTATE DAILY REGARDLESS] - Compress rotated logs: [YES gzip / NO] - Delete rotated logs older than: [N DAYS] - Signal the app to reopen logs after rotation: [COMMAND OR NONE] </inputs> <task> Write a Bash script that finds matching logs, rotates each qualifying file to NAME-YYYYMMDD.log (or numbered), compresses it if enabled, sends the optional reopen signal to the app, then deletes compressed logs older than the retention window. Print a summary of rotated and deleted files. Comment why the reopen signal matters and the retention logic. </task> <constraints> - #!/usr/bin/env bash, set -euo pipefail. - Be cron-safe: no interactive prompts, absolute paths, and a clear exit code. - Do not truncate a log the app still has open without sending the reopen signal (or note logrotate as the production-grade alternative). </constraints> <format> Return the full script in one code block, then give the exact crontab line to run it nightly and note when to prefer logrotate instead. </format>

You are a Bash scripting expert who writes robust scheduled jobs. <context> My backup cron sometimes overlaps with the previous run and doubles the load. I need one self-contained Bash script that guarantees only one instance runs at a time using a lock. </context> <inputs> - The command or steps the job performs: [DESCRIBE, E.G. tar + upload] - Lock file location: [PATH, E.G. /var/lock/mybackup.lock] - Behavior if already running: [EXIT QUIETLY / LOG AND EXIT] - Max expected runtime for a stale-lock warning: [MINUTES] - Log file path: [PATH] </inputs> <task> Write a Bash script that acquires an exclusive lock with flock at the top (self-locking via a file descriptor), and if the lock is held, exits per the chosen behavior. Inside the lock, run the job steps, timing them, and log start/finish/duration to the log file. Warn if the run exceeds the max-runtime hint. Ensure the lock is always released, even on error. Comment the flock mechanism. </task> <constraints> - #!/usr/bin/env bash, set -euo pipefail. - Use flock so the lock auto-releases if the process dies (no stale lock files to clean up manually). - Cron-safe: absolute paths, no prompts, meaningful exit codes. </constraints> <format> Return the full script in one code block, then give the crontab line and explain why flock beats a hand-rolled PID file. </format>

You are a database operations engineer who writes scheduled backup jobs. <context> I want a cron job as one self-contained Bash script that dumps my database on a schedule, keeps a tiered retention (daily/weekly/monthly), and reports failures loudly. </context> <inputs> - Engine and connection: [POSTGRES/MYSQL, HOST, DB, USER] - Credential source: [ENV / .pgpass / .my.cnf] - Backup root directory: [PATH] - Retention tiers: [E.G. KEEP 7 DAILY, 4 WEEKLY, 6 MONTHLY] - Failure alert: [WEBHOOK / EMAIL / EXIT NON-ZERO ONLY] </inputs> <task> Write a Bash script that dumps the database compressed with a timestamp into a daily folder, then on the right calendar days copies or promotes the dump into weekly and monthly folders, and prunes each tier to its retention count. Check the dump's exit status (with pipefail) and alert on failure. Log every action. Comment the tiered-retention promotion logic. </task> <constraints> - #!/usr/bin/env bash, set -euo pipefail. - Credentials from env or a protected file, never inline; exit non-zero on any dump failure. - Prune strictly per tier and never delete the most recent dump in any tier. </constraints> <format> Return the full script in one code block, then give the crontab line and explain the daily/weekly/monthly promotion so retention is predictable. </format>

You are a Bash and TLS automation engineer. <context> I need one self-contained Bash script, run from cron, that renews certificates only when they are near expiry and reloads the web server just once if anything changed. </context> <inputs> - Renewal tool: [certbot / acme.sh / OTHER COMMAND] - Domains or leave to the tool's config: [LIST OR AUTO] - Days-before-expiry to trigger renewal: [E.G. 30] - Web server reload command: [E.G. nginx -s reload / systemctl reload nginx] - Failure alert: [WEBHOOK / EMAIL / STDOUT] </inputs> <task> Write a Bash script that runs the renewal tool in its check-and-renew mode, captures whether any certificate was actually renewed, and reloads the web server only if a renewal occurred. On renewal failure, alert with the tool's error output. Log the outcome (renewed / not yet due / failed) with a timestamp. Comment the deploy-hook vs conditional-reload approach. </task> <constraints> - #!/usr/bin/env bash, set -euo pipefail. - Do not reload the web server on every run — only when a cert changed. - Cron-safe with absolute paths; exit non-zero on renewal failure so it is noticed. </constraints> <format> Return the full script in one code block, then give the twice-daily crontab line certbot recommends and explain deploy hooks as an alternative. </format>

You are a Bash scripting engineer who builds reporting automation. <context> I want a cron job as one self-contained Bash script that gathers a few metrics or log summaries and sends me a short daily digest by email or webhook. </context> <inputs> - What to include: [E.G. DISK USAGE, ERROR COUNT FROM A LOG, NEW SIGNUPS FROM A QUERY, BACKUP STATUS] - How to fetch each: [COMMAND OR QUERY PER ITEM] - Delivery: [mail/sendmail / SLACK OR DISCORD WEBHOOK / SES] - Recipient(s): [ADDRESS OR CHANNEL] - Subject line format: [E.G. Daily report — HOSTNAME — DATE] </inputs> <task> Write a Bash script that runs each fetch step, formats the results into a clean plain-text (or simple HTML) digest with a header and one section per metric, then delivers it via the chosen channel. Handle a failed fetch by including an error line for that item rather than aborting the whole report. Log delivery success/failure. Comment how each metric is gathered and the delivery block. </task> <constraints> - #!/usr/bin/env bash, set -euo pipefail (but isolate each fetch so one failure does not kill the digest). - Cron-safe: absolute paths, no prompts. Do not embed secrets inline; read tokens from env. - Keep the message concise and skimmable. </constraints> <format> Return the full script in one code block, then give the crontab line for a daily send and explain how to add a new metric section. </format>

You are a Bash and awk expert who writes log-analysis one-shot scripts. <context> I need one self-contained Bash script that parses a web server access log and prints a useful summary, so I can save it and run it against any log file. </context> <inputs> - Log file path: [PATH] - Log format: [COMMON/COMBINED NGINX/APACHE, OR DESCRIBE FIELD ORDER] - What to report: [TOP IPS, TOP URLS, STATUS-CODE BREAKDOWN, TOP 4xx/5xx PATHS, REQUESTS PER HOUR] - Time window filter: [E.G. TODAY, LAST HOUR, OR ALL] - Top-N size: [E.G. 20] </inputs> <task> Write a Bash script that uses awk to parse the chosen log format and produce each requested report as a clean, aligned table (rank, count, value), sorted descending. Include totals (total requests, unique IPs, error rate). Support reading from a file or stdin so it can be piped. Comment the awk field mapping and each aggregation. </task> <constraints> - #!/usr/bin/env bash, set -euo pipefail. - Do the heavy lifting in a single awk pass where possible; avoid slow shell loops over lines. - Handle a missing or empty log file with a clear message; align columns with printf or column -t. </constraints> <format> Return the full script in one code block, then explain how to adapt the awk field numbers to a custom log format and how to pipe zcat of a gzipped log into it. </format>

You are an awk and Bash expert who writes reliable CSV-processing scripts. <context> I need one self-contained Bash script that extracts, reorders, filters, or computes columns from a CSV file using awk, so I can reshape data without a spreadsheet. </context> <inputs> - Input CSV path and whether it has a header: [PATH, HEADER YES/NO] - Delimiter: [COMMA / TAB / OTHER] - Columns to keep and in what order: [E.G. 1,3,2 OR BY HEADER NAME] - Filter condition: [E.G. COLUMN 4 > 100, OR NONE] - Computed column: [E.G. ADD A TOTAL = col2*col3, OR NONE] </inputs> <task> Write a Bash script that uses awk with the correct field separator to select and reorder the requested columns, apply the optional row filter, and append any computed column, preserving or regenerating the header. Print the result to stdout (redirectable to a new file). Note the limitation with quoted fields containing the delimiter and how to handle it. Comment the FS/OFS setup and the filter/compute logic. </task> <constraints> - #!/usr/bin/env bash, set -euo pipefail. - Set FS and OFS correctly; keep the header aligned with the reordered columns. - Warn (in a comment and at runtime if detected) that naive awk splitting breaks on quoted commas, and suggest a real CSV tool for that case. </constraints> <format> Return the full script in one code block, then explain selecting columns by header name vs number and when to reach for csvkit instead. </format>

You are a Bash and sed expert who writes safe in-place editing scripts. <context> I need one self-contained Bash script that finds a string or pattern across many files and replaces it, with a preview and a backup, so I never corrupt a codebase. </context> <inputs> - Directory to search: [PATH] - File filter: [E.G. *.js, *.md, OR ALL TEXT FILES] - Search pattern: [LITERAL STRING OR REGEX] - Replacement: [TEXT] - Recursive: [YES / NO], case-sensitive: [YES / NO] </inputs> <task> Write a Bash script that lists every match first (with file and line) as a preview under a default --dry-run, then, only with --apply, performs the sed substitution in place while creating a .bak of each changed file. Report how many files and lines changed. Escape the pattern and replacement for sed safely, and skip binary files. Comment the escaping and the portable in-place editing (GNU vs BSD sed -i). </task> <constraints> - #!/usr/bin/env bash, set -euo pipefail. - Default is DRY-RUN; --apply is required to modify files and must write .bak backups. - Handle the sed -i portability difference between Linux and macOS; use grep -Il to skip binaries and survive spaces in paths. </constraints> <format> Return the full script in one code block, then explain how to review changes with the .bak files and how to escape special regex characters in the pattern. </format>

You are a Bash and grep expert who writes text-mining scripts. <context> I need one self-contained Bash script that extracts all occurrences of a pattern from files (e.g. emails, IPs, error codes, URLs), counts and ranks them, so I can save and reuse it. </context> <inputs> - Files or directory to search: [PATH OR GLOB] - What to extract: [E.G. EMAIL ADDRESSES / IPv4 / URLS / A CUSTOM REGEX] - Recursive: [YES / NO] - Output: [UNIQUE SORTED LIST / RANKED BY FREQUENCY / RAW MATCHES] - Optional: also show the file each match came from: [YES / NO] </inputs> <task> Write a Bash script that runs grep -Eo with the appropriate regex to pull only the matching substrings, then pipes through sort and uniq -c to rank by frequency (or just dedupe) per the chosen output. Provide ready-made regexes for email, IPv4, and URL, and allow a custom pattern. Print a clean ranked table. Comment each provided regex and the sort | uniq -c pipeline. </task> <constraints> - #!/usr/bin/env bash, set -euo pipefail. - Use grep -Eo for match-only extraction; use -r only when recursive is chosen. - Note the limits of regex email/URL matching in a comment; handle no-matches gracefully. </constraints> <format> Return the full script in one code block, then explain how to plug in a custom regex and how to feed piped input from another command. </format>

You are a Bash and sed expert who automates config-file edits safely. <context> I need one self-contained Bash script that sets or updates a key-value setting in a config file (e.g. add the line if missing, replace it if present) without duplicating entries, so it is safe to run repeatedly. </context> <inputs> - Config file path: [PATH] - Setting format: [E.G. KEY=VALUE, key value, key: value] - Key to set: [KEY] - New value: [VALUE] - Comment character to respect: [E.G. #] </inputs> <task> Write a Bash script that backs up the config file, then uses sed/grep to check whether the key already exists (uncommented): if it does, replace its value in place; if it exists only commented out, uncomment and set it; if it is absent, append the setting. Guarantee exactly one active line for the key (idempotent). Print a before/after diff of the changed line. Comment the three-case logic and the escaping. </task> <constraints> - #!/usr/bin/env bash, set -euo pipefail. - Always back up the file first; escape the value for sed (slashes, ampersands) and use a delimiter unlikely to collide. - Running twice with the same input must leave the file unchanged (true idempotency); handle the portable sed -i difference. </constraints> <format> Return the full script in one code block, then explain how to extend it to multiple keys and how to verify idempotency by running it twice. </format>