30 Claude Prompts That Write PowerShell Scripts

You are a senior Windows systems administrator and PowerShell automation engineer. <context> I need a self-contained PowerShell script that collects a full hardware and OS inventory for one or many machines and exports it to CSV, runnable in an elevated prompt. </context> <inputs> - Scope: [LOCAL / LIST OF COMPUTER NAMES OR A TXT FILE] - Data to collect: [OS + BUILD, CPU, RAM, SERIAL, MODEL, DISKS, IP, LAST BOOT] - Output folder for the CSV: [PATH] - Filename convention: [E.G. Inventory_YYYYMMDD.csv] - Credential for remote (if needed): [PROMPT / CURRENT USER] </inputs> <task> Write a script that queries each computer with Get-CimInstance (Win32_OperatingSystem, Win32_ComputerSystem, Win32_Processor, Win32_BIOS, Win32_LogicalDisk, network config) and builds one row per machine with the requested fields, converting bytes to GB and formatting last-boot time. Export all rows to a timestamped CSV and print a console summary of successes and failures. </task> <constraints> - One runnable .ps1 file; valid PowerShell 5.1+ syntax; use CIM sessions for remote queries. - Handle offline or unauthorized machines with try/catch and record them as failed rows, do not abort the whole run. - One consistent object schema so the CSV columns line up across all machines. </constraints> <format> Return the full script in one code block, then a short note on supplying the computer list and opening the CSV in Excel. </format>

You are a senior Windows systems administrator and PowerShell automation engineer. <context> I need a self-contained PowerShell script that checks disk free space across servers and emails a formatted HTML report, runnable as a daily scheduled task. </context> <inputs> - Servers to check: [LIST OR TXT FILE] - Warning / critical thresholds: [E.G. WARN < 20%, CRITICAL < 10%] - SMTP server, from, to: [HOST, FROM, RECIPIENTS] - Only email if any drive is below threshold?: [YES / ALWAYS SEND] - Include: [ALL FIXED DRIVES / SPECIFIC LETTERS] </inputs> <task> Write a script that queries logical disks with Get-CimInstance Win32_LogicalDisk (DriveType 3) per server, computes free percent and free GB, and builds an HTML table with rows color-coded green/amber/red against the thresholds. Sort worst-first, add a summary header, and send it with Send-MailMessage as an HTML body. Optionally suppress the email when everything is healthy. </task> <constraints> - One runnable .ps1 file; valid PowerShell 5.1+ syntax. - Inline CSS in the HTML so it renders in Outlook; handle unreachable servers as a clearly marked error row. - Wrap SMTP send in try/catch and log the outcome; no external modules. </constraints> <format> Return the full script in one code block, then a short note on setting thresholds and scheduling the daily send. </format>

You are a senior Windows systems administrator and PowerShell automation engineer. <context> I need a self-contained PowerShell script that pulls filtered Windows event log entries and exports them to CSV for troubleshooting or audit, runnable in an elevated prompt. </context> <inputs> - Log(s): [E.G. System, Application, Security] - Levels: [ERROR, WARNING, CRITICAL] - Time range: [E.G. LAST 24 HOURS OR A START/END] - Optional filters: [EVENT IDs, SOURCE/PROVIDER, MESSAGE KEYWORD] - Output CSV path: [PATH] </inputs> <task> Write a script that queries events with Get-WinEvent and a FilterHashtable (log name, level, start time), then applies any extra filters for event ID, provider, or message text. Select TimeCreated, LogName, Level, Id, ProviderName, and a trimmed Message, sort newest-first, and export to a timestamped CSV. Print a count-by-EventID summary to the console. </task> <constraints> - One runnable .ps1 file; valid PowerShell 5.1+ syntax. - Prefer Get-WinEvent with FilterHashtable for speed over Get-EventLog; handle 'no events found' cleanly. - Escape/trim multi-line messages so the CSV stays well-formed; no external modules. </constraints> <format> Return the full script in one code block, then a short note on adjusting the time range and event-ID filter. </format>

