DEV Community: Nav

Open-source Gmail MCP server: multi-account support, read/write (works with Claude, Cursor, OpenClaw)

Nav — Thu, 02 Apr 2026 22:10:36 +0000

Most AI tools come with a Gmail integration that can only read from one account. No writing. No archiving. No unsubscribing. I built an open-source MCP server that changes that.

The Problem

Claude's built-in Gmail connector reads emails from one account. That's it. No archiving, no labeling, no unsubscribing. If you have multiple Gmail accounts, you need to set up separate connectors for each one.

The Solution

A single MCP server that connects to all your Gmail accounts and gives AI full read/write access:

7 tools: list, read, archive, label, unsubscribe, batch process
Works with Claude, OpenClaw, Cursor, Windsurf, Cline, and any MCP client
Deploys in 5 minutes

Quick Start

Deploy to Railway or self-host
Add Google OAuth credentials
Connect your Gmail accounts via the web setup page
Point your AI client to the /mcp endpoint

Full setup guide: github.com/navbuildz/gmail-mcp-server

Example Prompts

"Show me unread emails from the last 2 days across all accounts"
"Unsubscribe from all newsletters in the last month"
"Archive everything from category:promotions"
"Label all emails from @company.com as 'Work'"

MIT licensed. PRs welcome.

The Best AI Prompts for Debugging Code

Nav — Tue, 31 Mar 2026 08:08:25 +0000

The Problem With "Debug This"

Paste broken code into ChatGPT and type "fix this" and you'll often get a fix for the wrong problem. The AI makes an assumption, rewrites something plausible-looking, and you're back where you started.

The real discipline is making the AI reason about the code before it proposes a fix. These prompts do that.

The Core Debugging Prompt

Prompt:

I have a bug and I need help finding it. Here's the context:

Language/framework: [specify]
What I expected to happen: [describe]
What actually happened: [describe — include exact error message if there is one]
What I've already tried: [list anything you've tested]

Code:
{{clipboard}}

Before suggesting a fix, walk me through your reasoning: what could cause this behavior, and which explanations are most likely?

Why it works: Asking for reasoning before the fix surfaces assumptions you might have missed. You also often spot the bug yourself while reading the explanation.

Stack Trace Analysis

Prompt:

Analyze this stack trace. Tell me:
1. Where exactly the error originates (file, line, function)
2. What the error message actually means in plain language
3. The most likely root cause
4. What I should look at first to fix it

Stack trace:
{{clipboard}}

For cryptic errors:

This error message is confusing me. Translate it into plain English, explain what likely triggered it, and suggest 2-3 things to check.

Error:
{{clipboard}}

Rubber Duck Debugging

Prompt:

I'm going to explain my code and what I think it's doing. After I describe it, ask me clarifying questions about any assumptions I'm making. Don't suggest fixes yet — I want to talk through the logic first.

Here's my code and what I believe it does:

{{clipboard}}

Why this works: Rubber duck debugging is legitimately effective — explaining code out loud (or in writing) forces you to surface your assumptions. The AI plays a better rubber duck than most humans because it will ask pointed questions.

Logic Error Hunting

Prompt:

This code runs without errors but produces wrong output. I need help finding a logic error.

Expected output: [describe]
Actual output: [describe]
Input being used: [describe or paste]

Walk through this code step by step as if you're executing it manually. Identify any point where the actual behavior diverges from what I intended.

{{clipboard}}

For off-by-one errors specifically:

I suspect I have an off-by-one or boundary error in this code. Walk through what happens at the edges: first iteration, last iteration, empty input, and single-element input.

{{clipboard}}

Performance Debugging

Prompt:

This code is slower than expected. Analyze it for performance problems:
1. Identify any O(n²) or worse operations hidden in loops
2. Flag unnecessary repeated work or redundant computations
3. Note any obvious missing optimizations (caching, early returns, etc.)
4. Rank the issues by likely impact

{{clipboard}}

For database/query performance:

This query is running slowly. Analyze it for common performance issues: missing indexes, unnecessary joins, N+1 patterns, subquery inefficiencies, or anything that would explain the slow execution.

{{clipboard}}

Async and Race Condition Debugging

Prompt:

I'm dealing with an async bug that's hard to reproduce consistently. It may be a race condition or timing issue. Analyze this code for:
- Any operations that could complete in an unexpected order
- Missing await/async handling
- State that might be read before it's written
- Any place where two async operations could interfere

{{clipboard}}

Memory Leak Investigation

Prompt:

I suspect a memory leak in this code. Look for:
- Event listeners that aren't cleaned up
- Timers or intervals that aren't cleared
- Circular references
- Objects or closures holding references longer than needed
- Any pattern that would prevent garbage collection

{{clipboard}}

"What Does This Code Actually Do?"

Prompt:

Explain exactly what this code does, line by line. Don't explain what it's trying to do — explain what it actually does. If there's a difference between the apparent intent and the actual behavior, flag it explicitly.

{{clipboard}}

Why this matters: Sometimes you wrote code 3 months ago and the bug is your mistaken mental model of what it does. This prompt bypasses your assumptions.

Better yet, catch bugs before they ship. Our code review prompts that catch bugs before they ship cover security audits, performance analysis, and architecture feedback.

Test Case Generation for Debugging

Prompt:

Generate test cases that would expose edge-case bugs in this code. Focus on:
- Boundary values (0, 1, -1, empty, null, undefined)
- Unexpected types as input
- Very large inputs
- Concurrent or rapid-fire invocations
- Error states and recovery

For each test case, tell me what bug it's designed to catch.

{{clipboard}}

Comparing Two Versions (What Changed?)

Prompt:

Here are two versions of the same code. The second version introduced a bug that didn't exist in the first. Identify what changed and explain which change is likely causing the regression.

Version 1:
[paste v1 here]

Version 2:
{{clipboard}}

"Is This Even the Right Approach?"

Prompt:

Before I spend more time debugging this, I want to sanity-check my approach. Am I solving this the right way?

Here's what I'm trying to do: [describe the goal]
Here's my current approach:

{{clipboard}}

Is there a fundamentally better way to do this that would sidestep the complexity I'm debugging?

Why this is underused: Sometimes the bug is a symptom of the wrong architecture. This prompt forces that conversation before you've sunk 3 more hours into the wrong solution.

Interpreting Compiler/Linter Errors

Prompt:

Explain this compiler/linter error in plain English. Then tell me exactly what I need to change to fix it — not just what's wrong, but the specific change with an example.

Error: [paste error]

Relevant code:
{{clipboard}}

Getting AI to Suggest Test Scenarios

Prompt:

I fixed a bug in this code. Suggest the minimal set of manual or automated tests I should run to verify the fix didn't break anything else. Include regression tests for the specific bug I just fixed.

{{clipboard}}

Tips for Better Debugging With AI

Paste the actual error message. "It's not working" gives the model nothing. The exact error message, including the line number and exception type, gives it everything.

Include what you've already tried. This prevents the AI from suggesting the first 3 obvious things you already ruled out.

Be explicit about language and framework. "JavaScript" and "Node.js" give different contexts than "TypeScript" and "Deno." The model's debugging paths depend on knowing the runtime. Different models also have different strengths for debugging — see our guides to ChatGPT developer prompts and Claude prompts for developers for model-specific tips.

Ask for reasoning, not just fixes. The single most effective tweak: add "before suggesting a fix, explain your reasoning" to any debugging prompt. You'll catch wrong assumptions before they waste your time.

Store your go-to debugging prompts. If you debug TypeScript daily, you'll reach for the same 3-4 prompts constantly. Store them in Promptzy, bind them to a shortcut, and fire them in 2 seconds instead of re-typing from memory. If you debug directly inside your editor, our Cursor AI prompts for debugging in your editor guide covers that workflow.

The prompts above aren't magic. They work because they force structure — yours and the AI's. The AI can't reason well about "fix this bug," but it reasons quite well about "here's what I expected, here's what happened, walk me through what could cause the gap."

That structure is the whole game.

Store and manage your prompts with Promptzy

Free prompt manager for Mac. Search with Cmd+Shift+P, auto-paste into any AI app.

Download Free for macOS

The Best AI Prompts for Summarizing Anything

Nav — Tue, 31 Mar 2026 08:08:24 +0000

After a few months of building prompts for this exact task, here's what actually works. Once you find the formats that fit your workflow, save your summarization prompts for different formats so you never have to reconstruct them from scratch.

Why Generic "Summarize This" Fails

The problem isn't the AI. It's that "summarize this" gives the model no constraints. Should it be 3 bullets or 3 paragraphs? Should it preserve technical detail or strip it? Is this for a 10-year-old or a PhD? The model guesses — and often guesses wrong.

The prompts below force clarity: length, format, audience, and what to keep vs. cut.

Long Article or Blog Post

Prompt:

Summarize the following article in 3-5 bullet points. Each bullet should be a complete sentence. Focus on the core argument and key supporting points. Skip examples unless they're central to the point.

{{clipboard}}

When to use it: Quickly scanning RSS feeds, research rabbit holes, or Pocket saves you never got to.

Variation — executive summary format:

Summarize the following article in 2 paragraphs: (1) what the author is arguing, and (2) the most important evidence or implication. Write for a smart reader who has no background in this topic.

{{clipboard}}

Meeting Notes or Transcript

Prompt:

Summarize these meeting notes into:
1. Key decisions made (with owners if mentioned)
2. Action items (format: [Name]: [Task] by [Date if mentioned])
3. Open questions or unresolved topics

