An evergreen, copy-paste library of 50+ prompts organised by task: PowerShell generation and review, Intune and Autopilot troubleshooting, Azure and Entra ID analysis, Windows errors, log analysis, documentation, incident summaries, root-cause analysis and interview preparation. Each prompt ships with the placeholders you swap for your environment and a note on when it shines.
This is a prompt library, not an essay. Each entry follows the six-block framework from Topic 6 in compact form: a role line, a context line with {PLACEHOLDERS}, a task line and an output-format line. Categories cover the daily surface of an IT professional: PowerShell generation and review ('Write a script that…, then review it for production risks'), Intune troubleshooting ('Here is my IntuneManagementExtension.log excerpt — list the 3 most likely causes ranked'), Azure/Entra analysis ('Explain this AADSTS error and the exact log to check'), documentation ('Turn this ticket thread into a KB article'), incident work ('Summarise this outage timeline for management'), and career ('Run a mock interview for an Intune admin role'). Swap the placeholders, paste, and edit the output.
Typing a fresh prompt for every task wastes the strongest asset an AI power user has: accumulated, tested wording. A library converts your best one-off prompts into repeatable tools — the same reason you keep PowerShell snippets in a repo. Practically it removes the blank-page problem at the worst moments: a P1 incident at 3 AM is exactly when you do not want to be composing prose. Teams gain too: shared prompt libraries standardise output quality across the helpdesk, and juniors inherit senior-quality briefing from day one.
Organise the library by workflow, not by product. A PowerShell prompt is used with an editor open; a log-analysis prompt with a log file ready; an interview prompt a week before the date. Each prompt embeds four moveable parts: ROLE (whose expertise you are renting), CONTEXT ({ENV_SIZE}, {OS_BUILD}, {TOOLING}), TASK (the single deliverable) and FORMAT (table, script, 150-word summary). The library's usage loop is: run prompt → adjust one context detail → rerun → save improvements back into the file. Version it in git like any other code, because it is code — the input your AI compiler runs on.
Pick a prompt from the library
↓
Swap {PLACEHOLDERS} for your env
↓
Paste → review the draft output
↓
Edit / verify → ship
↓
Improvements saved back to libraryA week with the library. Monday: 'Generate a PowerShell script that exports all Intune compliance policies to CSV via Graph' — 10 minutes saved. Tuesday: paste a 200-line IntuneManagementExtension.log excerpt with 'rank the 3 most likely causes of this Win32 app failure and say what to check for each' — app was blocked by a wrong detection rule, found in minutes. Wednesday: 'Turn this 14-message ticket thread into a 200-word KB article with numbered steps' — documentation done during the handover. Thursday: mock interview prompt for a colleague moving to a cloud role. Friday: 'Summarise this week's incidents for management in 5 bullets with business impact' — the report nobody wanted to write, done in one paste.
Paste: 'Role: senior Windows engineer. Task: write a PowerShell script that lists all devices missing the latest Windows quality update from Microsoft Graph. Context: {SDK_VERSION}, {TENANT_SIZE}. Constraints: Get-MgDeviceManagementManagedDevice, pagination, try/catch, no third-party modules. Output: commented script + 3 usage notes.' Run it, review it, fix the gaps — that review is part of the workflow.
Save this one permanently: 'You are an Intune specialist. Here is an excerpt of {LOG_NAME}: {LOG_EXCERPT}. Task: explain what happened, rank the 3 most likely root causes, and give the exact next check for each. Constraints: cite only what is visible in the excerpt; say 'not determinable from this excerpt' where true. Output: short verdict, ranked causes, next checks.'
Paste a messy ticket thread with: 'Turn this into a KB article: Title, Symptom, Cause, Resolution (numbered steps), Prevention. Audience: helpdesk L1. Length: max 200 words. Keep real error codes; redact hostnames as {HOST}.' Documentation backlog shrinks to minutes when the format is pinned in advance.
'Summarise this incident timeline for a management audience: {TIMELINE}. Output: 5 bullets — impact, duration, root cause, actions taken, prevention — no jargon, no blame.' Same incident, second audience: '…for the technical post-mortem: include exact error codes, timestamps and the evidence chain.'
Put prompts.md in a git repo with one section per category and a changelog. After every win, fold what you learned back into the prompt. Share the repo with your team; standardise the top 10 prompts so the whole helpdesk produces consistent output. Update it quarterly — prompts age as models improve.
A shared prompt library is also a data-leakage policy document. Standardise redaction placeholders ({HOST}, {USER}, {TENANT}, {IP}) and make them mandatory in team prompts. Decide per category what may be pasted: generic log patterns yes, tenant-identifying data only into enterprise tools with data boundaries, secrets never. Store the library in a controlled repo, not a public gist — prompts often reveal internal architecture ('we proxy through 10.0.x.x', 'our CA policy names'). And annotate which prompts assume enterprise vs consumer tools, so nobody runs the wrong one in the wrong place.
I keep a versioned prompt library organised by workflow — PowerShell generation and review, log triage, documentation conversion and management summaries. For a failing Win32 app I paste a redacted IME log excerpt and ask for ranked causes with next checks; for scripts I require error handling and then run a hostile self-review pass. Everything AI touches goes through my validation before it reaches a device. It typically saves me several hours a week, most visibly on documentation and incident reporting.
Hostnames and device names become {HOST}, user identities become {USER}, IPs become {IP}, and I strip tenant IDs, secrets, tokens and anything personal. I also prefer enterprise tools with contractual data boundaries for anything tenant-specific. The trade-off is real — redaction can remove useful signal — so I redact identifiers but keep error codes, timestamps and structure, which is usually where the diagnostic value lives.
Three artefacts: a shared, versioned prompt library with placeholders and per-category data rules; a short usage policy saying which tools are approved and what may never be pasted; and two or three golden examples per task type showing what a good AI-assisted output looks like before it ships. Then quality is reviewed like any other process — sample outputs monthly, prune dead prompts quarterly, and keep the library in git so improvements are visible.
Build the v1 of YOUR library: create prompts.md with five sections — PowerShell, Intune/Autopilot, Azure/Entra, Documentation, Incidents — and put two prompts in each from this topic, placeholders included. Run each prompt once on a real task this week, note one improvement per prompt, and commit the file to git. That single file will outlive this course.
Yes — they are tool-agnostic because they rely on structure, not product quirks. The only adjustments are practical: Copilot lets you ground on Graph data instead of pasting context, Claude handles longer log excerpts thanks to its 200k window, and ChatGPT is convenient for quick iteration. Keep the prompt identical and compare outputs across two tools when the stakes are high.
For technical output, yes by default: models are strongest in English for code, error codes and product terminology, and your docs usually need English anyway. You can ask for the final explanation in another language as an explicit output constraint ('explain in Hindi, keep commands in English'). Mixed-language prompting is normal and works well.
Quarterly at minimum, plus event-driven updates: a new model release, a major Intune/Azure portal change, or a repeatable failure of a prompt are all triggers. The changelog matters more than the schedule — every time a prompt fails in a way you later fixed by hand, fold the fix into the prompt and commit it. Libraries that record their own lessons stay alive.