You are a senior Windows systems administrator and PowerShell automation engineer. <context> I need a self-contained PowerShell script that lists installed software (with versions) across machines and exports it to CSV for license and audit tracking, runnable in an elevated prompt. </context> <inputs> - Scope: [LOCAL / LIST OF COMPUTERS] - Fields: [NAME, VERSION, PUBLISHER, INSTALL DATE, ARCHITECTURE] - Filter: [ALL / NAME CONTAINS KEYWORD / PUBLISHER] - Output CSV path: [PATH] - Dedupe identical entries?: [YES / NO] </inputs> <task> Write a script that reads installed programs from the uninstall registry keys (both 64-bit and 32-bit hives) rather than the slow Win32_Product class, per machine, and builds a row per product with the requested fields. Apply the filter, optionally dedupe, tag each row with the computer name, and export a timestamped CSV. Print a per-machine count summary. </task> <constraints> - One runnable .ps1 file; valid PowerShell 5.1+ syntax. - Read the registry uninstall keys (avoid Win32_Product, which is slow and can trigger repairs); note this in a comment. - For remote scope use Invoke-Command; handle offline machines with try/catch and mark them failed. </constraints> <format> Return the full script in one code block, then a short note on the registry-vs-Win32_Product choice and filtering by publisher. </format>

You are a senior Windows systems administrator and PowerShell automation engineer. <context> I need a self-contained PowerShell script that scans local certificate stores for certificates nearing expiry and reports them, runnable as a scheduled audit. </context> <inputs> - Stores to scan: [E.G. LocalMachine\My, LocalMachine\WebHosting] - Warn window: [E.G. EXPIRES WITHIN 30 DAYS] - Scope: [LOCAL / LIST OF SERVERS] - Output: [CONSOLE TABLE + CSV / ALSO EMAIL] - Ignore self-signed / specific issuers?: [OPTIONAL EXCLUSIONS] </inputs> <task> Write a script that enumerates certificates in the chosen stores with Get-ChildItem Cert:\, calculates days-until-expiry, and lists those expiring within the warn window (plus any already expired) with subject, issuer, thumbprint, NotAfter, and days left. Sort by days remaining ascending, apply exclusions, export to a timestamped CSV, and optionally email the summary. </task> <constraints> - One runnable .ps1 file; valid PowerShell 5.1+ syntax. - For remote scope use Invoke-Command against the cert provider; handle unreachable hosts with try/catch. - Clearly separate 'expiring soon' from 'already expired' in the output; no external modules. </constraints> <format> Return the full script in one code block, then a short note on choosing stores and scheduling the weekly report. </format>

You are a senior Windows systems administrator and PowerShell automation engineer. <context> I need a self-contained PowerShell script that registers another script as a Windows scheduled task with the right trigger and account, runnable once in an elevated prompt. </context> <inputs> - Script to run and arguments: [PATH + ANY ARGS] - Task name and folder: [NAME, OPTIONAL TASK PATH] - Trigger: [DAILY AT TIME / AT STARTUP / EVERY N MINUTES / AT LOGON] - Run as: [SYSTEM / A SPECIFIC SERVICE ACCOUNT] - Run whether user logged on or not, highest privileges?: [YES / NO] </inputs> <task> Write a script that builds the action (powershell.exe -NoProfile -ExecutionPolicy Bypass -File <script> <args>), the trigger from the chosen schedule, the principal (account and run level), and settings (start-when-available, restart-on-failure), then registers it with Register-ScheduledTask. If a task with that name exists, update it instead of erroring. Print the resulting task's next run time to confirm. </task> <constraints> - One runnable .ps1 file; valid PowerShell 5.1+ syntax using the ScheduledTasks module cmdlets. - Use -NoProfile and -ExecutionPolicy Bypass in the action so the task runs consistently; comment why. - Handle an existing task by updating rather than failing; prompt for or accept the service account credential securely. </constraints> <format> Return the full script in one code block, then a short note on verifying the task in Task Scheduler and choosing the run account. </format>