{{clipboard}}

Why this works: The three-section format forces the AI to distinguish between decisions, tasks, and ambiguity — instead of lumping everything into one wall of text.

For longer transcripts:

This is a meeting transcript. Ignore small talk, repeated points, and tangents. Extract:
- The 3-5 most important decisions made
- All action items with owners and deadlines
- Anything that requires follow-up from leadership

{{clipboard}}

Research Paper or Academic Article

Prompt:

Summarize this research paper for a non-specialist reader. Structure your response as:
1. What question the paper is trying to answer (1-2 sentences)
2. The method used (1-2 sentences, plain language)
3. Key findings (3-5 bullets)
4. What this means in practice (1 paragraph)
5. Any significant limitations or caveats the authors mention

{{clipboard}}

Variation — for speed-reading abstracts:

Read this abstract and tell me in 3 sentences: what was studied, what was found, and why it matters.

{{clipboard}}

For more academic use cases, see our full guide to summarization prompts for students and researchers.

Slack Thread or Team Chat

Prompt:

Summarize this Slack thread. Pull out:
- The original question or problem
- Key responses or perspectives
- Any consensus or decision reached
- Any tasks or follow-ups mentioned

Ignore emoji reactions and one-word responses.

{{clipboard}}

Tip: This works great with Slack's "Copy all" feature on threads.

Book Summary (Chapter or Full)

Prompt:

Summarize this chapter from the perspective of someone who wants to apply the ideas at work. Focus on:
- The central concept
- The most actionable insight
- One concrete thing I can do differently based on this chapter

{{clipboard}}

For a full book (using highlighted notes):

These are my highlights from a book I recently finished. Based on these, summarize:
1. The book's main thesis in 1-2 sentences
2. The 3-5 most important ideas
3. The most actionable takeaway

{{clipboard}}

Podcast or Video Transcript

Prompt:

This is a transcript from a podcast or video. Summarize it in the following format:
- Guest/speaker name (if mentioned)
- Main topic discussed
- 5 key points or insights (1-2 sentences each)
- Most quotable moment or idea

{{clipboard}}

For interviews specifically:

Summarize this interview transcript. Focus on what the guest is arguing, what makes their perspective unique, and any concrete advice or frameworks they share. Skip the host's questions in your summary.

{{clipboard}}

Legal Document or Contract Section

Prompt:

Summarize this legal document section in plain English. Explain:
- What this section is about
- What it requires of each party
- Any unusual clauses or terms that differ from standard agreements
- Any potential gotchas I should flag for a lawyer

Keep it simple enough for a non-lawyer to understand.

{{clipboard}}

⚠️ Always verify any AI summary of legal documents with an actual attorney before acting on it.

Email Thread or Long Email

Prompt:

Summarize this email thread in 3-4 sentences. Include:
- What was being discussed or decided
- The current status or conclusion
- Any action required from me

{{clipboard}}

For a single long email:

Summarize this email in 2 sentences: what is being asked of me, and by when (if mentioned).

{{clipboard}}

News Article (With Opinion Filtering)

Prompt:

Summarize the factual content of this article separately from the author's opinions or commentary.

First, list the verifiable facts stated. Then, separately, summarize the author's interpretation or framing of those facts.

{{clipboard}}

Why this prompt: News articles routinely blend fact and editorial. This forces a clear separation. If you're doing research-heavy summarization, you might also try Perplexity AI for research summaries — it can cite sources inline.

Technical Documentation or README

Prompt:

Summarize this technical documentation for a developer who is evaluating whether to use this tool or library. Include:
- What it does in one sentence
- The main use cases it's designed for
- Key technical requirements or constraints
- Any notable limitations or known issues

{{clipboard}}

YouTube Comments or Reviews

Prompt:

I'm going to paste a set of comments or reviews. Summarize:
- The main positive themes
- The main criticisms or complaints
- Any specific feature requests or suggestions
- Overall sentiment (positive/mixed/negative)

{{clipboard}}

Tips for Getting Better Summaries

Be explicit about format. Bullets vs. paragraphs, sentence count, headers or not — state it upfront. The model will match whatever you specify.

Specify the audience. "Summarize for my CEO" and "summarize for a new hire" will produce very different outputs from the same source.

Ask what to skip. "Ignore examples unless central to the argument" or "skip the intro" removes the noise that makes summaries bloated.

Use {{clipboard}} instead of pasting manually. If you're running these prompts repeatedly, storing them with the {{clipboard}} token means you copy your content, fire the prompt, and the context is already injected. No manual pasting. You can even add variables for source type, length, and audience to make a single template cover multiple summarization scenarios.

If you find yourself reaching for the same summarization prompt three times a week, it's worth binding it to a shortcut. Save these in a Promptzy vault — Cmd+Shift+P, type "summarize," and the right prompt is in your clipboard in under 2 seconds. For a full breakdown of tools that help you organize your summarization templates, we've got a separate guide.

The best summary prompt is the one you actually use consistently.

Store and manage your prompts with Promptzy

Free prompt manager for Mac. Search with Cmd+Shift+P, auto-paste into any AI app.

Download Free for macOS

What Is Promptzy? The Mac App That Replaces Your Prompt Notes App

Nav — Tue, 31 Mar 2026 02:11:34 +0000

If you use AI tools every day, you've probably hit this moment: you had a great prompt, used it once, and now you can't find it. It's buried in a chat, scattered across Notes or Notion, or just gone.

Promptzy is a Mac app built to fix that. Here's what it actually does.

The Problem It Solves

AI tools — ChatGPT, Claude, Perplexity, Copilot, Cursor — don't give you a way to store and reuse prompts. You write a good one, it works, you close the tab, it disappears. So people improvise: a Notion page, a .txt file, a Slack DM to themselves, Apple Notes.

The result is prompts scattered across 4-5 apps, none of which are easy to search or pull up quickly when you're mid-task in another window.

Promptzy is the one place your prompts live — and it's designed to be faster to use than any of those alternatives.

What Promptzy Does

Stores prompts as Markdown. Each prompt is a plain Markdown file. No proprietary format, no lock-in. You can read, edit, and export your prompts any time.

System-wide keyboard shortcut. Press Cmd+Shift+P from anywhere on your Mac — inside ChatGPT, Claude, VS Code, your email client, wherever — and a search overlay appears. Type a few characters to find your prompt, hit Enter, and it pastes directly into wherever your cursor was.

Fuzzy search. You don't need to remember the exact name of a prompt. Type "email follow" or "debug python" and Promptzy finds the right one.

Dynamic tokens. Prompts can include placeholders like {{clipboard}} (auto-fills with what's on your clipboard), {{date}} (today's date), or custom variables you fill in before pasting. So a prompt like "Summarize this article in 3 bullets: {{clipboard}}" pastes the prompt and your copied text in one action.

Collections. Group prompts into folders by use case — writing, code, research, work tasks, personal — so your library stays organized even as it grows.

No account required. Everything is stored locally on your Mac. No signup, no sync to a server, no data leaving your machine.

How It Compares to the Alternatives

vs. Apple Notes / Notion / text files: These work, but they're slow. You have to switch to the app, navigate to the right page, find the prompt, copy it, switch back, paste it. Promptzy does all of that in 2-3 keystrokes without leaving your current app.

vs. TextExpander: TextExpander is great for short text snippets. It gets expensive ($4-8/month) and is more focused on text abbreviations than long-form AI prompts. Promptzy is built specifically for prompts — supports Markdown, long multi-paragraph templates, variables, and collections.

vs. Raycast Snippets: Raycast is a powerful launcher and Snippets are a useful feature within it. But Snippets aren't optimized for AI prompts — no Markdown rendering, limited variable support, and it's opt-in to Raycast's ecosystem. Promptzy is focused on exactly this use case.

vs. just using chat history: Chat history is not searchable in any useful way. It gets long fast. AI companies can delete or archive old conversations. Don't rely on it as a prompt library.

The Free vs. Pro Breakdown

Promptzy is free to download and use. The free tier covers everything most people need: prompt storage, search, keyboard shortcut, collections, dynamic tokens.

The Pro upgrade ($5 one-time, not a subscription) adds a few power-user features. Check promptzy.app for the current feature breakdown — the free tier is genuinely generous.

The $5 price point is deliberate. It's not a subscription because your prompts shouldn't be held hostage to a recurring payment.

Who It's For

Promptzy is specifically for Mac users who use AI tools regularly at work. That includes:

Developers using Cursor, Copilot, or Claude for code
Writers and marketers who have standard prompt templates
Managers who use AI for writing reviews, emails, and docs
Researchers using Perplexity or Claude for analysis
Anyone who's had the "where's that prompt I wrote?" moment more than twice

If you use AI tools occasionally or prefer to work entirely in the browser, Promptzy might be more than you need. If you're in AI tools daily, it pays for itself quickly.

Getting Started

Download from promptzy.app. It's a standard Mac app — no configuration required. After installing:

Press Cmd+Shift+P to open the search overlay
Click "New Prompt" to save your first one
Organize into a collection
From now on, any prompt is one shortcut away

The fastest way to see if it's useful: spend 10 minutes moving your 5 most-used prompts into Promptzy. If that doesn't feel like an improvement, it's probably not for you. Most people who do that don't go back to their old system.

Why Your Prompts Are Scattered (And the 10-Minute Fix)

Nav — Tue, 31 Mar 2026 02:10:59 +0000

