Resources give you one prompt. Playbooks give you the whole workflow — step-by-step guides that connect multiple NewPrompt tools and resources to solve a complete problem end to end.
23 Playbooks
A complete AI-assisted review pass — not one prompt — that ends with ranked findings, tests guarding behavior, and a refactor plan when one is warranted.
Use when A change is important enough that one review prompt isn't enough — you want context, tests, and a plan around the review.
The order that actually finds bugs instead of guessing at them — so you end with a verified fix, not a plausible one that quietly returns next week.
Use when Something is broken, the cause isn't obvious, and the quick fixes haven't held.
Work a live production incident in the right order — triage and stabilize first, then find the cause, then write the summary and postmortem — so the fire is out before the writeup begins.
Use when Something is broken in production right now and you need to triage, find the cause, and write the postmortem.
Update old, risky code you didn't write — safely — by understanding and pinning its behavior in tests before you change a single line.
Use when The code is old, poorly understood, and risky to touch — but you have to update it anyway.
Restructure code you own without breaking it — change only what's worth changing, and prove with tests and a diff that behavior held.
Use when The code works but its structure is slowing you down, and you can't afford a regression.
Build a test suite that fails for real reasons, not green decoration — coverage across unit, integration, and edge cases, then a review for the gaps.
Use when A file or module has little or no test coverage and you want tests that catch real bugs.
Get up to speed on an unfamiliar codebase in an afternoon — ground the AI in the project, have it explain the hard parts, and keep what you learn.
Use when You've just joined a project or inherited a repo and need to get productive fast.
Get AI to actually read a document that's too big for one prompt — fit it to the model, split it cleanly, package the parts, and analyze them without losing the thread.
Use when You need AI to analyze a document that's too big to paste into one prompt.
Carry a project into a new chat, model, or teammate without the context evaporating — capture the state, distill what's worth keeping, and rebuild it as durable context on the other side.
Use when You're moving work to a new chat, model, or teammate and can't afford to lose the context you've built up.
Prepare documents for a RAG system so retrieved answers stay accurate — budget the chunk size to the model, ground the sources against drift, and split them on clean boundaries for retrieval.
Use when You're feeding documents into a RAG or retrieval system and need them chunked and grounded so answers stay accurate.
Fix an unreliable prompt the methodical way instead of poking at it — find what's actually unclear, rewrite for specificity, cut the noise, then prove the new version beats the old one.
Use when A prompt isn't getting reliable results and you want to fix it systematically, not by random tweaking.
Design a system prompt that holds up in production — define the role precisely, engineer the behavior and guardrails on top of it, then check it reads clearly before you ship.
Use when You're writing a system prompt for an assistant and want it reliable and clear, not a first draft you hope works.
Instruct an AI agent that runs on its own without it wandering off — anchor it to a role, write the agent system prompt, then lay out the multi-step plan it works through.
Use when You're building an autonomous or multi-step AI agent and need it to follow a reliable plan, not improvise.
Turn a prompt that worked once into one you can reuse — pull the winning prompt out of the chat, mark the parts that change as variables, and lock it into a clean template.
Use when A prompt finally worked and you want to reuse it across cases instead of rewriting it from memory each time.
Turn messy text into structured data you can trust enough to feed another system — bound the source, extract the fields, force clean JSON, and validate before it flows downstream.
Use when You need to pull structured data out of messy text reliably enough to feed another system.
Make any AI task return JSON your code can rely on — define the schema, force the model to it, validate every response, and diff the drift when a model update breaks the shape.
Use when You need an AI call to return JSON reliably enough for code to parse it without babysitting.
Build a text classification step you can automate on — pull out the unit to classify, assign a label from a fixed set, and validate the label is one you actually allow.
Use when You're classifying or routing text at scale and need labels consistent and valid enough to drive automation.
Pull a single coherent view out of a stack of sources — package them together, summarize each faithfully, then have AI synthesize across them instead of one at a time.
Use when You have several papers or sources and need AI to synthesize them into one coherent view, not summarize each in isolation.
Turn a meeting transcript into notes people actually use — a faithful summary, the action items pulled out and assigned, and a clean shareable format.
Use when You have a meeting transcript or recording and need structured notes with action items, not a wall of text.
Generate documentation that matches the code instead of drifting from it — have AI explain what the code really does, write it up as structured docs, then validate the format holds.
Use when You need documentation for code that has little or none, and you want it to reflect what the code actually does.
Turn a pile of reviews, surveys, or support comments into themes and priorities — extract the real signal, classify it by theme and sentiment, then summarize what's worth acting on.
Use when You have a pile of reviews, survey responses, or support comments and need to turn it into themes and priorities.
Run inbound support the same way every time — triage and route the ticket, pull the details that matter, draft a reply in a consistent voice, and log the resolution for the record.
Use when You handle inbound support tickets and want AI to triage, draft replies, and log resolutions consistently.
Run hiring the same way for every role — build a reusable job-description template, lay out a consistent screening sequence, and extract structured data from resumes instead of eyeballing each one.
Use when You're screening candidates and want a consistent, repeatable hiring process instead of ad-hoc prompts per role.
No playbooks found. Try another keyword or category.