You are a senior Windows systems administrator and PowerShell automation engineer. <context> I need a self-contained PowerShell script that rotates and compresses application log files and purges old ones, designed to run daily as a scheduled task. </context> <inputs> - Log folder(s): [PATH(S)] - Files to rotate: [E.G. *.log] - Rotate when: [SIZE OVER N MB / DAILY REGARDLESS] - Compress rotated logs?: [ZIP / LEAVE PLAIN] - Retention: [DELETE ARCHIVES OLDER THAN N DAYS] </inputs> <task> Write a script that, for each matching log, renames it with a date/time stamp, optionally compresses the rotated copy with Compress-Archive, recreates an empty active log if needed, and deletes archived logs older than the retention period. Write its own run log with counts of rotated, compressed, and purged files, and exit nonzero on failure so the scheduler flags it. </task> <constraints> - One runnable .ps1 file; valid PowerShell 5.1+ syntax; support -WhatIf. - Do not rotate a file that is exclusively locked, skip and log it; never delete inside the retention window. - Idempotent and safe to run daily; no external modules. </constraints> <format> Return the full script in one code block, then a short note on picking a rotation trigger and scheduling it nightly. </format>

You are a senior Windows systems administrator and PowerShell automation engineer. <context> I need a self-contained PowerShell script that performs a scheduled backup of files or a database dump to a target location with verification, designed to run unattended. </context> <inputs> - What to back up: [FOLDER(S) / SQL DUMP COMMAND / FILE LIST] - Destination: [LOCAL PATH / UNC SHARE] - Compression and naming: [ZIP, TIMESTAMP FORMAT] - Retention policy: [KEEP LAST N / N DAYS] - Notify on result: [EMAIL / EVENT LOG / LOG FILE ONLY] </inputs> <task> Write a script that runs the backup (copy or compress the sources, or invoke the provided dump command), writes a timestamped archive to the destination, verifies the archive exists and is non-zero in size, prunes old backups per the retention policy, and sends the chosen success/failure notification. Record duration, size, and status in a run log, and return a nonzero exit code on any failure. </task> <constraints> - One runnable .ps1 file; valid PowerShell 5.1+ syntax. - Verify destination reachability and free space before backing up; verify the archive after writing. - Wrap each stage in try/catch; never silently succeed if verification fails; no external modules beyond built-ins. </constraints> <format> Return the full script in one code block, then a short note on plugging in a DB dump command and scheduling it. </format>

You are a senior Windows systems administrator and PowerShell automation engineer. <context> I need a self-contained PowerShell script that reports pending and recently installed Windows updates and flags machines missing patches, designed to run on a schedule. </context> <inputs> - Scope: [LOCAL / LIST OF SERVERS] - Report: [PENDING UPDATES / LAST N INSTALLED / BOTH] - Flag if: [PENDING SECURITY UPDATES OR NO UPDATE IN N DAYS] - Output: [CSV / HTML EMAIL] - SMTP details if emailing: [HOST, FROM, TO] </inputs> <task> Write a script that uses the Windows Update COM API (Microsoft.Update.Session / Searcher) to list pending updates and reads recent installs from the update history per machine, then builds a per-machine summary of pending count, last-installed date, and a compliance flag. Export to CSV or send an HTML email highlighting non-compliant machines. Handle machines that need a reboot to finish updates. </task> <constraints> - One runnable .ps1 file; valid PowerShell 5.1+ syntax; use the Update COM API (no third-party module required). - For remote scope use Invoke-Command; handle unreachable machines and access errors with try/catch as failed rows. - Clearly mark reboot-pending and non-compliant machines; comment the COM calls. </constraints> <format> Return the full script in one code block, then a short note on running it remotely and scheduling a weekly compliance report. </format>

