Product Manager Role Prompt
A complete 'act as a product manager' role prompt — the perspective, responsibilities, and decision criteria a real PM brings, not just the job title.
Reusable AI workflows, prompt templates, instruction systems, and implementation patterns for engineering, support, research, and operations.
A complete 'act as a product manager' role prompt — the perspective, responsibilities, and decision criteria a real PM brings, not just the job title.
Turn AI into a structured pull request reviewer that catches risky changes, flags maintainability issues, and suggests missing test coverage.
Configure AI to answer support questions within your actual policy boundaries — not generic best-guess answers.
A reusable long-form content template with variables for topic, audience, tone, target keyword, content angle, outline, and call to action.
End a working session like a shift change, not an abandonment: state captured, decisions logged, next step named — ready for the next session to pick up.
Extract and compare findings from multiple sources without collapsing them into a single blended perspective.
Format, length, and exclusions are the three levers that make AI output land in usable shape. A rewrite shows how to retrofit them onto a prompt that has none.
If you can't say what makes the output right, the model can't either. Success criteria turn 'make it good' into a checkable definition of done.
Grade agent output the same way every time — a rubric scoring correctness, grounding, safety, tone, and completeness, with a pass threshold instead of a gut call.
Turn a failed case into a fix — diagnose where in the agent's flow it went wrong, categorize the failure, and point at the prompt, tool, or context that caused it.
Formats fuzzy agent instructions into a structured prompt with objective, available tools, constraints, success criteria, and failure handling.
Make sure a fix didn't break three other things — compare an agent's outputs across two versions on the same scenarios and flag every behavior that changed for the worse.
Test the two failure directions — does the agent refuse what it must, and does it stay helpful on the benign requests it shouldn't over-refuse?
A reusable AI agent task template with variables for objective, context, available tools, constraints, success criteria, failure handling, and output format.
Build the test set an agent has to pass — scenarios across the happy path, edges, and adversarial inputs, each paired with the expected behavior to grade against.
Build a system prompt for an autonomous, tool-using AI agent — plan before acting, one tool at a time, act on real results, stop before irreversible steps.
The most consequential setting in any extraction prompt: what the model does when the field isn't in the text. Four behaviors, and when each is right.
Generated code duplicates instead of extracting, wraps without deciding, and defends against impossible states. This prompt hunts those exact failure modes — without preserving bugs as behavior.
Onboard AI to a codebase the way you'd onboard a new hire: what it is, how it's built, the rules that aren't written down, and the things never to assume.
End a working session like a shift change, not an abandonment: state captured, decisions logged, next step named — ready for the next session to pick up.
The fidelity ladder: Balanced, High, Strict — and the six-rule battery that keeps a summary inside its source.
When every teammate explains the project differently, AI gets a different story each time. Shared team conventions give it one consistent account.
An AI workflow prompt set turns one goal into an executable sequence — objective, prompt, and expected output per step, ready to run top to bottom.
Explain the idea before the implementation: numbered steps with their contribution, honest best/worst-case complexity, and the alternatives each decision point rejected.
Overview, Authentication, Endpoints, Error Handling, Rate Limits — endpoint docs in an identical structure, with parameter tables and runnable examples forced.
Turns a reusable API request prompt into a clean variable set covering endpoint, method, auth, payload, response format, and error handling.
Architecture review for the public surface: abstractions that earn their place, dependency direction, seams, and the patterns the codebase already has.
Status codes, response shapes, 401 vs 403, idempotency — API tests that test the contract, not the implementation.
Dependency cycles, leaky modules, misplaced responsibilities — cleaned up within the existing design. Explicitly not an invitation to invent a new architecture.
Explain a system's shape, not its statements: layers and their owners, boundary contracts, dependency direction, and one request traced through every handoff.
Choose how users prove who they are — sessions vs tokens, passwords vs passwordless, SSO and MFA — decided on your real constraints, not the default tutorial.
Login, token refresh, and everything that must fail: expired tokens, wrong permissions, malicious credentials — auth tested as behavior.
Hunt the broken-access-control bug — review code for missing per-resource checks, IDOR, and 'logged in' mistaken for 'allowed', the vulnerability class that tops the OWASP list.
"Context length exceeded" is a planning failure, not bad luck. Catch High Risk content before sending: the limit inside the estimate range is the warning.
For developers in their first year: one concept at a time, every term defined before use, real values traced through every step — and "simplified" said when simplifying.
A reusable long-form content template with variables for topic, audience, tone, target keyword, content angle, outline, and call to action.
Converts a stream-of-consciousness prompt into a structured one with Task, Context, Constraints, Requirements, and Output Format sections.
The decomposition method for AI work: clarify the outcome, split into components with dependencies, sequence by risk, execute one component per prompt.
A reusable bug investigation template with variables for symptom, environment, reproduction steps, expected and actual behavior, error logs, and affected version.
Formats scattered bug observations — logs, guesses, reproduction steps, expected vs actual — into a structured debugging prompt.
Convert scattered bug notes, Slack messages, or user complaints into structured engineering tasks with reproduction steps, severity, and root cause hypothesis.
Stop re-explaining your project in every new chat. Capture it once as a context profile the AI keeps across every conversation — stack-inferred conventions and all.
Turn a prompt into a dollar figure: input cost, output cost, combined per call, and the number that actually matters — cost per 1,000 calls.
How long will this take to read? Estimate reading time from word count at a pace you choose — the "5 min read" label, calculated.
Documents variables in candidate evaluation prompt templates — candidate name, role, interview notes, strengths, concerns, and recommendation.
Done work tells stories; open work needs carrying. The package separates completed from pending and resumes from the first open task.
Documents variables in case study prompt templates — client, industry, challenge, solution, results, metrics, and quote.
The model answered "Complaints" — your set says "Complaint". One character of drift, one broken dashboard. Caught before it counts.
Praise, Complaint, Feature Request, Bug Report, Question — multi-label feedback categorization where one message can carry three signals.
Added, Changed, Fixed, Removed, Security — changelog entries written as user-visible changes, not commit messages.
Paste any text and see characters, words, lines, and reading time at once — plus whether it fits Twitter, SMS, and meta-description limits.
A character is what you type; a token is what a model reads. This shows when to count which, from the character side.
The PRD looks done — but Non-Goals is gone and Requirements jumped above Goals. Section presence and order, checked in one pass.
Will it fit? Check any text against Twitter, SMS, meta-description, and other limits at once, and see exactly how far over you are.
Documentation mode chunks structured documents at heading boundaries, tells the model to reconstruct the section structure, and answers with original headings.
Billing, Technical, Account, How-To, Feature Request — ticket triage with definitions that decide the borderline cases for the model.
Prompts pasted into ChatGPT over time pick up restated rules and politeness. Here is how to declutter them in a few seconds.
Marketing prompts collect superlatives and restated tone instructions. Here is how to strip them back to the instructions that actually shape the copy.
A set of before-and-after examples showing exactly what prompt cleanup removes — and what it deliberately leaves alone.
Research prompts often demand thoroughness three times and then quietly also ask for brevity. Here is how to clean and de-conflict them.
Turn AI into a structured pull request reviewer that catches risky changes, flags maintainability issues, and suggests missing test coverage.
"Review this code" gets shallow comments. The review contract gets findings with severities, a checklist, and a verdict.
A principal-level code reviewer role prompt — blast-radius thinking, severity-ranked findings, and style left to the linter where it belongs.
Tell AI your code style once. List the stack and the engine returns the naming rules and conventions it implies — plus your own house rules carried verbatim.
Run a prompt twice, or on two models, and diff the answers to see exactly where they differ — mechanically, without ranking them.
Two blog prompt variations for the same topic, compared: which one actually controls angle, audience, structure, and length?
'Review my code and be detailed' against a structured review prompt — compared on structure, because review quality follows review structure.
A 'be nice and helpful' support prompt against a policy-bounded one — compared on risk, because support prompts fail on risk first.
Two versions of a document, compared line by line — which sections were added, removed, or reordered, at a glance.
Generated two variants of a headline or a line of copy? Diff them to see precisely which words changed between the drafts.
Adjective-driven vs offer-driven: two marketing copy prompts compared on output control, audience, and call-to-action discipline.
Not "which window is biggest" but "where does MY content fit": the same material and response budget checked across GPT-5, Claude, and Gemini in one report.
See exactly what changed between v1 and v2 of a prompt — added, removed, and modified instructions, plus whether the revision reduced or introduced risk.
'Research X and tell me what's best' against a scoped prompt with criteria and source rules — compared on clarity, where research prompts live or die.
Long prompts feel safer but often score worse. A worked comparison of a tight 25-word prompt against a 90-word ramble that controls less.
A side-by-side way to decide between two ChatGPT prompt drafts — scored on clarity, specificity, output control, and risk instead of gut feeling.
Drop two pieces of text side by side and get the literal difference between them — what was added, removed, and reworded.
A sequential prompt workflow for competitor analysis: scope what the analysis must decide, evaluate every competitor on the same criteria, and end with findings a pricing or positioning call can rest on.
Set up Cursor, Copilot, or Claude for a repo that already exists. One profile becomes the rules file your AI assistant reads on every request.
Converts a loose content request into a prompt with audience, goal, tone, format, and constraints — so the output matches what you actually needed.
A sequential prompt workflow for content strategy: audience first, then goals, competitor gaps, topic clusters, defensible angles, and a publishing plan with a review loop.
Every turn resends the whole history. Budget a growing chat: how much window the conversation already consumes and how many turns of life it has left.
RAG context is a budget with line items: retrieved documents, the question, and the answer all share one window. Plan how many chunks actually fit.
Creative collaborations build invisible state: the voice you settled on, the structures you rejected. Carry it forward so the next session writes like the last one.
Long threads die at the window wall. Checkpoint with a compact handoff while the conversation still works — and continue in a fresh chat without the bloat.
When the window fills, don't retype the project from memory. A handoff package carries the decisions, constraints, and pending work into the new session as its first message.
Judge the whole conversation, not one reply — evaluate a multi-turn exchange for context retention, coherence, goal completion, and recovery from misunderstanding.
What a converged conversation contains: a rejected voice, an accepted framing, a hard constraint, a format decision, and a final-version moment — each mapped to its prompt section.
In feedback threads the rejections carry the knowledge: the mocking empty-state enthusiasm, the passive phrasing — converted into the avoid-rules that define the style.
Make AI act as a copywriter that sells — clarity over cleverness, benefit-first, one clear action — instead of producing flat, generic marketing text.
When a field has a hard character cap — a meta description, a bio, a title — count against it instantly and see exactly how much room is left.
Count the lines in a list, a block of addresses, a CSV, or any line-structured text — plus paragraphs and the rest.
A quick pre-flight check: count a system prompt's tokens and cost before it ships, so the bill and the size hold no surprises.
Code is not prose: symbols, indentation, and punctuation push it to more tokens per character. This counts a real snippet so the difference is visible.
Drop in any block of text and get a clean word count with the structure around it — useful when a word range is the spec.
A reusable profile that tells AI everything constant about your project — type, stack, conventions, glossary, architecture principles, and the rules it must never guess.
A grounded workflow starts with a grounded source: package the reference once with strict rules, then run every question of the session against it.
Your domain words mean specific things. A project glossary teaches AI the difference between a basket and a cart, an SKU and a product — so it stops using them loosely.
A case-study chat that converged on the three-beat structure becomes a template: {{input}} changes per customer, everything the iteration earned stays fixed.
Set credential rules that help instead of annoy — modern password handling, MFA factors and when to require them, and account-recovery that isn't the weakest link.
Discovery, Demo, Negotiation, Follow-Up, Closed Won, Closed Lost — classify activity notes by sales stage so pipeline reports stop lying.
When the destination is a spreadsheet, CSV is the contract: one header row, one data row, quoting rules, and an honest answer about nested data.
Give Cursor a project context profile to load on every request — stack conventions, glossary, and never-assume rules — saved as your .cursorrules file.
Action items only: every commitment from the call — owner, task, deadline — straight into the CRM, with quotes for the promises that matter.
A CSM role prompt built on leading indicators — churn is decided months before the cancellation, adoption beats satisfaction, renewals are earned in the boring quarters.
Configure AI to answer support questions within your actual policy boundaries — not generic best-guess answers.
A data analyst role prompt with statistical honesty built in — clarify the decision first, treat correlation as a hypothesis, and never launder uncertainty into precision.
Ship a schema change without downtime or data loss — an expand-migrate-contract migration plan with backward compatibility, ordering, and a reversal path.
Measure before reasoning: find WHERE the time goes, separate latency from memory from throughput, and think at production scale.
Stabilize, then diagnose: impact first, rollback options before intervention, timeline from the deploy history — forensic discipline under fire.
"Fix this error" gets guesses. The investigation contract gets a ten-stage diagnosis: facts separated from assumptions, alternatives weighed, fixes justified.
AI is a strong debugging partner and a confident wrong one: the fast-investigation contract that keeps its speed and removes its overconfidence.
Before touching a shared module: what it depends on, what depends on it, and which of those dependencies are risky — direction mapped, cycles flagged.
Turn a deploy into a runbook anyone can execute — ordered steps, preconditions, verification at each gate, and the rollback hook, instead of tribal knowledge.
Turn UI requirements and component needs into a design-system spec: a component inventory with states, variants, responsive behavior, accessibility requirements, microcopy rules, and developer handoff notes.
Surface the ambiguity a model will exploit: vague quantities, hedges, undefined time, open-ended lists, and conflicting instructions — flagged, not fixed.
Did anything change, and what exactly? Detect every change between two versions — a swapped number, an added word — with nothing missed.
Turns scattered technical instructions into a coding prompt with a clear task, code context, constraints, and expected output.
Make AI act as a DevOps engineer — CI/CD, infrastructure as code, observability, and reliability — instead of a generic assistant.
A support-reply iteration becomes a standing instruction: status-and-date first, ticket number in sentence one, never overpromise — paste once per session, use all day.
Extracts and documents variables in technical documentation prompt templates — feature name, purpose, setup, usage, limitations, and troubleshooting.
Cart to confirmation as a user would do it — with the failure scenarios real users actually trigger: refreshes, back buttons, double clicks.
Null, empty, min, max, off-by-one, malformed, unicode — the systematic boundary hunt that finds bugs where they actually live.
An exception is a symptom, not a diagnosis: trace from the throw site back to the root trigger, with the runtime checklist on the table.
Structure the escalation decision for a high-risk support situation — consistent criteria, clear rationale, and a ready brief for the team taking over.
AI knows general programming but not your domain. Establish how your specific world works — its rules, its vocabulary, its non-negotiables — so it reasons inside it.
Truncated answers are usually a budgeting mistake: nothing was reserved for the response. See how the reserved output changes the whole calculation.
A classification call costs a fraction of a cent — until you run a million of them. This prices a small repeated prompt at the scale that actually bills.
How long will this take to say aloud? Estimate speaking time from word count so a talk, video script, or voiceover lands on schedule.
Token budget planning for real workloads: how much of the window a transcript actually consumes, what is left for the answer, and how much headroom remains.
Know how many tokens a job will consume before you send it — input plus an assumed response, costed per call and at scale.
Turn real interactions into a labeled eval set — sample for coverage, label each with the expected behavior, and balance the set so the score means something.
Put numbers on prompt quality: eight scored dimensions — clarity, specificity, structure, output control, completeness, risk, efficiency, readiness.
Optimize what the engine does, not what the SQL looks like: cost concentration, estimate-vs-actual gaps, and plan warnings — with forensic evidence rules.
Summary, Why It Matters, What Happens Next — the executive summary contract for readers who will never open the source.
What actually happens when a client calls POST /orders: the contract, every decision point, every side effect, and the conditions that route off the happy path.
Build a prompt that walks through a function line by line — what each line does and why — calibrated for a developer still learning the codebase.
"Explain this code" gets line-by-line narration. The understanding contract gets strategy, audience-fit, design decisions, and inference labeled as inference.
The class everyone avoids: its actual responsibilities, its key methods, its side effects, and the paths through it — understood before anyone proposes splitting it.
Build a prompt that breaks a regular expression down piece by piece in plain language — what it matches, what each part does, and what it rejects.
Parties, effective date, term, payment, termination notice, governing law — key terms into a contract register, with "unknown" marking every gap loudly.
Free text in, named fields out. The extraction prompt pattern that turns any unstructured text into consistent, parseable records.
Sender, company, request, deadline — out of emails with quoted replies and signature blocks, using guidance that knows how email is actually read.
When the chat says "this is the final version", that's the moment to bottle: the scenario opening, the differentiators, the 170-word cap — extracted at peak convergence.
Invoice number, vendor, dates, total, currency — extracted into clean fields with strict no-inference rules, ready for accounts payable.
Decisions actually made, commitments actually given — extracted from fragmentary meeting notes that never label their action items.
Pros, cons, feature requests, rating — review text into feedback-board fields, with experienced-vs-wished kept strictly apart.
Candidate name, current role, years, skills, education — résumés into consistent screening records, with inference kept on a short leash.
A converged email thread becomes a standing asset: the usage-anchored subject pattern, the value-before-discount rule, the five-sentence cap — extracted, not retyped.
Product, issue summary, stated severity, steps already tried — ticket fields extracted from free-text customer messages, without the model's own judgment leaking in.
Every entry a "## Question?" heading with a self-contained answer — FAQs grouped by topic, phrased the way users actually ask.
Decouple deploy from release — a feature-flag rollout plan with the flag's default, targeting, kill switch, and the cleanup that stops flags becoming permanent debt.
A reusable product requirements template with variables for user problem, proposed solution, target users, constraints, acceptance criteria, out-of-scope items, and success metric.
The changes you would miss on a re-read — an added word, a swapped term — surfaced exactly, so nothing slips past.
Words like "good", "engaging", and "professional" feel like instructions but specify nothing. Find them so you know where the prompt leaves things open.
Code is denser in tokens than prose: symbols, indentation, and short identifiers all cost extra. Estimate code files with code ratios before pasting them.
Run 40 looks nothing like run 1: sections reordered, one came back empty. Detect the drift, repair the run, keep the pipeline honest.
How to surface contradictions like 'keep it short' and 'be highly detailed' that quietly produce inconsistent AI output.
The JSON won't parse and you can't see why. Deterministic cause-sniffing — trailing commas, single quotes, unclosed brackets — and the repair prompt that fixes it.
'Make it good', 'be detailed', 'keep it interesting' — vague prompts get vague output. The fix is mechanical: replace every fuzzy word with a checkable instruction.
Stop getting 'Sure, here is the JSON…' — the output-contract pattern that forces models to return only parseable JSON: schema, example, and a strict rule block.
Verify a RAG answer is actually from its retrieved context — every claim traced to a retrieved passage, and any answer that outran its sources flagged.
Catch the confident invention — check an AI output's claims against its source and flag every statement that isn't supported, with the unsupported span quoted.
Day three of a multi-day code change, chat nearly full: hand off the merged work, the chosen approach, the dangerous cache risk, and the cron audit still pending.
Review a project handoff or onboarding package for what's missing — decisions, files, assumptions, constraints, risks, and next actions — and return a completeness score and a ready / not-ready verdict.
Research sessions accumulate fragile state: coded findings, methodological choices, suspect signals. Hand it off with the rigor the research deserves.
A sequential prompt workflow for hiring: outcome-based role definition, signal-mapped screening, structured interviews, evidence-based debriefs, and a 30-day onboarding.
Clarity often comes from removal, not addition. Here is how cutting redundancy makes the remaining instructions easier for a model to follow.
The first step to a more readable prompt is seeing what hurts readability now. Get the diagnosis — long sentences, stacked clauses — then fix it elsewhere.
Timeline, Root Cause, Impact, Next Steps — post-mortem summaries where the sequence stays chronological and the severity stays as written.
The six sections a reliable extraction prompt needs: source guidance, field definitions, extraction rules, missing-data behavior, ambiguity policy, example.
Real database, real services, real transactions — integration tests that verify round-trips and rollback, not mocked theater.
Sales, Support, Partnership, Press, Spam — route inbound email by intent, with a Strict "Other" so the weird ones reach a human.
Answer questions using your KB content directly — citing the source, staying within documented scope, and refusing to fill gaps with guesses.
It fails once in twenty runs: the occurrence pattern IS the evidence. Hunt the difference between failing and passing runs — forensically.
The error only happens for some inputs: find the implicit contract those inputs violate, with the runtime checklist as the suspect list.
Answer the question directly: a clarity score plus the specific reasons a prompt reads as unclear — vague terms, unstated objective, missing specifics.
Documents variables in job description prompt templates — role title, seniority, responsibilities, required skills, benefits, location, and hiring process.
Native JSON modes guarantee syntax, not your schema. The prompt contract that covers field names, types, and null discipline — whether or not the API has JSON mode.
Automation platforms fail silently on malformed model output. The strict contract that keeps AI steps feeding clean JSON into the rest of the flow.
You have the schema — fields, types, requirements. The translation into a prompt the model actually follows: schema lines, realistic example, and validation rules.
Review JWT usage for the known traps — alg confusion, missing signature/expiry checks, secrets in the token, and the revocation problem stateless tokens create.
Turn features, pains, and outcomes into benefit-led landing-page sections: a benefit headline, three to five benefit blocks, outcome bullets, objection handling, and the proof each claim still needs.
Two landing-page hero/CTA variants loaded for side-by-side scoring — generic vs intent-matched — judged on clarity, specificity, visitor-intent match, and friction, with a recommended variant.
Turn product positioning into above-the-fold hero copy: a headline, subheadline, primary and secondary CTA, a trust cue, an objection-handling line, and three alternative headline angles to test.
Write trust, social proof, risk reversal, and objection-handling copy for a landing page — with proof placeholders and an explicit do-not-invent rule, so nothing is fabricated.
Cleans up variables in landing page prompt templates — headline, audience, pain point, offer, social proof, CTA, and objections.
Make sure the right people know — a launch comms plan covering who to tell, when, through which channel, and what to say if it goes wrong.
Qualified, Nurture, Unqualified — a three-label pipeline gate with numeric confidence and a Strict Other for the leads that fit nothing.
For code whose authors are gone: reconstruct likely intent as labeled inference, hunt undocumented assumptions, and end with a maintenance brief — what's safe to touch.
Legacy code has callers you cannot see and assumptions nobody wrote down. This refactoring prompt treats every public surface as load-bearing and changes in small, verified steps.
Mentoring-style maintainability review: what makes the next change expensive, explained with corrected examples — teach, don't just judge.
Parties, obligations, dates, penalties — contract summaries for business readers, with defined terms and legal language kept exact.
Compare two blocks line by line — config, lists, or records — to see exactly which lines were added, removed, or changed.
A reusable social post template with variables for topic, audience, point of view, tone, hook style, key insight, and desired action.
Reorganise a prompt that grew too long — clear sections carry the weight, so the duplicate clauses it picked up along the way can go.
Generic prompts produce generic output. Specificity is added in slots — audience, context, named requirements — and a rewrite shows exactly which slots yours is missing.
The contract that stops AI documents from restructuring themselves: a pinned section skeleton, forced tables, and strict consistency rules.
Purpose, Highlights, Details, Recommendations, Next Steps — recurring business reports with conclusions first and numbers in context.
A sequential prompt workflow for market research: scope the question, set evidence rules, map the landscape, hunt counter-evidence, and end with a stress-tested verdict.
A worked marketing prompt revision — from adjective soup to offer-driven — with the diff showing exactly which changes carry the improvement.
A marketing strategist role prompt that thinks positioning-first — channel saturation curves, attribution honesty, and one testable angle per recommendation.
Turns raw meeting notes into a structured prompt with task, context, and output expectations clearly separated — ready to use with an AI assistant.
Extract decisions, action items, and open questions from raw meeting notes — the three things that need to survive the meeting.
Attendees, Decisions, Discussion, Action Items, Next Meeting — the notes document every meeting fills the same way.
A reusable meeting notes template with variables for raw notes, attendees, meeting goal, decisions, action items, risks, open questions, and next meeting date.
The "message too long" error has a structural fix: split at paragraph boundaries into sequenced chunks with wait rules, instead of pasting fragments and hoping.
Turns a vague or mixed-up task description into a clean prompt with a defined task, context, constraints, and output format.
Map every predicate, join, and sort to the index that serves it — or doesn't. Composite order rules, covering decisions, and the write tax nobody mentions.
Safe, Spam, Harassment, Hate, Adult — multi-label policy classification with Strict Other and numeric confidence, built for review queues.
Pattern matching, records, nullable annotations, async done right — a C# modernization scope with the rule that matters: modern equivalents are rarely exact equivalents.
var to const, callback pyramids to async/await, || guards to ?? — with the trap called out by name: || treats 0 and empty string as missing, ?? does not.
Decide what to watch before you ship — the signals, thresholds, and alerts for a release, so a silent failure pages you instead of surfacing in a support ticket.
Big tasks fail in single prompts. Multi-step prompting breaks a goal into focused, sequential prompts — each output validated, then fed into the next.
Keep tenants out of each other's data — design the isolation model, the tenant-scoping rule every query must obey, and the cross-tenant leaks to test for.
EXPLAIN shows type=ALL on a 1.2M-row table: full scan on every search. MySQL optimization with InnoDB clustering realities, version-aware optimizer limits, and covering reads.
Flat schemas are easy; reliability gets hard at the first nested array. How to contract arrays and objects so the structure survives the model.
Integrate OAuth/SSO without the footguns — the right flow for your client, state and PKCE, token handling, account linking, and the provider-edge cases that break logins.
A capable engineer with zero context on your codebase needs different explanations than a junior: conventions, vocabulary, and where everything connects — not syntax.
A free, browser-based diff tool: paste two texts, get a colored diff and a change count. Nothing installed, nothing uploaded.
An operations manager role prompt that thinks in flows — map the actual process, find the constraint that matters, and never automate a bad process into a faster bad process.
An 11-minute report that reads two years of orders to return 24 rows: the rows-read to rows-returned ratio is the target — filters pushed down, pre-aggregation costed honestly.
A five-table join that got slow as data grew: establish cardinality first, check each join strategy against the data shape, and hunt the fan-out doing wasted work.
Raw notes are fragments, not conclusions. Package them so the AI organizes without inflating — a four-word note stays an observation, not a firm claim.
Pasting a document raw mixes material with instructions. Package it: explicit delimiters, citable [§N] section labels, and grounding rules — the source travels verbatim.
Requirements language is normative: shall binds, should suggests, may permits. Package the spec so the distinction survives the AI's reading.
Research mode packages multi-source material so findings stay attributed: exact quotes over paraphrase, §-citations per claim, and your inferences labeled as yours.
API docs packaged with the rule that matters: code, versions, and identifiers quoted exactly — and this document beats the model's general knowledge of the API.
Allocations in hot loops, N+1 queries, complexity against real input sizes — the performance review that thinks about production load.
Make access auditable — a roles-by-actions matrix that shows exactly who can do what, exposes the gaps and over-grants, and becomes the spec the code is checked against.
A handoff carries one conversation forward. Persistent context is different: facts that are true in every chat, written once and rarely touched.
A book-length document against a 200K window: the estimate exceeds the budget at both ends of the range. The plan starts from Will Not Fit, not from hope.
getByRole over CSS chains, auto-wait over sleep, web-first assertions — Playwright tests written the way Playwright wants.
Confirm a deploy is actually healthy — a short, ordered smoke-test checklist of the critical paths to verify in the first minutes after shipping.
A real plan with the story inside: estimate says 42 rows, actual is 51,840. PostgreSQL analysis grounded in the plan — stale statistics, bloat, planner costs, and the index arsenal.
A reusable PR review prompt template with variables for repository, branch, change summary, changed files, review criteria, and risk areas.
Problem, Goals, Non-Goals, numbered Requirements, Risks, Timeline — PRDs identical in structure across every author and feature.
Contract review tolerates zero invention: clauses packaged under strict grounding, obligations cited by section, and missing terms reported as missing — never assumed.
In multi-part delivery, WHERE the task lands decides the answer quality. Analysis mode places the task behind the all-delivered announcement — never before.
Transcript analysis fails when speakers blur. Transcript mode packages the conversation with attribution rules: who said it, when it was revised, and no words in anyone's mouth.
Chunks without continuity rules are read as separate documents. The continuity contract — numbering, wait rules, acknowledgements, completion — keeps N parts one document.
New sessions love to reopen settled questions. Forensic fidelity carries every decision verbatim — and overriding one requires raising an explicit question first.
Your editing preferences — short sentences, six-word headlines, em-dashes intact — declared across a chat in two languages, preserved as standing rules.
```json fences are the most common reason JSON.parse fails on model output. The rule set that prevents them — and why fences happen in the first place.
Find the path from user to admin — audit for vertical and horizontal escalation: mass-assignment of roles, unchecked elevation, and operations that trust client-supplied privilege.
Key Findings, Recommendations, Open Risks — collected feedback compressed for the roadmap discussion, with recommendations the source actually supports.
A sequential prompt workflow for product launches: problem definition through MVP scope, risk register, milestone roadmap, launch checklist, and post-launch review.
Documents variables in product launch prompt templates — product name, audience, launch date, positioning, benefits, channels, and CTA.
A complete 'act as a product manager' role prompt — the perspective, responsibilities, and decision criteria a real PM brings, not just the job title.
Turn a rough feature idea into a structured requirement: problem statement, acceptance criteria, and what's explicitly out of scope.
Weigh the evidence against the target and decide — a synthesis that renders a hit / partial / miss verdict and turns it into an iterate, pivot, or scale recommendation, with the reasoning that holds it up.
Turn a success metric into a measurement plan — the behavioral signals, funnel and cohort cuts, and feedback sources that will actually prove or disprove whether a shipped product hit its target.
Consolidate the whole validation into one shareable report — the success metric, the evidence, the hit / partial / miss verdict, and the iterate / pivot / scale decision, in a form the team and stakeholders can act on.
SHIP or DO NOT SHIP: twelve checks on failure modes, observability, rollback, and load — the review that happens before the incident.
The flagship at full power: every decision, constraint, risk, assumption, and pending item of a complex project, transferred forensically as the new session's first message.
A/B test prompts on paper first: score both variants on output control and clarity, fix the loser's gaps, then spend your runs on a fair fight.
Prompt chaining runs prompts in sequence where each output becomes the next prompt's input — the technique that turns a chat into a pipeline.
A prompt changelog answers 'why does this line exist?' months later. The diff report is the entry format — dated, itemized, and written for you.
A full clarity read-out across four axes, each score explained — so you understand not just how clear a prompt is, but what is driving the number.
Get a single 0-100 clarity score for a prompt, backed by four sub-scores and the reasons behind them — including conflicting instructions that quietly cut clarity.
A short, practical checklist for cleaning a prompt — what to remove, what to flag, and what to leave alone.
The full enhancement pass in one worked example: fix vague wording, commit the hedges, strip filler, fill the gaps — without changing what the prompt asks for.
Iterate prompts like an engineer: change one thing per revision, diff before adopting, keep the report. v1 → v2 → v3 without losing what worked.
A full quality review of a single prompt across clarity, ambiguity, specificity, and structure — what a well-built prompt looks like when it scores well.
Diagnose a prompt before you send it: explainable scores for clarity, ambiguity, specificity, and structure, with observations that name where it is vague.
A revision can read better and behave worse. How to catch prompt regressions — new ambiguity, lost constraints, dropped control — before the edit goes live.
Five checks before a prompt revision replaces the version that works: nothing removed silently, no new ambiguity, control intact, contradictions zero, growth justified.
Check whether a prompt pins down the details that matter — length, format, audience, examples, criteria — or leaves them for the model to guess.
Measure a prompt's structure — headings, lists, sentence length, density — to see whether its shape helps the model or buries the instructions.
Review the change as it will land: cross-file impact, deployment risk, migration safety — plus whether the PR does what its description says.
Make AI act as a QA engineer — test strategy, edge cases, regression prevention, and validation — instead of an assistant that writes happy-path tests.
Design a role model that scales — roles derived from real permissions, the role-permission mapping, and the inheritance and edge cases before you hardcode 'isAdmin'.
Code a new hire cannot follow is a cost on every future change. This prompt renames for intent, extracts nameable steps, and replaces cleverness with clarity — semantics untouched.
Overview, Installation, Usage, Examples, Configuration — the README skeleton with required, runnable code examples.
The strongest anti-hallucination tool is structural: only the delimited source exists, gaps answer "The source does not say.", and uncited claims are forbidden.
Deep nesting and tangled branching make code unreasonable. This prompt flattens control flow with guard clauses and collapses duplicate decisions — with every branch still routing the same way.
Empty sections, blank-line gaps, leftover headers, and stray filler all add noise. Here is how to strip the scaffolding without touching the instructions.
Measure first, then trim. This counts a padded, over-polite prompt so you can see the tokens the filler is costing — before you cut it.
"Refactor this code" invites silent behavior changes. The refactoring contract preserves business rules, outputs, and side effects — and flags uncertainty instead of deciding it.
Characterization tests for legacy code: assert what it does TODAY — bugs and all — so tomorrow's change can't lie about its impact.
A go/no-go checklist for a release — config, secrets, migrations, comms, rollback, and monitoring all confirmed ready before you ship, ending in a clear GO or NO-GO.
Getting JSON once is easy; getting the same JSON shape on run 500 is the real problem. The consistency mechanics: stable schema, null discipline, and type pinning.
Three near-identical functions, one future bug fixed in only two of them. This prompt consolidates duplication into shared logic — and knows when near-duplicates should stay separate.
A worked example of stripping duplicate and restated instructions out of a prompt that says the same thing five different ways.
Don't re-roll the whole response — send back a surgical prompt that fixes the violations and keeps everything that was right.
Support says it happens; nobody can make it happen. Turn a vague bug report — symptoms, environment, expected vs actual — into a reproduction strategy.
Objective, Background, Findings, Recommendations, Open Questions — briefs where what was found and what to do stay clearly separated.
A reusable multi-source comparison template with variables for sources, evaluation criteria, audience, decision context, priority criteria, and output format.
Objective, Methodology, Findings, Limitations — paper summaries that keep the findings tied to the caveats that constrain them.
Gives a vague or too-broad research request a defined scope, source criteria, comparison framework, and output format.
Tightening a research prompt usually means narrowing it — the diff shows whether your revision sharpened the scope or silently changed the question.
Extract and compare findings from multiple sources without collapsing them into a single blended perspective.
The social-campaign sequence that finally worked — hook, data point, contrarian take, thread — preserved as a workflow prompt that runs the whole recipe in order.
AI wrote it; review it with extra suspicion: strict correctness review of the diff, because generated code fails confidently.
Correctness review with C#'s own traps: async deadlocks, undisposed IDisposables, double-enumerated LINQ, silenced nullability.
Best-practices review with JavaScript's own traps added: equality coercion, floating promises, this-binding, shared-object mutation.
The fastest fix for mediocre AI output is rewriting the prompt: vague words become concrete instructions, hedges become commitments, and missing elements get filled.
'Write a blog post about X, make it engaging' is the most rewritten prompt on the internet. Here's its strong form — angle, reader, hook rule, and length.
Marketing prompts built from 'compelling' and 'persuasive' produce copy that sounds like everyone's. The rewrite swaps adjectives for an offer, a reader, and one CTA.
'Research X and tell me what you find' returns a topic summary, not an answer. The rewrite adds the control a research ask needs: scope, criteria, and output shape.
'Be nice and fix their issue' is a liability in a support prompt. The rewrite adds the control lines support actually needs: boundaries, length, and a next step.
Turn a deploy into a deploy you can undo — a step-by-step rollback plan with triggers, the reverse of every forward step, and the point of no return named.
Forensic-grade RCA: most likely cause plus alternatives, each with supporting AND contradicting evidence — and unknowns that stay unknown.
Enterprise, SMB, Self-Serve, Partner — route inbound interest to the right sales motion, with Best Match because every inquiry needs a lane.
For code that ships weekly: a refactoring prompt where regression avoidance outranks improvement depth, log lines stay intact, and every step is rollback-friendly.
An expert sales consultant role prompt — qualification-first, discovery-before-pitch, with exact phrasings and the situations where each technique backfires.
Turn product requirements and key entities into an ERD-ready schema spec: tables, fields, primary and foreign keys, relationships with cardinality, indexes, and constraints — with the modeling gaps named as open questions.
Twelve security checks — injection, auth, secrets, SSRF, privilege escalation — reviewed the way an attacker would read the code.
Make AI act as a security engineer — threat modeling, secure design, risk assessment, and defensive recommendations — instead of a generic assistant.
Explicit waits, stale-element handling, drivers that actually quit — Selenium regression tests that hold the legacy fort.
Project context is mixed: code, notes, and docs together. Send it as one sequenced package the model holds complete before any work begins.
Positive, Negative, Neutral, Mixed — overall-sentiment classification where the definitions resolve the "loved it BUT" reviews.
A reusable SEO brief template with variables for keyword, search intent, audience, competitor notes, required sections, word count, and internal links.
Build a structured content brief from a keyword or topic before drafting — so writers start with intent, not assumptions.
In sequential prompting the order is the intelligence: definitions before judgments, evidence before conclusions, plans before execution.
Review the session lifecycle for the classic holes — fixation, weak expiry, missing rotation, insecure cookies, and sessions that outlive a logout or password change.
How to cut the length of a bloated prompt by removing redundancy and filler — without deleting any actual instruction.
Turn website goals, audiences, content types, and conversion paths into a sitemap and information-architecture spec: navigation, a page inventory, hierarchy, URLs, user journeys, and an internal-linking plan.
Queries that were instant at launch and crawl a year later: scale-aware investigation of work that grows faster than the data, before it owns the server.
Make AI act as a software architect — system design, scalability, service boundaries, and trade-offs — instead of jumping straight to code.
Make AI act as a software engineer — design, implementation, and testing trade-offs — instead of a generic assistant that writes whatever you ask.
Documents variables in standard operating procedure prompt templates — process name, owner, steps, exceptions, validation checks, handoff rules, and review cadence.
Book-length analysis needs the WHOLE work read before any judgment. Analysis mode delivers the chapters in order and triggers the full analysis only at the end.
Code split mid-function is unreviewable. Codebase mode splits at file boundaries, keeps fenced blocks atomic, and lists the files in every chunk.
Splitting a long prompt by character count butchers it. Boundary-aware chunking splits at sections and paragraphs, keeps code blocks atomic, and counts every forced cut.
A research corpus is many sources, not one text. Split at source boundaries so each study stays distinct — and synthesis waits for the full corpus.
Hours of meetings exceed any message limit. Split transcripts at speaker-turn boundaries, deliver in order, and extract decisions only after every meeting has arrived.
"Optimize this query" gets generic indexing advice. The optimization contract demands evidence: real bottlenecks, justified indexes with their write tax, and no invented plans.
At 240M rows and growing: keyset pagination over OFFSET, partition pruning, and the PostgreSQL specifics — analysis aimed at the scale the table will reach, not the scale it passed.
Extracts and documents variables from SQL query prompt templates — table names, columns, filter conditions, joins, sort order, and result limits.
Fast for most customers, 30x slower for the largest two — the parameter sniffing signature. SQL Server tuning with actual plans, clustering-key economics, and CONVERT_IMPLICIT hunting.
Read the trace bottom-up, find the frame where the bad value entered, and name what made it bad — the trace is a map, not an answer.
Ship to a few before the many — a canary/staged rollout plan with cohorts, the metrics that gate each stage, and the auto-rollback condition.
When half the team says "route" and the other half says "trail", AI picks one at random. Standardize the terms so its output uses your words, the same way every time.
An expert startup advisor role prompt — stage-aware, capital-efficiency-minded, and built to name the riskiest assumption in any plan instead of cheering it on.
A reference document is only as useful as its addressability. Heavy § labeling turns a nine-section reference into something every answer can point into.
The blocks a reliable summary prompt needs: source guidance, a fixed section skeleton, length budgets, fidelity rules, and quote handling.
Long thread in, key points out — newest-message-first reading so a newcomer can act without the archaeology.
Build a prompt that turns a long article or report into faithful key points — compressing what is there, never adding outside knowledge or padding thin sections.
The board-grade version: strict fidelity, critical quotes preserved, decisions and commitments as the formal record.
Build a prompt that turns a video, lecture, or podcast transcript into the key takeaways — attribution and chronology preserved, weight-bearing wording quoted.
Structures scattered ticket notes into a prompt that asks an AI for a policy-aware reply or escalation recommendation.
Support prompts carry policy. A worked revision showing how to evolve one without dropping the boundary that keeps replies inside policy.
A reusable support response template with variables for customer issue, policy boundary, account context, resolution steps, tone, escalation condition, and follow-up action.
Product, Pricing, Support Experience, Onboarding, Documentation — multi-label topic classification for open-ended survey answers.
Overview, Key Concepts, How It Works, Usage, Troubleshooting — docs pages with the same shape for every feature, and code in every usage section.
A technical recruiter role prompt that evaluates hiring quality at month six — screening design, evidence-based assessment, and bias flags built in.
Compress long technical content into summaries calibrated to a specific audience and purpose — not a generic restatement.
Generate edge-case-focused test scenarios for any function, feature, or API endpoint — covering boundary values, failure modes, and regression risks.
The blocks a reliable classification prompt needs: defined labels, classification rules, edge-case rules, an ambiguity policy, and a confidence contract.
Paste two texts and see exactly what changed — a git-style colored diff with additions, deletions, and word-level edits, and a mechanical change count.
The full read-out: characters, words, lines, sentences, reading time, and density — average word and sentence length — in one report.
Build a prompt that produces a true tl;dr — the gist of a long piece in a few scannable points, brevity enforced, nothing invented.
Paste a prompt, get an honest token estimate — a range, not a fake-precise number — plus the cost across GPT, Claude, and Gemini.
How character counts become honest token estimates: content-type ratios, why code and CJK text tokenize denser, and why a range beats a fake-exact number.
A token is not a character. This shows the gap on a real prompt — characters, tokens, and the ratio between them — so the difference stops being abstract.
Word count feels intuitive, but models bill tokens. This shows tokens per word on a real article so you can convert between the two with eyes open.
Check that the agent calls tools right — the correct tool, valid arguments, the right time, and graceful handling when a tool fails or returns nothing.
A lightweight way to track how a prompt changes over time: keep the previous version, diff every revision, and read the risk deltas instead of guessing.
Transferring a project means transferring its state: what's done, what's decided, what's frozen, what's left — at a fraction of the transcript's size.
The result you finally liked lives inside the chat. Distill the iterations into one prompt: corrections become requirements, the accepted version becomes the quality bar.
A status-report iteration that converged on "lead with the decision-relevant number" becomes a prompt that produces that report every week without the Monday rewrite.
Make AI act as a tutor that actually teaches — plain language first, understanding checks, building from what you know — not a wall of dense explanation.
The discount rules live in code; the questions come from sales. This prompt explains implemented business logic to a technical manager — behavior and risk, minimal code.
Mock the dependencies, test the business logic, one behavior per test — the unit testing contract that bans plumbing tests.
Documents and exports variables from user story and acceptance criteria prompt templates — persona, goal, outcome, constraints, and definition of done.
A UX researcher role prompt that respects evidence — observation over opinion, sample-size honesty, and findings that name their own limitations.
Paste the response, get the verdict: real JSON parsing, missing-field detection, and a repair prompt for everything found.
Label in the set? Case exact? Confidence in range? The checks that keep classification output usable for routing.
Heading scan against the skeleton: missing sections, broken order, absent title — the README that shipped without its Examples.
Fields checked against the contract: missing ones flagged, invented ones caught, prose around the object detected.
Did the summary keep its contract? Section presence, preamble detection, and the "Here is the summary" tax — checked and repaired.
Required fields one at a time, invalid formats, business rules at their exact boundaries — validation tested the way users break it.
When a prompt's output suddenly shifts, the first question is what changed in the prompt. A diff answers it in seconds — additions, removals, and edits, itemized.
Seven questions that decide between two prompts — audience, format, length control, constraints, criteria, ambiguity, and contradictions.
The same text is a different number of tokens on GPT, Claude, and Gemini. This shows the spread on multilingual text — which is why an honest count is a range.
Stop guessing whether content fits the model. A budget check before sending: estimated token range, reserved response space, and a fit verdict from Safe to Will Not Fit.
When the edits are inside a sentence, line mode is too coarse. Word mode highlights the exact words inserted and deleted.
Count words in any text, with sentence and paragraph structure and reading time — for essays, articles, and anything with a word target.
Legacy integrations and enterprise systems still speak XML. The output contract for well-formed, single-root XML responses — same engine, XML rules.
When the consumer is a config file or a human-reviewed pipeline, YAML beats JSON. The same output-contract engine, rendered as a YAML mode.
Ship without a maintenance window — a deployment strategy (blue-green or rolling) that keeps the service up, handles in-flight requests, and stays compatible across versions.
No resources found. Try another keyword, category, or tool.