30 Claude Prompts That Write Scripts

You are a systems engineer who writes dependable backup scripts. <context> I need a script that backs up a folder into timestamped archives and keeps only the last N, returned as a runnable, commented artifact suitable for daily cron runs. </context> <inputs> - Source folder: [PATH] - Backup destination: [PATH] - Archive format: [tar.gz / zip] - Exclude patterns: [E.G. node_modules, *.log, .cache] - Retention: [KEEP LAST N BACKUPS, E.G. 7] - Verify archive after creating?: [YES / NO] </inputs> <task> Write a bash script that creates a timestamped archive of the source (honoring exclude patterns), writes it to the destination, optionally verifies the archive integrity, then prunes old backups beyond the retention count. Log each step with timestamps to a log file and print a final summary (archive name, size, backups now retained). </task> <constraints> - One self-contained bash script; set -euo pipefail; correct handling of paths with spaces. - Retention prune deletes only this script's own timestamped archives, never anything else in the destination. - Comment each block; exit non-zero and log on any failure so cron can detect it. </constraints> <format> Return the full bash script as a code block, then a note on adding it to cron and testing the retention prune safely. </format>

You are a database reliability engineer who writes safe dump-and-rotate scripts. <context> I need a script that dumps my database to a compressed, timestamped file and rotates old dumps, returned as a runnable, commented artifact for scheduled backups. </context> <inputs> - Database type: [POSTGRES / MYSQL] - Connection: [HOST, PORT, DB NAME, USER] - Password source: [ENV VAR NAME / .pgpass or .my.cnf] - Backup folder: [PATH] - Retention: [KEEP LAST N / KEEP DAYS] - Compress with: [gzip / zstd] </inputs> <task> Write a bash script that runs pg_dump or mysqldump (per the chosen type) into a timestamped, compressed file, checks the dump exit code and non-zero file size before considering it successful, prunes dumps beyond the retention rule, and logs each step. Print the dump filename, size, and dumps retained. </task> <constraints> - One self-contained bash script; set -euo pipefail; never hardcode the password (read from env or a credentials file). - Treat an empty or zero-byte dump as a failure and do NOT prune old backups in that case. - Comment the dump, verify, and prune steps; exit non-zero on any failure. </constraints> <format> Return the full bash script as a code block, then a note on supplying credentials securely and adding it to cron with output logging. </format>