You've got a prompt that took you 20 minutes to get right. The output was exactly what you wanted — specific, well-formatted, tone-perfect. You close the tab. Two weeks later, you need it again. Where is it?

Maybe you checked:

Your Notion docs (the page you vaguely remember creating)
Apple Notes (where you paste things "temporarily")
A .txt file on your desktop called something like prompts-v3-final.txt
Slack, where you DM'd it to yourself
The actual ChatGPT chat history (now buried under 200 other conversations)

Sound familiar? That's prompt sprawl, and it costs more time than people realize. Every time you can't find a prompt, you either rebuild it from scratch (losing 10-30 minutes) or settle for a worse version of it.

Why This Happens

The problem isn't that you're disorganized. It's that AI tools give you no native home for prompts. ChatGPT, Claude, Perplexity, Copilot — none of them have a real prompt library. You write something that works, use it, then it disappears into chat history.

So you improvise. Notion seems logical. Notes is fast. A Google Doc for sharing. A Slack DM for "I'll deal with this later." Over time, you've created 4-6 places where prompts might live, and none of them is authoritative.

The 10-Minute Fix

You don't need a complex system. You need one place and a way to get to it fast. Here's a simple setup:

Step 1: Pick one place (5 minutes)

Stop trying to consolidate everything you've ever saved — that's a rabbit hole. Instead, declare one place as the canonical home for new prompts going forward. Everything else can stay where it is.

If you're on a Mac, the cleanest option is Promptzy — it's built specifically for this and has keyboard shortcut access. If you want to DIY it, Notion works, but you'll need the shortcuts setup below.

Step 2: Create 4-6 folders by job-to-be-done (3 minutes)

Don't organize by AI tool. Organize by what you're trying to accomplish:

Writing (emails, docs, content)
Research & analysis
Code (if you write code)
Work tasks (your specific role)
Personal use

That's it. Five folders. The discipline is resisting the urge to create 20 subcategories.

Step 3: Set up a keyboard shortcut (2 minutes)

The biggest friction point is retrieval. If getting to your prompts requires opening an app, navigating to a folder, searching a doc, and copy-pasting — you won't do it consistently.

The fix is a keyboard shortcut that opens your prompt library instantly. On Mac:

Promptzy: Cmd+Shift+P opens the search overlay, anywhere on your system
Raycast: Works if you've set up snippets there
Alfred: Can open specific Notion pages or text files with a hotkey

This step is what separates people who actually use their prompt library from people who have one they never check.

What to Put In It

Don't try to catalog every prompt ever. Start with these:

Your 10 most-used prompts — the ones you find yourself rebuilding or searching for regularly. These are your quick wins. Move them first.

Your best templates — prompts that have a fill-in-the-blank structure and work across different contexts. For example, "Rewrite this [content type] for [audience] in a [tone] tone" is more valuable than a one-time-use prompt.

Role-specific prompts — if you regularly use AI for a specific type of work (writing emails, debugging code, analyzing data), those belong in a dedicated folder.

What Not to Do

Don't try to import everything. You'll spend 3 hours organizing old prompts and give up. Start with what you're using now.

Don't create a tagging system before you have prompts to tag. Over-engineering the organization before you have content is how Notion pages die.

Don't make your prompts too specific. "Write a follow-up email to Jason about the Q3 proposal" isn't a reusable prompt — it's just a task. Good prompts are templates. "Write a follow-up email after a sales call where [outcome]. Highlight [key point]. CTA: [action]" — that's a prompt.

Don't store prompts in your AI tool's chat history. It's not a library. Chat history is search-hostile and will be deleted or archived. Don't rely on it.

The Real Payoff

After a week of this system, you'll notice two things:

First, you'll start using better prompts more consistently. When good prompts are easy to reach, you use them. When they're buried, you improvise — and improvised prompts get improvised results.

Second, you'll stop rebuilding. Every prompt you save is time you don't spend recreating it next month. The library compounds.

This isn't a complex system. It's a single folder, a shortcut, and the discipline to save things you'll want again. Takes 10 minutes to set up, saves hours over a year.

If you're on Mac and want the fastest version of this, Promptzy is built exactly for this use case — Markdown storage, fuzzy search, system-wide keyboard shortcut, no subscription.

The Best AI Prompts for Teachers and Educators

Nav — Tue, 31 Mar 2026 02:09:59 +0000

Teaching is one of the most prompt-heavy jobs there is. You're constantly generating the same kinds of content — lesson plans, rubrics, quiz questions, parent emails, feedback comments — just with different content each time. That's exactly what AI is built for.

These prompts are written for teachers who actually want to use AI, not just talk about using it. Copy them directly, adjust for your subject and grade level, and start saving real time.

Lesson Plan Prompts

Full lesson plan from a standard:

Create a 50-minute lesson plan for [grade level] students on [topic]. Learning objective: [paste your standard or objective]. Include: a warm-up activity (5 min), direct instruction (15 min), guided practice (15 min), independent or group activity (10 min), and an exit ticket (5 min). Use [any specific pedagogy, e.g., project-based learning / Socratic questioning / UDL principles] where appropriate.

Hook activity generator:

I'm teaching [topic] to [grade level] students. Give me 5 different hook activities to start the lesson — something that will grab attention in the first 2 minutes and make students curious about what's coming. Vary the types: one visual, one question-based, one surprising fact, one short story, one hands-on.

Differentiated instruction — same lesson, three levels:

Take this lesson objective: [paste objective]. Create three versions of the main activity for the same class: one for students who are still developing the foundational skills, one for students at grade level, and one for students who are ready for extension. Each version should be achievable independently and take about the same amount of time.

Substitute teacher plan:

Write a self-contained substitute teacher plan for a [grade level] [subject] class. Topic: [topic]. The sub has no subject expertise. Include: a brief overview for the sub, step-by-step instructions, a student handout, and a suggested schedule for [X] minutes. Everything the sub needs should be on the page.

Rubric and Assessment Prompts

Project rubric:

Create a 4-point rubric for a [type of project] on [topic] for [grade level]. Categories to evaluate: [list 3-5 things you want to assess, e.g., content accuracy, creativity, presentation, use of evidence]. Use clear, student-friendly language for each level. Format as a table.

Quiz question generator:

Write 10 quiz questions on [topic] for [grade level] students. Include: 4 multiple choice, 3 short answer, 2 true/false with a justification prompt, and 1 extended response. Vary the cognitive demand — some recall, some application, at least one analysis question. Include an answer key.

Exit ticket generator:

Write 3 different exit ticket options for a lesson on [topic] for [grade level]. Each should take no more than 3 minutes and reveal whether students understood [specific concept you're checking]. One should be a written response, one a visual/diagram, one a quick self-assessment scale with a follow-up question.

Feedback and Grading Prompts

Written feedback on student work:

I'm a [grade level] [subject] teacher. Here is a student's [essay/lab report/project write-up]: [paste work]. Write specific, actionable feedback in a warm-and-demanding tone. Mention 2 things that are working well (be specific, not generic). Identify the single most important thing they should improve. End with one concrete revision suggestion.

Bulk feedback template for a common error:

Many of my students made the same mistake on this assignment: [describe the error]. Write a feedback comment I can paste to all affected students that: explains what went wrong (without being condescending), shows them the correct approach with a brief example, and encourages them to revise. Keep it under 80 words.

Self-assessment prompt for students:

Write a student self-assessment reflection students should complete before submitting their [project/essay]. Include 4 questions: one asking them to identify their strongest section and why, one asking them to identify what they'd improve with more time, one asking them to rate their effort with evidence, and one open question about what they learned about themselves as a learner during this project.

Parent Communication Prompts

Parent email — concern about a student:

Write a professional, empathetic email to a parent about their child [first name only, no last name]. The concern is: [describe the situation — academic, behavioral, social, etc.]. Tone: warm but honest, not alarming. Include: a specific positive observation about the student, a clear description of the issue, one concrete action I'm taking, and an invitation to discuss. Keep it under 200 words.

Newsletter update / class recap:

Write a brief class newsletter section (150 words) for [subject] class. This week we covered [topics]. Students are currently working on [project/assignment]. One interesting discussion we had was about [topic]. Upcoming: [dates/events]. Tone: friendly, informative, accessible to parents who aren't familiar with the subject.

Response to a frustrated parent email:

Here is a parent email I received: [paste email]. Help me draft a professional, calm response that: acknowledges their concern without being defensive, provides factual context, explains the next step I'm taking, and keeps the door open for dialogue. I want to maintain the relationship even if we disagree.

Differentiation and Accommodation Prompts

Simplified reading passage:

Take this text: [paste passage]. Rewrite it at a [X] grade reading level while preserving all the key information. Keep the same paragraph structure. Do not oversimplify the concepts — just make the language more accessible. Add a short vocabulary box at the bottom defining the 5 most important terms.

English language learner accommodation:

I have ELL students in my [grade level] class. Take this assignment prompt: [paste prompt]. Rewrite it in clearer, simpler English while keeping the same expectations. Add a bilingual vocabulary guide with the 8 most important content words and their definitions in both English and [target language]. Also suggest one visual support I could add.

Extension activity for fast finishers:

My [grade level] students who finish early need a meaningful challenge, not busywork. The current assignment is about [topic]. Design an extension activity that goes deeper — something that requires them to apply, analyze, or create, not just recall more facts. Should take 10-15 minutes and require no additional materials.

IEP and Support Planning Prompts

Accommodation ideas for a specific challenge:

A student in my class struggles with [specific challenge — e.g., processing written instructions, staying on task during independent work, anxiety during assessments]. Suggest 5 practical, low-prep classroom accommodations I can implement immediately. Be specific — not "provide extra time" but how exactly to structure that in my class context.

Writing IEP goal language:

Help me write a measurable IEP goal for a student who currently [describe current performance level] in [skill area]. The goal should include: a clear behavior, a measurable criterion, a timeframe, and conditions under which the behavior will occur. Write 3 versions at different levels of ambition.

Save These Prompts for Later

These prompts work best when they're easy to reach. If you're pulling them from a doc or searching through old chats each time, you're losing the time you were supposed to save.

Promptzy lets you store prompts like these as keyboard shortcuts on your Mac — hit Cmd+Shift+P and search "rubric" or "parent email" and the prompt auto-pastes wherever your cursor is. Worth setting up once.

The Best AI Prompts for Writing Performance Reviews

Nav — Tue, 31 Mar 2026 02:09:58 +0000

Performance review season is brutal. You're juggling dozens of reviews, trying to write specific, fair, constructive feedback for each person — while still doing your actual job. And then you have to write your own self-review on top of it.

AI doesn't replace your judgment, but it does eliminate the blank-page problem and helps you write more consistently across your reports. These prompts are built for that.

Manager Writing About Direct Reports

Full performance review draft:

I'm a [your role] writing a performance review for [report's role]. This person has been on my team for [X months/years]. Here are my notes on their performance: [paste your bullet points or notes — the messier the better].