You are a senior Windows systems administrator and PowerShell automation engineer. <context> I need a self-contained PowerShell script that mirrors or syncs a source folder to a destination using Robocopy with proper logging and exit-code handling, designed to run on a schedule. </context> <inputs> - Source and destination: [PATH / UNC] - Mode: [MIRROR (DELETE EXTRAS) / COPY NEW+CHANGED ONLY] - Excludes: [FILES/DIRS TO SKIP] - Multithreading and retries: [E.G. /MT:16, /R:2 /W:5] - Log folder: [PATH] </inputs> <task> Write a script that constructs the Robocopy command from the inputs (mirror vs copy, excludes, threads, retry/wait), runs it, captures its exit code, and translates Robocopy's exit codes into a clear success/warning/failure result (0-7 are success/informational, 8+ are errors). Write a timestamped Robocopy log, print a human-readable summary, and return an exit code the scheduler can act on. </task> <constraints> - One runnable .ps1 file; valid PowerShell 5.1+ syntax wrapping robocopy.exe. - Correctly interpret Robocopy exit codes (bit flags); do not treat exit code 1 as a failure. - Guard mirror mode with a confirmation or -Force switch since it deletes; verify source and destination first. </constraints> <format> Return the full script in one code block, then a short note on the exit-code mapping and safely using mirror mode. </format>

You are a senior Windows systems administrator and PowerShell automation engineer. <context> I need a self-contained PowerShell script that runs a command or script block against many remote machines in parallel and collects the results, runnable from an admin workstation. </context> <inputs> - Target machines: [LIST OR TXT FILE OF NAMES] - Command or script block to run: [E.G. GET A REGISTRY VALUE, CHECK A SERVICE] - Credential: [CURRENT USER / PROMPT FOR ADMIN CREDS] - Parallelism / throttle limit: [E.G. 20] - Output: [CONSOLE TABLE + CSV] </inputs> <task> Write a script that reads the target list, opens sessions with Invoke-Command -ComputerName (using a throttle limit), runs the provided script block remotely, and returns one result object per machine tagged with the computer name and a success flag. Aggregate reachable and unreachable machines, print a summary table, and export the combined results to a timestamped CSV. </task> <constraints> - One runnable .ps1 file; valid PowerShell 5.1+ syntax; assumes WinRM/PS Remoting is enabled. - Handle offline hosts and remoting errors with try/catch per machine so one failure never stops the batch. - Support a -ThrottleLimit and pass credentials with Get-Credential when prompted; never hardcode passwords. </constraints> <format> Return the full script in one code block, then a short note on enabling PS Remoting and supplying the machine list. </format>

You are a senior Windows systems administrator and PowerShell automation engineer. <context> I need a self-contained PowerShell script that silently installs or updates an application on a list of remote machines and verifies the result, runnable from an admin workstation. </context> <inputs> - Installer source: [UNC PATH TO MSI/EXE] - Silent install arguments: [E.G. /qn /norestart FOR MSI] - Target machines: [LIST OR TXT FILE] - Detection check: [REGISTRY KEY / FILE VERSION / SERVICE THAT SHOULD EXIST AFTER] - Credential and throttle: [PROMPT / THROTTLE LIMIT] </inputs> <task> Write a script that, per remote machine via Invoke-Command, copies or references the installer from the UNC source, runs the silent install with the given arguments, captures the installer exit code, and then runs the detection check to confirm success. Skip machines that already pass the detection check, and report per machine: skipped, installed, or failed (with exit code or error). Export a deployment CSV. </task> <constraints> - One runnable .ps1 file; valid PowerShell 5.1+ syntax; assumes PS Remoting is enabled. - Treat MSI exit code 3010 as success-pending-reboot, not failure; verify with the detection check, not just the exit code. - Handle offline machines and install timeouts with try/catch per host; never hardcode credentials. </constraints> <format> Return the full script in one code block, then a short note on setting silent args per installer type and reading the deployment report. </format>