You are a DevOps engineer who writes reliable cloud-sync automation. <context> I need a script that syncs a local folder to an S3-compatible bucket, returned as a runnable, commented artifact I can run manually or on a schedule. </context> <inputs> - Local folder: [PATH] - Bucket + prefix: [s3://bucket/prefix] - Provider: [AWS S3 / S3-COMPATIBLE ENDPOINT URL] - Credentials source: [ENV VARS / AWS PROFILE] - Delete remote files not present locally?: [YES / NO] - Exclude patterns: [E.G. *.tmp, .DS_Store] </inputs> <task> Write a bash script that wraps the AWS CLI to sync the local folder to the bucket, applying exclude patterns and the chosen delete/mirror behavior. Do a --dryrun preview first when passed --preview, print a summary of files uploaded/updated/deleted, and log the run. Verify the AWS CLI and credentials are present before starting. </task> <constraints> - One self-contained bash script; set -euo pipefail; do not print secrets. - Preflight check that the CLI exists and credentials resolve; fail clearly if not. - Guard the delete/mirror option behind an explicit flag so it can't wipe the remote by accident. - Comment each step. </constraints> <format> Return the full bash script as a code block, then a note on setting credentials, using --preview, and enabling mirror mode safely. </format>

You are a security-minded engineer who writes encrypted-backup scripts. <context> I need a script that archives a folder, compresses it, and encrypts it so I can store it safely off-site, returned as a runnable, commented artifact. It should also be able to decrypt/restore. </context> <inputs> - Source folder: [PATH] - Output archive path: [PATH] - Encryption tool: [gpg SYMMETRIC / openssl AES-256] - Passphrase source: [ENV VAR NAME / PROMPT] - Exclude patterns: [OPTIONAL] - Mode: [BACKUP / RESTORE] </inputs> <task> Write a bash script with a backup mode (tar + compress + encrypt to a single output file) and a restore mode (decrypt + extract to a target folder). Verify the passphrase is available, never echo it, and confirm the encrypted output exists and is non-empty. Print the output path and size on backup, and the restored path on restore. </task> <constraints> - One self-contained bash script; set -euo pipefail; read the passphrase from env or a secure prompt, never a CLI arg. - Use a widely available tool (gpg or openssl); state which in a comment and check it is installed. - Comment the pipeline; on restore, refuse to overwrite an existing target unless --force is passed. </constraints> <format> Return the full bash script as a code block, then a note on supplying the passphrase securely and testing a round-trip backup then restore. </format>

You are a systems administrator who writes safe rsync-based sync scripts. <context> I need a script that mirrors one directory to another (local or over SSH) using rsync, returned as a runnable, commented artifact with logging and a dry-run mode. </context> <inputs> - Source path: [LOCAL PATH] - Destination: [LOCAL PATH OR user@host:/path] - Direction: [ONE-WAY MIRROR / UPDATE-ONLY (NO DELETE)] - Exclude patterns: [E.G. .git, node_modules, *.tmp] - Bandwidth limit: [OPTIONAL, E.G. 5000 KB/s] - Log file: [PATH] </inputs> <task> Write a bash script that builds the correct rsync command for the chosen direction (archive, compress-in-transit for remote, delete only in mirror mode), applies excludes and any bandwidth limit, runs a --dry-run when passed --preview, and appends a timestamped summary to the log. Print files transferred and bytes moved. </task> <constraints> - One self-contained bash script; set -euo pipefail; correct handling of trailing slashes so rsync doesn't nest folders. - The --delete flag is only ever used in explicit mirror mode; update-only mode never deletes. - Verify rsync (and ssh for remote) exist; comment the flag choices. </constraints> <format> Return the full bash script as a code block, then a note on the trailing-slash gotcha, using --preview, and setting up SSH keys for remote sync. </format>

You are a systems engineer who writes disk-hygiene automation. <context> I need a cron-ready script that cleans up and rotates old log files so a folder never fills the disk, returned as a runnable, commented artifact. </context> <inputs> - Log directory: [PATH] - File pattern: [E.G. *.log] - Compress logs older than: [E.G. 7 DAYS] - Delete logs older than: [E.G. 30 DAYS] - Also truncate huge active logs over: [SIZE, E.G. 500MB] - Dry-run first?: [YES / NO] </inputs> <task> Write a bash script that finds matching logs, gzips ones past the compress age, deletes ones past the delete age, and optionally truncates oversized active logs safely (without breaking a process holding the file open). Support --dry-run that only reports actions. Log what it did with timestamps and print bytes reclaimed. </task> <constraints> - One self-contained bash script; set -euo pipefail; operate ONLY inside the given log directory. - Never delete or truncate files outside the pattern; dry-run is default until --apply is passed. - Comment the age and size logic; make it idempotent and safe to run hourly. </constraints> <format> Return the full bash script as a code block, then a note on adding a cron entry and confirming the paths are scoped correctly. </format>

You are an SRE who writes lightweight monitoring scripts. <context> I need a cron-ready script that checks disk usage and alerts me when a mount crosses a threshold, returned as a runnable, commented artifact. </context> <inputs> - Mounts to watch: [E.G. / , /data] - Warn threshold: [E.G. 80%] - Critical threshold: [E.G. 90%] - Alert channel: [PRINT / WEBHOOK URL / EMAIL COMMAND] - Only alert on state change?: [YES / NO] - State file: [PATH] </inputs> <task> Write a bash script that reads usage for each watched mount, compares against warn/critical thresholds, and sends an alert with the mount, percent used, and free space. If 'only on change' is set, store last state and alert only when the level changes (ok -> warn -> critical). Exit code reflects the worst level found so cron can flag failures. Print a one-line status per mount. </task> <constraints> - One self-contained bash script; set -euo pipefail; use df in a portable way and parse safely. - Never crash on a missing mount; report it as an error line instead. - Comment the threshold and state-change logic; keep the alert payload compact. </constraints> <format> Return the full bash script as a code block, then a note on the exit-code convention, wiring the webhook, and scheduling it every 15 minutes. </format>

You are an automation engineer who builds scheduled reporting scripts. <context> I need a cron-ready script that gathers a few metrics each day and produces a formatted summary report, returned as a runnable, commented artifact. </context> <inputs> - Data sources: [E.G. A LOG FILE, A CSV, A SHELL COMMAND OUTPUT] - Metrics to compute: [E.G. TOTAL EVENTS, ERROR COUNT, TOP 5 ITEMS] - Report format: [PLAIN TEXT / MARKDOWN / HTML] - Output: [WRITE TO FILE PATH / PRINT / PIPE TO EMAIL COMMAND] - Date range: [TODAY / LAST 24H] - Language: [PYTHON / BASH / AUTO] </inputs> <task> Write a script that reads the configured sources, computes the requested metrics for the date range, and renders a clean report in the chosen format with a title, a timestamp, a metrics summary section, and a top-items table. Write it to the output target. Print a confirmation line with the report path or a short preview. </task> <constraints> - Prefer standard library; if a data source is missing, note it in the report rather than crashing. - Deterministic formatting; numbers aligned; timestamps in ISO format. - Comment the parsing and aggregation logic so I can add a new metric. </constraints> <format> Return the full script as a code block, then a note on adding a metric, choosing the output target, and scheduling it daily via cron. </format>

You are an SRE who writes endpoint monitoring scripts. <context> I need a cron-ready script that checks whether a list of URLs or services is healthy and alerts on failures, returned as a runnable, commented artifact. </context> <inputs> - Targets to check: [LIST OF URLs OR host:port] - Success criteria: [HTTP 200-399 / EXPECTED TEXT IN BODY / TCP CONNECT] - Timeout per check: [SECONDS] - Retries before failing: [E.G. 2] - Alert channel: [PRINT / WEBHOOK URL / LOG] - Alert on recovery too?: [YES / NO] </inputs> <task> Write a script that checks each target against its success criteria with the configured timeout and retries, records status, and sends an alert when a target goes down (and optionally when it recovers). Track state between runs so it doesn't re-alert on an already-down target. Print a status table and set the exit code to non-zero if anything is down. </task> <constraints> - Prefer standard library / curl; store per-target state in a small JSON file. - Handle DNS/connection errors as 'down', not as script crashes; respect the timeout strictly. - Comment the check, retry, and state-transition logic. </constraints> <format> Return the full script as a code block, then a note on the state file, the exit-code convention, and scheduling it every few minutes via cron. </format>

You are a systems engineer who writes process-supervision scripts. <context> I need a cron-ready watchdog script that checks whether a process or service is running and restarts it if it has died, returned as a runnable, commented artifact. </context> <inputs> - Service identifier: [PROCESS NAME / PID FILE / systemd UNIT / PORT] - How to detect it: [pgrep / PID FILE / port CHECK / systemctl is-active] - Restart command: [E.G. systemctl restart X / A SHELL COMMAND] - Max restarts per window: [E.G. 3 IN 10 MIN] - Log file: [PATH] - Notify on restart?: [PRINT / WEBHOOK] </inputs> <task> Write a bash script that detects whether the service is alive using the chosen method, and if not, runs the restart command, logs the event with a timestamp, and optionally notifies. Implement a restart-rate limit: if it has restarted more than N times in the window, stop trying and log a 'flapping' alert instead of looping forever. Print the current state and any action taken. </task> <constraints> - One self-contained bash script; set -euo pipefail; track restart timestamps in a small state file. - Never spawn duplicate instances; respect the rate limit so a broken service can't be restart-looped. - Comment the detection, restart, and flap-guard logic. </constraints> <format> Return the full bash script as a code block, then a note on the detection method, the flap guard, and scheduling it every minute via cron. </format>

You are a backend engineer who writes robust API client scripts. <context> I need a script that pulls all records from a paginated REST API and writes them to a CSV, returned as a runnable, commented artifact. </context> <inputs> - Base endpoint: [URL] - Auth: [NONE / BEARER TOKEN (ENV VAR) / API KEY HEADER] - Pagination style: [PAGE NUMBER / offset+limit / CURSOR IN RESPONSE] - Fields to keep: [LIST OF JSON PATHS] - Output CSV: [PATH] - Language: [PYTHON / NODE / AUTO] </inputs> <task> Write a script that requests each page following the pagination style, accumulates records until there are no more, flattens the chosen fields out of each JSON object, and writes them to a CSV with a header. Read the token/key from an environment variable. Retry transient errors (429, 5xx) with exponential backoff and honor a Retry-After header. Print pages fetched and total rows. </task> <constraints> - Prefer standard library (or requests); never hardcode the token; document the env var in a comment. - Correct backoff-and-retry on 429/5xx; stop cleanly at the last page. - Comment the pagination and field-flattening logic; handle an empty result set. </constraints> <format> Return the full script as a code block, then a note on setting the auth env var, adjusting the pagination style, and mapping fields. </format>

You are a backend engineer who writes reliable API integration scripts. <context> I need a script that reads records from a file and POSTs each to an API or webhook, returned as a runnable, commented artifact, with proper error handling. </context> <inputs> - Source file: [CSV OR JSON PATH] - Target endpoint: [URL] - Auth: [BEARER (ENV VAR) / API KEY HEADER / HMAC SIGNATURE] - Body mapping: [WHICH COLUMNS/FIELDS -> WHICH JSON KEYS] - On failure: [RETRY N TIMES / LOG AND SKIP / STOP] - Rate limit (requests/sec): [E.G. 5] </inputs> <task> Write a script that reads each record, maps it to the request body, and POSTs it with the configured auth and content-type. Honor the rate limit, retry failures with backoff per the chosen policy, and write a results log (record id, status code, response summary) plus a failures file for anything that didn't succeed. Print totals: sent, succeeded, failed. </task> <constraints> - Prefer standard library (or requests); read secrets from env vars, never inline. - Idempotency-friendly: log each result so a re-run can skip already-sent records if an id is available. - Comment the mapping, auth, and retry logic; validate the endpoint responds before bulk-sending. </constraints> <format> Return the full script as a code block, then a note on the body mapping, supplying auth via env, and re-running only the failures file. </format>

You are a data engineer who writes scheduled ingestion scripts. <context> I need a cron-ready script that polls an API on a schedule and appends new results to a local store (CSV or SQLite), returned as a runnable, commented artifact that only records new records. </context> <inputs> - Endpoint: [URL] - Auth: [NONE / BEARER (ENV VAR)] - Unique record key: [FIELD USED TO DEDUPE] - Store: [APPEND CSV / SQLITE TABLE] - Store path: [PATH] - Incremental param: [E.G. since=LAST_TIMESTAMP, OR NONE] </inputs> <task> Write a script that fetches the endpoint (using the incremental 'since' param when supported), parses the records, deduplicates against what is already stored using the unique key, and appends only new rows to the store. Persist the latest timestamp/cursor for the next run. Print records fetched, new records added, and duplicates skipped. </task> <constraints> - Prefer standard library (csv/sqlite3); create the store/table on first run. - Deduplicate reliably by the unique key; never insert a duplicate; handle an empty response. - Comment the incremental and dedup logic; read auth from env; retry transient errors. </constraints> <format> Return the full script as a code block, then a note on the dedup key, the incremental cursor, and scheduling it via cron. </format>

You are a backend engineer who writes high-throughput, well-behaved API clients. <context> I have a list of IDs or URLs to enrich by calling an API for each, and I need it done fast but safely, returned as a runnable, commented script artifact. </context> <inputs> - Input list: [FILE OF IDs/URLs] - Endpoint template: [E.G. https://api.x.com/items/{id}] - Auth: [BEARER (ENV VAR) / API KEY / NONE] - Concurrency: [E.G. 10 PARALLEL] - Global rate limit: [E.G. 20 REQUESTS/SEC] - Output: [JSONL / CSV PATH] </inputs> <task> Write a script that fires requests concurrently up to the concurrency cap while enforcing the global rate limit, collects each response (or error), and writes results streaming to the output file so a crash doesn't lose progress. Retry transient failures with backoff, and record failures separately. Print a live-ish progress count and final totals. </task> <constraints> - Use a concurrency primitive appropriate to the language (asyncio/aiohttp for Python, Promise pool for Node); state the choice in a comment. - Enforce BOTH the concurrency cap and the rate limit; never exceed either; back off on 429. - Stream output so progress survives interruption; comment the concurrency and rate-limit logic. </constraints> <format> Return the full script as a code block, then a note on tuning concurrency vs. rate limit and resuming from partial output. </format>

You are a backend engineer who writes caching utilities for API-heavy scripts. <context> I keep hitting the same API endpoints repeatedly during development and want a script/module that caches responses to disk to save time and quota, returned as a runnable, commented artifact. </context> <inputs> - Language: [PYTHON / NODE] - Cache location: [FOLDER PATH] - Cache TTL: [E.G. 1 HOUR, OR PER-CALL] - Key by: [FULL URL / URL + BODY] - Auth header handling: [EXCLUDE FROM CACHE KEY] - Max cache size / entries: [OPTIONAL] </inputs> <task> Write a small module with a cached_get/cached_request function that builds a cache key from the request (excluding auth headers), returns a fresh on-disk cached response when it exists and is within TTL, otherwise performs the real request, stores the response with a timestamp, and returns it. Include a --clear option to purge expired entries and a demo call at the bottom. Print cache hit vs. miss for each call. </task> <constraints> - Prefer standard library; store cache entries as files named by a hash of the key; never cache non-2xx responses. - Respect the TTL exactly; exclude Authorization from the key so tokens don't fragment the cache. - Comment the key-building, TTL, and eviction logic. </constraints> <format> Return the full module as a code block with a usage example, then a note on invalidating the cache and setting per-call TTLs. </format>