Write a professional performance review with the following sections: Overall Performance Summary (2-3 sentences), Key Accomplishments (3-5 bullets with specific impact where I've noted it), Areas for Development (2-3 constructive observations), and a Forward-Looking Statement about their trajectory and potential.

Tone: honest, specific, professional. Don't use vague filler phrases like "hard-working" or "great team player" unless I've given you specific evidence for them.

Writing about a strong performer:

I want to write a glowing performance review for someone who genuinely exceeded expectations this year. Their key contributions: [list 3-5 specific things they did]. They also showed growth in: [list areas]. Write a 250-word review that makes clear this person is high-potential. I want their manager above me to read this and notice them.

Writing about an underperformer — honest but fair:

I need to write a performance review for someone who did not meet expectations this year. The gaps were: [describe gaps specifically]. To be fair, they did [acknowledge positives]. I've had [X] conversations with them about this — [describe roughly what was discussed].

Write a review that: accurately describes the performance gap without being harsh, is specific enough to be legally defensible, acknowledges effort or improvement where real, and sets clear expectations for what "meeting expectations" looks like going forward. Do not soften it to the point of dishonesty.

Mid-cycle check-in summary:

I just had a mid-year check-in with a direct report. Here's what we discussed: [paste your notes]. Write a short summary I can send to them as a written record of our conversation. Include: what's going well, what they're working on improving, and the one goal we aligned on for the next 90 days. Conversational tone, not corporate.

Self-Review Prompts

Full self-review draft:

I'm writing my self-review for [review period]. My role is [title]. Here are the things I worked on this year: [paste accomplishments, projects, challenges — messy notes are fine].

Write a self-review with these sections: Key Accomplishments (3-5 with quantified impact where I've given numbers), Challenges and What I Learned (honest, not defensive), Growth Areas I've Worked On, and What I Want to Focus On Next Year.

Tone: confident but not arrogant. I want to advocate clearly for myself while being accurate.

Quantifying impact when you don't have hard numbers:

I worked on [project/initiative] this year. I don't have exact metrics, but here's what I know about the impact: [describe what changed, what got better, what problems got solved]. Help me write 2-3 achievement bullets that honestly represent the impact without fabricating numbers. Use ranges, qualitative outcomes, and comparative language where appropriate.

Self-review when the year was rough:

This was a hard year for me professionally. [Briefly describe: layoffs, reorgs, personal challenges, difficult projects, etc.]. Despite that, I still contributed in these ways: [list]. Write a self-review that's honest about the context, doesn't make excuses, and still clearly demonstrates my value to the team. I need to strike the balance between explaining the circumstances and owning my performance.

Peer Review Prompts

Peer feedback — positive:

I'm writing peer feedback for [colleague's role]. They collaborated with me on [project or situation]. Specifically, they: [list 2-4 specific things they did]. Write thoughtful peer feedback (150-200 words) that's specific and genuine. I want my words to actually help them understand their strengths, not just be a feel-good paragraph.

Peer feedback — when someone was difficult to work with:

I need to give honest peer feedback to someone who was frustrating to collaborate with. The issues were: [describe specifically — communication problems, missed deadlines, taking credit, etc.]. Write feedback that is: specific and behavioral (not personality-based), professional, and constructive. Frame it as observations and impact, not character judgment. I want to be honest without torching the relationship.

360 feedback summary for your manager:

I've received peer feedback from [X] colleagues. Here are their responses: [paste raw feedback]. Synthesize this into a summary that: identifies the common themes (positive and developmental), highlights the most specific and actionable observations, and flags anything surprising or contradictory. Format as a brief report I can share with the employee.

Development Goals and PIP Language

Writing development goals (not fluffy ones):

I need to write a development goal for [employee] in the area of [skill gap]. The gap shows up specifically as: [describe observable behavior]. Write a SMART development goal with: a clear behavior target, measurable success criteria, a timeframe, and 2-3 specific actions or resources. Make it something we can actually track, not "improve communication skills."

Performance Improvement Plan (PIP) language:

I need to draft a Performance Improvement Plan for someone in the role of [role]. The documented concerns are: [list specific performance gaps]. What we've discussed previously: [summarize prior conversations and any warnings]. The goal of the PIP is to help them succeed, not to document termination.

Write PIP language for the Goals section that: states the expected standard clearly, identifies measurable benchmarks for weeks 30/60/90, and describes how we'll support them. Avoid punitive language — be direct and clear, not threatening.

Follow-up after a difficult performance conversation:

I just had a tough conversation with a direct report about their performance. The main points I covered: [list]. They reacted [describe reaction — defensive, upset, receptive, etc.]. Write a brief follow-up email I can send within 24 hours that: summarizes what we discussed without repeating everything verbatim, confirms the agreed next steps, and keeps the tone supportive and forward-looking.

Review Cycle Admin Prompts

Calibration prep — stack ranking notes:

I need to prepare for calibration where I'll advocate for my team. I have [X] direct reports. Here's my quick assessment of each: [list name, performance tier you'd place them in, and 1-2 sentences of evidence].

For each person, draft 2-3 sentences I can use to advocate for their calibration rating in a group discussion. I need to be concise and specific — calibration moves fast and I need strong talking points, not lengthy explanations.

Review cycle reminder to your team:

Write a short, human-sounding Slack message to my team reminding them that self-reviews are due [date]. Include: what platform they're in, what sections they need to complete, and one piece of practical advice for making self-reviews easier. Keep it under 100 words. Not corporate. Sound like a manager who actually wants to help, not an HR announcement.

Stop Rewriting These Every Cycle

The prompts above will save you hours this review cycle. But next cycle, you'll be starting from scratch again — unless you save them.

If you're on a Mac, Promptzy stores these as prompt templates you can recall instantly with a keyboard shortcut. Store them in a collection called "Review Season" and they're always one Cmd+Shift+P away.

The Best AI Prompts for Writing Emails (Professional + Casual)

Nav — Mon, 30 Mar 2026 15:30:47 +0000

The Best AI Prompts for Writing Emails (Professional + Casual)

Email writing is universally necessary but often dreaded. AI assistance helps significantly when prompts are specific rather than generic. Here are 30 focused email prompts organized by type, each designed to produce authentic-sounding messages. Context variables in brackets allow customization for your specific situation.

Cold Outreach

1. Cold outreach — B2B

Write a cold outreach email to [name/role] at [company]. I'm reaching out because 
[specific reason relevant to them]. My ask is [clear single ask]. Keep it under 100 
words, no fluff, make the opening line relevant to them specifically.

Context: {{clipboard}}

2. Cold outreach — job/opportunity

Write a cold email to [person] about [opportunity or reason for reaching out]. 
I want to make a genuine connection, not ask for a favour immediately. Keep it brief, 
show I've done my research, and end with a low-friction ask (like a 15-minute call, 
not a job offer).

Background I know about them: {{clipboard}}

3. Cold outreach — partnership

Write a partnership outreach email to [person/company]. The potential collaboration 
is [describe it]. Make the email brief, explain what's in it for them before what's 
in it for me, and end with a specific ask.

4. Podcast or media pitch

Write a pitch email to [podcast host / journalist / newsletter writer]. I want to 
[be featured / contribute / be interviewed] because [specific reason why it fits their 
audience]. Keep it short — they get a lot of these. Lead with what's valuable to their 
readers/listeners, not what I want.

Follow-Ups

5. Follow-up on no response

Write a follow-up email for a message I sent [X days] ago that got no response. 
Context: {{clipboard}}

Keep it short, non-pushy, make it easy to reply with a yes/no, and give them an 
easy out if they're not interested.

6. Follow-up after a meeting

Write a follow-up email after a meeting with [person/company]. Cover: a brief thank 
you, summary of what was agreed, next steps with owners and timelines, and any open 
questions. Keep it scannable.

Meeting notes: {{clipboard}}

7. Follow-up on a proposal

Write a follow-up email on a proposal I sent [timeframe] ago. I don't want to be 
pushy, but I need to know if they're still interested. Keep it brief, restate the 
key value in one sentence, and ask a direct question that's easy to answer.

Proposal context: {{clipboard}}

8. Follow-up after a job interview

Write a follow-up email after a job interview. Express genuine interest (not 
desperation), reference something specific from the interview, and keep it under 
100 words. Don't ask "have you made a decision yet."

Interview notes: {{clipboard}}

9. Nudge on an overdue deliverable

Write an email to nudge [person] on [deliverable] that's overdue. I don't want to 
be accusatory — I want to understand if there's a blocker and offer help if needed. 
Keep it short and non-passive-aggressive.

Context: {{clipboard}}

Professional / Internal

10. Project status update

Write a project status update email for [audience: team / stakeholders / client]. 
Cover: what's been completed, what's in progress, any blockers, and what's coming 
next. Use a clear structure, keep it scannable, and flag anything that needs a 
decision.

Current status: {{clipboard}}

11. Request for a meeting

Write an email requesting a meeting with [person]. Reason: [why I need to meet with 
them]. Be direct about the ask, explain why it's worth their time, and include 
specific proposed times or a scheduling link option.

12. Escalation email

Write an escalation email about [issue]. I need to escalate because [reason]. Keep 
it professional, factual, and solution-focused — not emotional. Clearly state what 
I've already tried and what I need from the recipient.

Background: {{clipboard}}

13. Decline a request or invitation

Write a professional decline email for [request/invitation]. I want to be honest 
without over-explaining, leave the relationship intact, and close the door gently 
without leaving it completely shut if [relevant].

14. Announce a decision or change

Write an announcement email for [decision or change]. The audience is [describe them]. 
Explain what's changing, why, when it takes effect, and what it means for them. 
Anticipate the obvious questions and answer them in the email.

15. Ask for a reference or recommendation

Write an email asking [person] to be a reference / write a recommendation for me. 
Context: [what role or opportunity]. Make it easy for them — offer to send a brief 
on what to emphasise, give them an easy out, and express genuine appreciation for 
their time.

Hard Conversations

16. Deliver critical feedback

Write an email delivering critical feedback to [person] about [issue]. Be direct 
and specific — avoid vague language. Focus on behaviour or outcomes, not personality. 
Explain the impact and what change looks like going forward.

Situation: {{clipboard}}

17. Address a conflict or misunderstanding

Write an email to address a conflict or misunderstanding with [person] about 
[situation]. I want to clarify my perspective without being defensive, acknowledge 
their viewpoint, and propose a path forward. Keep it professional and forward-looking.

Context: {{clipboard}}

18. Deliver bad news

Write an email delivering bad news to [person/group] about [what happened]. Be 
direct — don't bury the lead. Acknowledge the impact, explain what happened briefly, 
and focus most of the email on what comes next.

Situation: {{clipboard}}

19. Push back on a decision

Write a professional email pushing back on [decision] made by [person/team]. I 
disagree because [reasons]. Frame it as raising concerns, not attacking the decision. 
Be specific, offer an alternative if I have one, and be clear I'll support whatever 
final call is made.

20. End a professional relationship

Write a professional email ending a working relationship with [person/company]. Be 
honest but tactful, don't over-explain, thank them for the work together if 
appropriate, and close things clearly.

Client Communication

21. Project kick-off email

Write a project kick-off email to a new client. Cover: welcome/excitement (briefly), 
project overview, what I need from them to get started, timeline overview, and how 
we'll communicate. Keep it professional but warm.

Project details: {{clipboard}}

22. Scope change or additional cost

Write an email informing a client of a scope change or additional cost. Be 
transparent about what changed and why, explain the cost/time impact clearly, and 
frame it as a shared decision rather than a surprise.

Situation: {{clipboard}}

23. Handle a client complaint

Write a response to a client complaint about [issue]. Acknowledge the problem without 
being defensive, take responsibility where appropriate, explain what went wrong 
briefly, and focus on the resolution.

Complaint: {{clipboard}}

24. Request feedback from a client

Write an email requesting feedback from a client after [project/engagement]. Keep it 
low-friction — a few specific questions are better than a long survey. Make it clear 
their feedback will be used, not just collected.

Personal and Casual

25. Thank you email

Write a genuine thank you email to [person] for [what they did]. Be specific about 
what they did and why it mattered — don't write something that could apply to anyone. 
Keep it short.

26. Introduction email

Write an email introducing [person A] to [person B]. Explain who each person is in 
one sentence, why the connection is valuable, and make a clear ask or suggestion for 
how they should follow up. CC both.

27. Reconnect with an old contact

Write a casual email to reconnect with [person] whom I haven't spoken to in [time]. 
Reference something genuine — a shared history, something I remember about them, or 
something I noticed about their recent work. Don't ask for anything in the first 
email.

28. Congratulate someone on an achievement

Write a short congratulatory email to [person] about [achievement]. Make it genuine 
and specific to what they actually did — not just "congratulations, well done."

Email Polish

29. Improve an existing email draft

Rewrite this email draft to be clearer and more concise. Keep the meaning but cut 
anything that isn't earning its place. Don't change the tone or main point.

Draft: {{clipboard}}

30. Make an email more direct

Rewrite this email to be more direct and less hedged. Remove unnecessary qualifiers 
("I was wondering if maybe", "just wanted to check"). Get to the point faster and 
make the ask clear.

Draft: {{clipboard}}

Setting Up Email Prompts with Dynamic Variables

The prompts use placeholders like [name], [company], and [context] for customization. For recurring email types — cold outreach in specific industries, client status updates, or follow-ups at set intervals — adding dynamic variables means the prompt customizes itself at paste time.

For instance, a cold outreach prompt with {{clipboard}} for background context means copying relevant context, firing the prompt, and receiving a first draft incorporating what was pasted.

Promptzy handles this natively. Store email prompts with dynamic tokens, and they resolve automatically when pasted. An "Emails" collection with 10-15 templates means most-used types are one Cmd+Shift+P away. $5 one-time, no subscription; prompts stored as plain Markdown files you own.

Originally published at promptzy.app/blog

The Best AI Prompts for Code Review (Works with Any AI Tool)

Nav — Mon, 30 Mar 2026 15:29:37 +0000

The Best AI Prompts for Code Review (Works with Any AI Tool)

The quality of AI code reviews hinges primarily on prompt design rather than the underlying model. Generic requests yield shallow feedback, whereas targeted prompts focused on specific concerns—security, performance, naming conventions—produce actionable insights that catch real issues.

These prompts function across ChatGPT, Claude, Copilot Chat, and Gemini. Rather than rewriting identical prompts for each pull request, you can save them for reuse. The author has employed similar versions for approximately one year and reports they've identified genuine bugs.

General Code Review

1. Comprehensive Review

Review the following code for: (1) bugs and logic errors, (2) security vulnerabilities, 
(3) performance issues, (4) readability and naming. For each issue, point to the specific 
line or section and suggest a concrete fix.

{{clipboard}}

2. Quick Scan

I'm going to paste some code. Without going deep, tell me the 3-5 things that stand 
out most as potential problems. Don't give me an essay — just flag what catches 
your eye.

{{clipboard}}

3. Senior Engineer Review

Review this code as a senior engineer doing a real code review. Be direct and specific. 
Point out what's genuinely wrong, what's debatable, and what's fine. If something is 
subjective, say so. Don't pad the response with praise.

{{clipboard}}

4. Junior Developer Focused Review

Review this code in a way that helps a junior developer learn. Explain not just what 
to change but why it matters. Balance encouragement with honesty — point out what's 
done well alongside what needs improvement.

{{clipboard}}

Security Review

These prompts apply to code handling user input, authentication, or sensitive information.

5. Security Audit

Audit this code for security vulnerabilities. Check for: SQL injection, XSS, CSRF, 
insecure deserialization, broken authentication, improper input validation, hardcoded 
secrets, and any OWASP Top 10 concerns. Explain each issue and how to fix it.

{{clipboard}}

6. Authentication and Authorization Review

Review this code specifically for authentication and authorisation issues. Are 
permissions checked correctly? Are there any privilege escalation paths? Is session 
handling secure? Is user input trusted when it shouldn't be?

{{clipboard}}

7. Data Handling Security

Review how this code handles sensitive data. Is it encrypted at rest and in transit? 
Is it logged anywhere it shouldn't be? Are there any places where sensitive data could 
be exposed in errors or responses?

{{clipboard}}

8. Input Validation Review

Review the input validation in this code. Is all user input validated and sanitised 
before use? Are there any paths where unvalidated input reaches a database, shell 
command, or file system?

{{clipboard}}

Performance Review

9. Performance Analysis

Analyse this code for performance issues. Identify: expensive operations that could 
be cached, unnecessary iterations or nested loops, N+1 query patterns, blocking 
operations, and memory inefficiencies. Suggest specific improvements.

{{clipboard}}

10. Database Query Review

Review these database queries for performance. Check for: missing indexes, N+1 patterns, 
unnecessary data fetching, missing query limits, and any queries that will degrade at 
scale.

{{clipboard}}

11. Memory Usage Review

Review this code for memory issues. Look for: memory leaks, large in-memory data 
structures that could be streamed, unnecessary object creation in hot paths, and 
anything that could cause issues under load.

{{clipboard}}

Readability and Maintainability

12. Naming and Clarity Review

Review the naming in this code — variables, functions, classes, and modules. Is 
everything named clearly enough that someone new could understand the intent? Suggest 
specific renames for anything that's ambiguous or misleading.

{{clipboard}}

13. Complexity and Simplification

Where is this code more complex than it needs to be? Identify over-engineering, 
unnecessary abstractions, convoluted logic that could be simplified, and any "clever" 
code that should be made boring instead.

{{clipboard}}

14. Maintainability Review

Review this code from the perspective of long-term maintenance. Is it readable to a 
new developer? Is the logic well-encapsulated? Are dependencies clear? What would make 
this harder to change in 6 months?

{{clipboard}}

15. Code Smell Identification

Identify code smells in this code: long functions doing too many things, deep nesting, 
repeated logic, magic numbers, poor separation of concerns, and anything that violates 
single responsibility. Don't fix them — just name them and explain why they're a 
problem.

{{clipboard}}

Architecture and Design

16. API Design Review

Review this API design. Evaluate: naming conventions, RESTful principles (if applicable), 
error handling approach, response structure consistency, versioning considerations, and 
developer experience. Suggest specific improvements.

{{clipboard}}

17. Function Design Review

Review the design of this function. Does it do one thing? Is the interface clean? 
Are the parameters sensible? Should it be split up? Is the return type appropriate?

{{clipboard}}

18. Error Handling Review

Review the error handling in this code. Are all error cases handled? Are errors 
propagated correctly? Are error messages useful for debugging? Is there anything that 
fails silently or swallows errors?

{{clipboard}}

19. Dependency and Coupling Review

Review the dependencies and coupling in this code. Are there tight couplings that 
would make testing or replacing components difficult? Are there any circular 
dependencies? Could the architecture be improved for testability?

{{clipboard}}

Testing

20. Test Quality Review

Review these tests. Do they actually test the right things? Are there edge cases 
missing? Are the tests too brittle (testing implementation details instead of 
behaviour)? Are the assertions meaningful?

{{clipboard}}

21. Test Coverage Gaps

Here's the production code and the tests for it. What's not covered by the tests? 
What edge cases, error paths, or scenarios are missing? List them specifically.

Code: {{clipboard}}

22. Test Setup and Teardown Review

Review the test setup and teardown in this file. Are tests isolated from each other? 
Are mocks set up correctly? Could any tests interfere with others? Is the test data 
setup realistic?

{{clipboard}}

Pull Request Review

23. PR Diff Review

I'm reviewing this pull request. Go through the diff and check for: (1) logic 
correctness, (2) edge cases not handled, (3) test coverage gaps, (4) anything that 
could break existing behaviour, (5) naming or style issues. Be specific about file 
and line references where possible.

{{clipboard}}

24. PR Description Review

Review this PR description. Is it clear what problem is being solved? Is the approach 
explained? Are there testing instructions? Are there any risks or edge cases the 
reviewer should know about?

{{clipboard}}

25. PR Summary for Non-Technical Stakeholders

Summarise this pull request in plain English for a non-technical stakeholder. What 
problem does it solve? What changed? Is there any risk? What should they know about 
it?

{{clipboard}}

Using These Prompts Effectively

Pick the Right AI Tool

Different models excel at different aspects of code review. There are specialized guides for ChatGPT and Claude specifically optimized for developer workflows.

Be Specific About Review Scope

Broad requests like "review this code" produce shallow assessments. Targeted prompts addressing particular concerns — "specifically for security" — yield focused, useful feedback. Match the prompt to your review objective.

Include Necessary Context

Provide relevant code sections rather than entire files. When code interacts with database schemas or external APIs, include those details too.

Leverage the {{clipboard}} Pattern

Copy code first, then execute the prompt. The clipboard automatically injects content, accelerating the workflow compared to manual copy-paste operations.

Run Focused Multiple Reviews

Security and performance reviews identify different issues. Execute multiple specialized reviews on critical code rather than attempting comprehensive coverage in one prompt.

If you're doing regular AI-assisted code reviews, keeping these prompts accessible saves real time. Promptzy stores them as Markdown files and pastes them into Copilot Chat, Claude, or ChatGPT in under two seconds — no hunting for templates mid-review. The {{clipboard}} token handles the code injection automatically.

Originally published at promptzy.app/blog

The Best Perplexity AI Prompts for Research and Deep Dives (2026)

Nav — Sun, 29 Mar 2026 09:27:46 +0000

Perplexity is not a replacement for ChatGPT or Claude — it's a different tool. Its edge is real-time search with citations, which makes it excellent for research tasks where you need sourced, current information. Generic AI prompts don't take advantage of that. The prompts below are written specifically for what Perplexity does differently: surfacing cited answers, synthesising across sources, and handling questions where currency matters.

Use these for research tasks. For longer reasoning, writing, or coding, you'll likely get better results from a model with a longer context window. If you find research prompts you keep reusing, you can save your best research prompts so they're ready whenever you need them.

Market Research

These are where Perplexity pulls away from offline models. You get sourced, current answers that you'd otherwise spend an hour assembling manually.

1. Market overview

Give me a current overview of the [market/industry] market. Cover: size and growth trajectory, 3-5 major players with their positioning, recent trends or shifts, and what the competitive landscape looks like heading into the next 12-18 months. Cite sources.

2. Emerging players in a space

Who are the most interesting emerging companies in [space] right now? For each one, give me: what they do, what differentiates them, their funding status if known, and why they're worth watching. Cite sources.

3. Customer pain points in a market

What are the most common complaints or unmet needs customers have in the [market] space? Pull from recent reviews, forums, social media, and industry reports. Cite sources.

4. Regulatory landscape

What are the current regulatory requirements or upcoming regulatory changes affecting [industry/company type] in [region]? Focus on what's changing in the next 12-24 months. Cite sources.

5. Industry analyst reports summary

Summarise what major analysts (Gartner, Forrester, IDC, or similar) are saying about [market/technology] in 2026. What are the key predictions and disagreements? Cite sources.

Competitor Analysis

6. Competitor deep dive

Give me a detailed overview of [competitor company]. Cover: what they do, pricing model, recent funding or acquisitions, customer reviews sentiment, recent news, and what's working vs what's a weak point. Cite sources.

7. How a competitor is growing

How has [company] grown its customer base over the last 1-2 years? What channels, partnerships, or strategies seem to be working? Cite sources.

8. Competitor pricing breakdown

What does [product/service] currently charge? Break down their pricing tiers, what each includes, any recent changes, and whether there's a free tier or trial. Cite sources.

9. What customers say about a competitor

What are customers saying about [product] in 2026? Summarise the most common praise and complaints from reviews on G2, Capterra, Reddit, and similar. Cite sources.

10. Feature comparison across competitors

Compare [feature] across [Company A], [Company B], and [Company C]. How does each approach it differently? Who's doing it best based on user feedback? Cite sources.

Technical Research

11. How a technology works

Explain how [technology/protocol/system] works. Give me a technically accurate explanation that assumes a software engineering background. Include current state of adoption and any important recent developments. Cite sources.

12. Best practices for a technical topic

What are the current best practices for [technical topic] in 2026? What has changed from a few years ago? Are there any debates in the community about the right approach? Cite sources.

13. Security vulnerabilities or CVEs

Are there any known security vulnerabilities or CVEs affecting [library/framework/technology] in the last 12 months? What's the severity, and what are the mitigations? Cite sources.

14. Benchmarks and performance comparisons

How does [technology/tool/model] perform compared to alternatives? Find recent benchmarks or comparisons. What are the real-world performance differences? Cite sources.

15. Open source alternatives

What are the best open source alternatives to [commercial tool/service] in 2026? For each, give me: what it does, how it compares on features, adoption level, and any trade-offs. Cite sources.

Business and Strategy Research

16. Funding and investment activity

What's the recent funding activity in [space/sector]? Who's raised significant rounds in the last 6 months, at what valuations, and what does the investor interest say about the direction of the space? Cite sources.

17. Key hires and talent movements

Have there been any notable executive hires, departures, or talent movements at [company] recently? What do they signal about company direction? Cite sources.

18. Acquisition activity

What acquisitions have happened in [space] in the last 12 months? Who acquired what, at what price if reported, and what's the strategic rationale? Cite sources.

19. Partnership announcements

Have there been any significant partnership or integration announcements from [company] recently? What's the strategic value? Cite sources.

20. Job posting signals

What does [company]'s current hiring activity suggest about their priorities and direction? What roles are they actively hiring for, and what does that tell us? Cite sources.

News Synthesis

21. Weekly digest on a topic

What are the most significant news items related to [topic] from the last 7 days? Give me 5-7 bullet points with brief explanations and why each matters. Cite sources.

If you need to condense Perplexity's output further, our summarization prompts work well as a second pass in ChatGPT or Claude.

22. Summarise a recent event or announcement

Summarise what happened with [event/announcement] and why it matters. Include: what happened, the context, the key reactions, and what it might mean going forward. Cite sources.

23. Track a developing story

What's the current status of [ongoing situation]? Give me a brief history and where things stand right now. Cite sources.

For academic and deep-dive work, our AI prompts for students and researchers guide covers complementary patterns that pair well with Perplexity's citation engine.

24. Find expert opinions on a topic

What are practitioners, researchers, or notable voices saying about [topic] right now? I want a range of perspectives, not a single consensus view. Cite sources.

25. Separate signal from noise

There's been a lot of coverage of [topic] recently. Cut through the hype: what's genuinely new or important, and what's just noise or marketing? Cite sources.

Due Diligence and Fact-Checking

26. Fact-check a specific claim

I've heard that [specific claim]. Is this accurate? What does current information say? If it's partially true, explain the nuance. Cite sources.

27. Verify a statistic

Where does the statistic "[stat]" come from? Is it accurate? What's the original source and methodology? Are there more recent figures? Cite sources.

28. Find contradicting evidence

What's the strongest evidence against the view that [position]? Are there credible sources, studies, or cases that contradict it? Cite sources.

29. Check a company 's claims

[Company] claims that [claim]. How accurate is this? What do independent sources say? Cite sources.

30. Background on a person or organisation

Give me a factual background on [person/organisation]. Include: their history, notable work or events, any controversies, and current activities. Stick to verifiable information. Cite sources.

Getting Cited, Sourced Answers

A few things that improve Perplexity results:

Always ask for sources explicitly ("cite sources" at the end of a prompt). Perplexity usually cites by default, but asking makes it prioritise sourced claims over inference.

For technical questions, specify the level of depth you want. Perplexity tends toward accessible explanations by default — if you want a technically precise answer, say so.

For time-sensitive research, add "as of 2026" or "in the last 6 months" to constrain results. This helps avoid mixing current and outdated information. For search-grounded work that leans more toward Google's ecosystem, Gemini prompts for productivity covers a complementary set of research patterns.

Perplexity's follow-up conversation works well for drilling down — use it iteratively rather than trying to cram everything into one prompt.

If you're running the same research prompts repeatedly — market monitoring, competitor tracking, weekly digests — storing them somewhere accessible saves setup time. You can organize your research prompts on Mac to keep your best Perplexity templates one shortcut away. Promptzy stores these as plain Markdown files and pastes any prompt into any app in under 2 seconds. A "Research" collection means your best Perplexity prompts are one Cmd+Shift+P away.

Store and manage your prompts with Promptzy

Free prompt manager for Mac. Search with Cmd+Shift+P, auto-paste into any AI app.

Download Free for macOS

The Best GitHub Copilot Prompts for Faster Coding (2026)

Nav — Sun, 29 Mar 2026 09:10:56 +0000

GitHub Copilot has evolved well past autocomplete. With Copilot Chat, workspace agents, and slash commands, it's now a full coding assistant — but most developers are still using it for simple completions and occasionally asking it to explain something. The prompts below are written for the full Copilot experience: inline suggestions, Chat, and the workspace agent.

These are specific, tested, and honest about what Copilot does well versus where you'll get better results from a standalone model like Claude or ChatGPT. If you find yourself reaching for the same patterns repeatedly, you can save Copilot prompt patterns you use repeatedly so they're always one shortcut away.

Code Review

Copilot Chat is surprisingly good at code review when you give it focused prompts. These get more useful output than generic "review this code" requests. For a deeper dive into review-specific patterns across tools, see our AI prompts for code review guide.

1. General code review

/review

Review this code for: bugs, security issues, performance problems, and readability concerns. Be specific — call out line numbers where possible and suggest concrete fixes.

2. Security-focused review

Review this code specifically for security vulnerabilities. Check for: SQL injection, XSS, insecure deserialization, hardcoded secrets, improper input validation, and any OWASP Top 10 concerns.

{{clipboard}}

3. Performance review

Analyse this code for performance issues. Identify expensive operations, unnecessary iterations, memory leaks, and N+1 query patterns. Suggest specific optimisations.

{{clipboard}}

4. Review for maintainability

Review this code from a maintainability perspective. Is it readable? Is the naming clear? Are there any abstractions missing or over-engineered? How would a new team member experience this?

{{clipboard}}

5. Pull request review checklist

I'm reviewing this pull request diff. Go through it and check for: (1) correctness — does the logic do what it claims, (2) edge cases that aren't handled, (3) test coverage gaps, (4) any naming or style inconsistencies, (5) anything that could break existing behaviour.

{{clipboard}}

Test Generation

Test generation is one of Copilot's strongest use cases when you're specific about what you want.

6. Write unit tests for a function

Write comprehensive unit tests for this function. Cover: happy path, edge cases, error cases, and boundary conditions. Use the testing framework already in this project.

{{clipboard}}

7. Write tests for untested code

This code has no tests. Write unit tests that give good coverage. Identify any parts that are hard to test and suggest how to refactor them for testability.

{{clipboard}}

8. Write integration tests

Write integration tests for this feature. Focus on the interactions between components, not just individual functions. Mock external dependencies appropriately.

{{clipboard}}

9. Identify test gaps

I have this code and these existing tests. Identify what's not covered by the tests and write additional tests to fill the gaps.

Code: {{clipboard}}

10. Write a test for a specific bug

Write a regression test that would have caught this bug before it was introduced: [describe the bug]. The test should fail on the buggy code and pass on the fix.

Documentation

11. Write function documentation

Write clear, accurate documentation for this function. Include: what it does, parameters with types and descriptions, return value, exceptions it can throw, and a usage example.

{{clipboard}}

12. Write a README section

Write a clear README section for this module or feature. Cover: what it does, how to use it, required configuration, and a code example.

{{clipboard}}

13. Write inline comments for complex logic

Add inline comments to this code that explain the "why" behind non-obvious decisions. Don't comment obvious things — focus on logic that would confuse a new developer.

{{clipboard}}

14. Generate API documentation

Generate API documentation for this endpoint or function. Use a clear format covering: purpose, request parameters, response format, error codes, and an example request/response.

{{clipboard}}

Debugging

15. Explain an error

I'm getting this error: {{clipboard}}

Explain what's causing it, what part of the code is responsible, and give me a fix.

16. Trace unexpected behaviour

This code should do [expected], but it's doing [actual] instead. Walk me through what's actually happening step by step and explain why it behaves this way.

{{clipboard}}

17. Suggest fixes for a failing test

This test is failing. Here's the test and the error output. Tell me whether the bug is in the implementation or the test itself, and give me a fix either way.

{{clipboard}}

18. Diagnose a performance problem

This function is running slower than expected. Profile it mentally — where are the bottlenecks? What would you change first?

{{clipboard}}

Refactoring

19. Refactor for readability

Refactor this code to improve readability without changing behaviour. Extract functions if needed, improve naming, and remove any unnecessary complexity.

{{clipboard}}

20. Reduce duplication

This codebase has duplication across these files. Identify the patterns and suggest how to refactor them into shared abstractions.

{{clipboard}}

21. Modernise old code

This code was written for an older version of [language/framework]. Update it to use current best practices and modern syntax while preserving all existing behaviour.

{{clipboard}}

22. Break up a large function

This function is doing too much. Break it up into smaller, focused functions. Each function should do one thing and be testable in isolation.

{{clipboard}}

PR Summaries and Commit Messages

23. Write a PR description

Write a clear PR description for these changes. Cover: what problem this solves, how it was approached, what was changed, how to test it, and any edge cases or risks.

Diff summary: {{clipboard}}

24. Write a commit message

Write a clear, conventional commit message for these changes. Format: type(scope): short description. Include a body if the change needs more explanation.

Changes: {{clipboard}}

25. Summarise a PR for review

Summarise this PR for a reviewer who hasn't seen the context. Give them: the problem being solved, the approach taken, what files changed and why, and what to focus on during review.

{{clipboard}}

Workspace Agent Prompts

Copilot's workspace agent (@workspace) has context about your entire project. These prompts work best in that mode.

26. Find all usages of a pattern

@workspace Find all places in the codebase where [pattern/function/class] is used. List them with file paths and explain the context for each.

27. Understand a codebase area

@workspace Explain how [feature/module] works in this codebase. Walk me through the main files involved, how data flows, and what the key abstractions are.

28. Identify all places that need to change

@workspace I need to change [thing]. List all the places in the codebase that will need to be updated, including any tests, config files, and documentation.

29. Find potential breaking changes

@workspace If I change the signature of [function/interface], what else in the codebase would break? List all affected files and usages.

30. Onboard to a new codebase

@workspace I'm new to this codebase. Give me an overview: what does it do, how is it structured, what are the main entry points, and what should I read first to get oriented?

Getting the Most Out of Copilot Chat

A few patterns that improve results:

Use/fix, /explain, /tests slash commands for quick single-purpose requests. They're faster than typing a full prompt and Copilot handles the framing.

Give Copilot the right context. Copilot Chat sees the open file, but if you're asking about interactions between files, paste the relevant code or use @workspace. For chat-based AI work outside the editor, our ChatGPT prompts for developers and Cursor AI prompts guides cover complementary workflows.

Be specific about what you don 't want. "Refactor this without changing the public API" or "write tests without mocking the database" saves you from unhelpful suggestions.

If you're building up a library of prompts across Copilot, Claude, and ChatGPT, you need a way to manage your developer prompts across tools. A prompt manager keeps them together and accessible from anywhere. Promptzy stores prompts as Markdown files and pastes any of them into VS Code, the browser, or anywhere else in under 2 seconds. A "Copilot" collection means your best prompts are one shortcut away — without switching context.

Store and manage your prompts with Promptzy

Free prompt manager for Mac. Search with Cmd+Shift+P, auto-paste into any AI app.

Download Free for macOS

The 30 Best AI Prompts for Operations & Project Managers

Nav — Sat, 28 Mar 2026 20:37:13 +0000

If you run operations or manage projects, you're spending a lot of time on things that should take minutes. Status reports. Risk summaries. Meeting agendas. Escalation emails. The work behind the work.

AI prompts for project managers can cut that overhead dramatically — but only if the prompts are actually built for how ops and PM work functions. Generic "summarize this" prompts don't cut it when you need a structured risk log or a vendor scorecard that your stakeholders will actually read.

This is a list of 30 AI prompts built specifically for operations and project managers. Copy them directly, or save them in Promptzy so you can fire any one of them with a keyboard shortcut.

Status Reports & Updates

1. Weekly status report from bullet points

Write a professional weekly project status report. Project: [PROJECT NAME]. RAG status: [RED/AMBER/GREEN]. Key updates this week: [BULLET POINTS]. Blockers: [LIST]. Next week priorities: [LIST]. Keep it under 300 words. Use a clear structure with headers.

2. Executive summary for stakeholders

Summarize the following project update into a 5-sentence executive summary for senior stakeholders who want the headline, not the detail. Focus on: current status, any risks, key decisions needed. Update: [PASTE UPDATE]

3. Turn messy notes into a formal status update

I have rough meeting notes and want to turn them into a clean stakeholder update email. Clean up the language, organize into: progress, risks, actions, next steps. Notes: [PASTE NOTES]

4. Red status escalation message

Write a professional escalation email for a project that has just moved to RED status. Project: [NAME]. Core issue: [DESCRIBE]. Impact if unresolved: [IMPACT]. What I need from leadership: [WHAT YOU NEED]. Tone: direct, factual, no blame.

5. Sprint retrospective summary

Write a sprint retrospective summary from these team inputs. Format: What went well, what didn't, what we're changing. Keep each section to 3 bullet points max. Inputs: [PASTE RAW NOTES]

Risk Management

6. Risk log entry

Write a risk log entry for the following risk: [DESCRIBE RISK]. Include: risk description, likelihood (High/Medium/Low), impact (High/Medium/Low), risk owner, mitigation actions (3 bullet points), contingency plan. Format as a table row I can paste into a spreadsheet.

7. Risk assessment from project description

I'm starting a new project: [DESCRIBE PROJECT]. Identify the top 5 risks I should log immediately. For each risk: name it, rate likelihood and impact, suggest one mitigation action. Be specific to my project context, not generic.

8. Risk update for steering committee

I need to present our top project risks to a steering committee. Here are the risks: [LIST RISKS AND STATUS]. Write a 3-paragraph narrative that explains the risk landscape, what we're doing about it, and what decisions the committee needs to make.

9. Issue escalation vs. risk differentiation

Help me categorize these items as either active issues (already affecting the project) or risks (potential future problems): [LIST ITEMS]. For each, tell me how to log it and what immediate action to take.

Meeting Agendas & Facilitation

10. Kick-off meeting agenda

Write a 60-minute project kick-off meeting agenda for: [PROJECT NAME AND BRIEF DESCRIPTION]. Attendees: [LIST ROLES]. Include: introductions, project overview, scope, roles & responsibilities, timeline, risks, open Q&A. Add time allocations and the goal for each section.

11. Retrospective facilitation guide

Create a 45-minute retrospective facilitation guide for a team of [NUMBER] people. Use the Start/Stop/Continue format. Include: opening warm-up activity, time allocations, exact facilitator prompts to use, and how to close with clear action items.

12. Recurring standup format

Write a standup meeting format for a [NUMBER]-person ops team. Each person has 2 minutes. The format should surface blockers fast and stay under [TOTAL MINUTES] total. Include the exact 3 questions each person answers.

13. Meeting notes to action items

I have raw meeting notes. Extract all action items and format them as a table with: Action, Owner, Due Date, Priority (H/M/L). Notes: [PASTE NOTES]. If owner or due date isn't mentioned, flag it as TBD.

14. Steering committee deck outline

Create a steering committee presentation outline for project [NAME] at [MILESTONE/STAGE]. The committee wants: status summary, financials, risks, decisions needed, and next steps. Give me a slide-by-slide outline with 2-3 bullet points per slide.

SOPs & Documentation

15. Standard operating procedure template

Write a standard operating procedure (SOP) for the following process: [DESCRIBE PROCESS]. Include: purpose, scope, roles and responsibilities, step-by-step procedure, exceptions, revision history table. Tone: clear, direct, no unnecessary jargon.

16. Process documentation from brain dump

I'm going to describe a process in rough terms. Turn it into a clean, numbered SOP that a new team member could follow without asking questions. My description: [PASTE DESCRIPTION]

17. Runbook for recurring operations task

Create a runbook for: [TASK OR PROCESS NAME]. This is a recurring task done by [ROLE]. Include: trigger/when to run this, prerequisites, step-by-step instructions with commands or system steps where relevant, common errors and how to handle them.

18. RACI matrix from project description

Build a RACI matrix for a [PROJECT TYPE] project. Roles involved: [LIST ROLES]. Key workstreams: [LIST WORKSTREAMS OR DELIVERABLES]. Use a table format with Responsible, Accountable, Consulted, Informed clearly marked.

Escalations & Difficult Communications

19. Scope creep response email

Write a professional email to a stakeholder who is requesting work outside the original project scope. Acknowledge their request, explain the scope boundary clearly, offer to raise a formal change request if they want to proceed, and keep the tone collaborative. Context: [DESCRIBE REQUEST]

20. Missed deadline notification

Write an email informing stakeholders that [DELIVERABLE] will be delayed from [ORIGINAL DATE] to [NEW DATE]. Explain the reason honestly without over-apologizing. Include what's being done to prevent further delays and the revised plan. Tone: direct, accountable.

21. Pushback on unrealistic deadline

Help me write a professional response to a request to deliver [DELIVERABLE] by [UNREALISTIC DATE]. I need to say no clearly, offer an alternative timeline with reasoning, and keep the relationship intact. My actual estimate: [YOUR TIMELINE]. Context: [BACKGROUND]

22. Post-incident summary

Write a post-incident summary for the following operations issue. Format: incident summary, timeline of events, root cause, impact, immediate actions taken, long-term remediation plan. Details: [PASTE INCIDENT NOTES]

Vendor & Budget Management

23. Vendor evaluation scorecard

Create a vendor evaluation scorecard for selecting a [TYPE OF VENDOR/SERVICE]. We're evaluating [NUMBER] vendors. Criteria to include: [LIST YOUR KEY CRITERIA]. Weight each criterion by importance. Format as a spreadsheet-ready table with scoring columns.

24. RFP requirements section

Write the requirements section for an RFP for [PRODUCT/SERVICE]. We need: functional requirements, technical requirements, vendor qualifications, and SLA expectations. Context about our needs: [DESCRIBE CONTEXT]. Be specific, not generic.

25. Budget variance explanation

Write a budget variance explanation for a [PROJECT/DEPARTMENT]. We're [OVER/UNDER] budget by [AMOUNT/PERCENTAGE]. Reason: [EXPLAIN WHY]. Write a 2-paragraph explanation for a finance review meeting that is factual, clear, and includes a corrective action.

26. Contract renewal decision brief

Write a one-page decision brief for renewing or replacing our contract with [VENDOR NAME]. Contract details: [COST, TERM, WHAT THEY DO]. Our experience: [POSITIVES AND NEGATIVES]. Options: renew, renegotiate, or switch to [ALTERNATIVE]. Recommendation: [YOUR RECOMMENDATION]. Format for a leadership read.

Planning & Strategy

27. Project charter draft

Draft a project charter for: [PROJECT NAME AND DESCRIPTION]. Include: project objective, scope (in/out of scope), success criteria, key stakeholders, high-level timeline, assumptions and constraints, budget summary, and approvals section. Keep it to one page.

28. Dependency map from project list

I have a list of workstreams for a project. Identify the dependencies between them and flag which are on the critical path. Workstreams: [LIST THEM]. Format as a table showing: workstream, depends on, must complete before, on critical path (Y/N).

29. Lessons learned document

Write a lessons learned document for a recently completed [TYPE] project. Team size: [SIZE]. Duration: [DURATION]. Outcome: [SUCCESSFUL/PARTIALLY SUCCESSFUL/FAILED AND WHY]. Include: what worked well, what didn't, recommendations for future similar projects, and a summary section for the project archive.

30. Quarterly ops review outline

Create an outline for a quarterly operations review for [TEAM/DEPARTMENT]. Audience: [LEADERSHIP LEVEL]. Include: KPI scorecard, highlights, lowlights, blockers resolved, open risks, team capacity, and priorities for next quarter. Format as a presentation outline with talking points per slide.

Making These Prompts Work Harder

A few things that separate the PMs who get real leverage from AI versus the ones who spend more time fixing outputs than they saved:

Be specific about format. Prompts that say "write a status report" get generic output. Prompts that say "under 300 words, use headers, RAG status at the top" get something you can actually send.

Use variables. Where you see [PROJECT NAME] or [PASTE NOTES], that's a placeholder. The more specific context you provide, the better the output. This is also where tools like Promptzy help — you can store these prompts with {{clipboard}} tokens that auto-fill your clipboard content on paste, so you don't have to restructure the prompt every time.

Iterate on outputs. First draft from AI is rarely the final version. Use a follow-up prompt: "Make this more direct" or "Cut this by 30%" to get closer to what you need.

Save the prompts you use most often so they're always one shortcut away. Store these in Promptzy and assign a keyboard shortcut to the ones you reach for daily.