You are a senior Windows systems administrator and PowerShell automation engineer. <context> I need a self-contained PowerShell script that restarts a named service across many servers and confirms it came back healthy, runnable from an admin workstation during maintenance. </context> <inputs> - Service name: [SERVICE OR DISPLAY NAME] - Target servers: [LIST OR TXT FILE] - Rollout style: [ALL AT ONCE / ONE AT A TIME (ROLLING)] - Health check after restart: [SERVICE RUNNING / A URL OR PORT RESPONDS] - Credential and throttle: [PROMPT / THROTTLE LIMIT] </inputs> <task> Write a script that, per server via Invoke-Command, stops and starts (or Restart-Service) the target service, waits for it to reach Running, then runs the post-restart health check. In rolling mode, process servers one at a time and stop the rollout if a server fails its health check. Report per server: restarted+healthy, restarted+unhealthy, or failed. Export the results to CSV. </task> <constraints> - One runnable .ps1 file; valid PowerShell 5.1+ syntax; assumes PS Remoting is enabled; support -WhatIf. - In rolling mode, abort remaining servers on the first unhealthy result and report clearly which ones were untouched. - Handle offline servers and service-not-found with try/catch per host; never hardcode credentials. </constraints> <format> Return the full script in one code block, then a short note on choosing rolling vs all-at-once and defining the health check. </format>

You are a senior Windows systems administrator and PowerShell automation engineer. <context> I need a self-contained PowerShell script that gathers specific log files or event-log exports from many remote servers into one local folder for troubleshooting, runnable from an admin workstation. </context> <inputs> - Target servers: [LIST OR TXT FILE] - What to collect: [FILE PATHS/GLOBS ON EACH SERVER / EVENT-LOG QUERY] - Time window (for event logs): [E.G. LAST 24 HOURS] - Local collection folder: [PATH] - Credential and throttle: [PROMPT / THROTTLE LIMIT] </inputs> <task> Write a script that, per server, either copies matching log files back over an admin share or UNC path, or runs a Get-WinEvent query via Invoke-Command and exports the results, saving everything under a per-server subfolder in the local collection folder (named by server and timestamp). Report per server what was collected or why it failed, and zip the whole collection at the end for easy sharing. </task> <constraints> - One runnable .ps1 file; valid PowerShell 5.1+ syntax; assumes PS Remoting and/or admin share access. - Keep each server's output in its own subfolder to avoid filename collisions; handle offline servers with try/catch. - Do not overwrite a previous collection; timestamp the root folder; never hardcode credentials. </constraints> <format> Return the full script in one code block, then a short note on choosing file-copy vs event-log mode and where the zip lands. </format>

You are a senior Windows systems administrator and PowerShell automation engineer. <context> I need a self-contained PowerShell script that reboots a set of remote servers safely, waits for them to come back, and verifies health, runnable during a maintenance window. </context> <inputs> - Target servers: [LIST OR TXT FILE] - Rollout: [ALL AT ONCE / ROLLING ONE AT A TIME] - Pre-reboot check: [E.G. NO ACTIVE USERS / A SERVICE IS DRAINED] - Post-reboot health check: [PING + WINRM + KEY SERVICE RUNNING] - Wait timeout per server: [E.G. 10 MINUTES] </inputs> <task> Write a script that, per server, runs the pre-reboot check, issues Restart-Computer (with -Wait / -For WinRM where useful), polls until the server responds to ping and WinRM within the timeout, then confirms the key service is Running. In rolling mode, do one server fully before the next and stop on the first failure. Report per server: rebooted+healthy, timed out, or failed pre-check, and export a summary CSV. </task> <constraints> - One runnable .ps1 file; valid PowerShell 5.1+ syntax; assumes PS Remoting is enabled; support -WhatIf. - Respect the wait timeout and never assume success just because the reboot command returned; verify with the health check. - In rolling mode, halt remaining servers on the first failure and list which were left untouched; handle offline hosts with try/catch. </constraints> <format> Return the full script in one code block, then a short note on setting the pre-reboot drain check and choosing rolling mode. </format>