DEV Community

Cover image for πŸ€– 100 AI Agent Prompts I Use Daily. These 15 Are Pure Gold.
Suraj Khaitan
Suraj Khaitan

Posted on

πŸ€– 100 AI Agent Prompts I Use Daily. These 15 Are Pure Gold.

#ai #agents #claude #webdev

I don't prompt chatbots for a living β€” I run agents. Over the last year I've collected, tested, and quietly retired hundreds of prompts that steer autonomous coding and research agents. About 100 survived into my daily rotation. Fifteen of them are load-bearing: remove one and my agents get measurably dumber, slower, or more dangerous. Here are the fifteen, the copy-paste text, why each works, and the exact models they work with in 2026.

Why I Went Down This Rabbit Hole

Here's the shift nobody tells you about when you move from "using AI" to managing agents: the prompt stops being a question and becomes a contract. A chatbot prompt asks for an answer. An agent prompt authorizes a system to read your files, run your tools, spend your tokens, and change your codebase while you're in a meeting. Get it vague and the agent wanders, hallucinates, or confidently ships a landmine. Get it right and it lands a reviewed PR before you're back at your desk.

As Anthropic and half the field now argue, in 2026 the discipline isn't "prompt engineering" anymore β€” it's context engineering: curating the right tokens into a limited window at each step, because every frontier model measurably degrades as context grows β€” long before the window is full (transformer attention scales with the square of the token count, so more context literally dilutes recall). The one-liner I use with my team: prompt engineering optimizes how you ask; context engineering optimizes *what the agent knows when it answers.* The prompt is just the part of the context you write on purpose.

So I did the obvious thing. I treated my prompt library like a codebase: version it, test it, delete what doesn't earn its place. ~100 prompts made the cut. These 15 are the ones I'd tattoo on the inside of my eyelids.

TL;DR

  • Agent prompts are contracts, not questions. They define the goal, the constraints, the tools, and β€” most importantly β€” the definition of done.
  • The gold splits into six jobs: plan before acting, build with discipline, verify everything, keep autonomy on rails, ground answers in truth, and compound your leverage.
  • The single highest-ROI habit: make the agent write a plan and stop for approval before it touches anything.
  • Calibration beats confidence. A prompt that lets the agent say "I don't know" is worth more than one that forces an answer β€” layered guardrails reportedly cut hallucinations 71–89%.
  • These are model-agnostic but tuned for tool-using, reasoning-capable models. Full 2026 compatibility table below (Claude Opus/Sonnet 5, GPT-5.6, Gemini 3.x, Grok 4.5, Muse Spark, and the open-weight field).
  • The other 85 are listed by category at the end so you can raid the whole shelf.

What Makes an Agent Prompt "Gold" in 2026

Before the list, the five principles every keeper shares. This is the rubric I score prompts against.

  1. It states the definition of done. The most common reason an agent "fails" is that it succeeded at a different task than you meant. Name the tests, the output format, the acceptance check.
  2. It respects the instruction budget. Frontier models reliably follow only ~150–200 instructions, and your coding agent's system prompt already burns ~50 of them (OpenHands, 2026). A bloated prompt doesn't add rigor β€” it buries the rules that matter. Short and sharp wins.
  3. It engineers context, not just wording. Keep the critical instruction at the beginning or end, strip pasted raw tool output, and give the agent a file to use as external memory instead of stuffing everything in the window (Anthropic).
  4. It builds a bounded loop. The teams getting the most out of agents aren't writing clever one-liners β€” they're building well-bounded loops with a plan, tool control, verification, and a stop condition. Reflection matters: one round of structured self-critique catches a large share of errors.
  5. It rewards calibration over confidence. A model that admits uncertainty where it would be wrong is far more useful than one that's right 95% of the time but confidently wrong the other 5% with no signal which is which.

Every prompt below is doing at least three of those five things on purpose.

Which Models These Prompts Work With (2026)

These are model-agnostic β€” but they assume a model that can use tools, reason, and hold a plan. Here's the current agent-capable lineup and what each is good for as an agent backbone. (Intelligence figures track the Artificial Analysis Intelligence Index; treat as directional.)

Model Lab Weights Agentic strengths Tools / MCP
Claude Opus 5 Anthropic Closed Best all-round agent backbone; extended thinking + effort low→max Tools, computer use, MCP
Claude Sonnet 5 Anthropic Closed Default workhorse; big agentic jump (Terminal-Bench +20 pts) Tools, computer use, MCP
Claude Fable 5 Anthropic Closed Long-horizon autonomy, hardest reasoning Tools, MCP
Claude Haiku 4.5 Anthropic Closed Fast tier for subagents & high-volume fan-out Tools, thinking
GPT-5.6 Sol / Terra / Luna OpenAI Closed Strong agentic coding; reasoning-effort control Tools, MCP
Gemini 3.1 Pro Google Closed Reasoning/science, multimodal, long context Tools, computer use
Gemini 3.6 Flash Google Closed Computer-use leader (OSWorld ~83%); cheap high-volume loops Tools, computer use
Grok 4.5 xAI Closed Cost-efficient agentic coding; 3 effort levels Tools
Muse Spark 1.1 Meta Closed Tool-use / orchestration leader (MCP Atlas); subagents Tools, MCP, computer use
Kimi K3 Moonshot Open* Top open model; agentic search & browsing Tools, MCP
GLM-5.2 Z.ai Open (MIT) Value agentic coding; self-hostable Tools, MCP
DeepSeek V4 DeepSeek Open (MIT) Frontier-adjacent, cheap, self-hostable Tools
MiniMax M3 MiniMax Open (MIT) Cheapest agentic coding + computer-use Tools, computer use
Qwen 3.5 / 3.6 Alibaba Open (Apache) Dual-mode thinking; strong tool use across sizes Tools, MCP

Kimi K3 weights are open under a custom license. **The one rule of thumb:* frontier models (Opus 5, GPT-5.6 Sol, Gemini 3.1 Pro) need less hand-holding β€” delegate outcomes, not steps. Small/fast models (Haiku 4.5, Flash-Lite, small open models) need the structure spelled out β€” give them the steps.

Now the fifteen.

🧭 Job 1 β€” Plan Before You Act

1. The Spec-First Contract (my single highest-ROI prompt) 

Before you write any code, produce a short spec and STOP for my approval:
1. Restate the goal in one sentence.
2. List your assumptions and any open questions.
3. List the files/functions you expect to touch.
4. Give a step-by-step plan.
5. Define "done" β€” the exact tests or checks that will prove it works.
Do not write a single line of code until I reply "approved".
Enter fullscreen mode Exit fullscreen mode

Why it works: a reviewed plan almost always means the implementation lands in one pass. It also surfaces the wrong assumptions before they become a 400-line diff. This is "plan mode" as a habit.
When to use: any non-trivial task. I skip it only for one-line fixes.

2. The Decomposition & Routing Prompt 

Break this into a dependency-ordered task list. For each subtask give: a one-line
description, its inputs, its output, and whether it can run in parallel. Then tag each
as CHEAP (safe for a fast model) or JUDGMENT (needs a frontier model). Propose the
execution order and what to run first.
Enter fullscreen mode Exit fullscreen mode

Why it works: it turns a vague epic into a plan-and-execute graph β€” and the CHEAP/JUDGMENT tags are exactly how I fan work out across a model fleet (frontier planner, cheap executors). Anthropic found delegation quality lives almost entirely in the task description β€” objective, output format, tools, and explicit boundaries β€” and that in their multi-agent research system token usage alone explained ~95% of performance variance, with agents burning ~4Γ— the tokens of chat and multi-agent setups ~15Γ—. Decompose well and route cheap, or the bill explodes.
When to use: large, multi-step builds and migrations.

πŸ”¨ Job 2 β€” Build With Discipline

3. The Red-Test-First Prompt 

Reproduce this bug as a FAILING test before you fix anything. Show me the red test and
confirm it fails for the right reason. Only then write the minimal fix, and show the test
going green. Don't touch unrelated code.
Enter fullscreen mode Exit fullscreen mode

Why it works: you get a regression guard for free and a higher-quality fix, because the agent has to actually understand the bug to reproduce it.
When to use: every bug fix.

4. The Minimal-Diff Prompt 

Make the smallest change that solves this. Read the neighboring code first and match its
style, naming, and patterns. No drive-by refactors, no new dependencies, no reformatting.
If you believe a refactor is needed, propose it separately β€” don't just do it.
Enter fullscreen mode Exit fullscreen mode

Why it works: it keeps diffs small and reviewable and stops the agent from "improving" 40 files you didn't ask about. Reviewable diffs are the whole game in agent-assisted engineering.
When to use: any edit inside an existing codebase.

πŸ” Job 3 β€” Trust Nothing, Verify Everything

5. The Adversarial Self-Review Prompt 

You just produced the above. Now switch roles: you are a skeptical senior reviewer who is
convinced this is wrong. List the top 5 most likely bugs, edge cases, or false assumptions,
and for each say how you'd test it. Then fix the ones that are actually real.
Enter fullscreen mode Exit fullscreen mode

Why it works: a single round of structured self-critique catches a startling share of a model's own errors. Making the model change hats beats asking "are you sure?" β€” it forces a genuinely different pass over the work.
When to use: after any first draft of code or analysis.

6. The Second-Opinion (Cross-Model) Prompt 

Review this diff as an adversarial critic. Assume the author is competent but overconfident.
Find correctness bugs, security issues, and untested paths. Rank findings by severity.
Do NOT rewrite the code β€” just report the findings.
Enter fullscreen mode Exit fullscreen mode

Run this on a different model than the one that wrote the code.

Why it works: self-review is structurally blind to a model's own confident-wrong mistakes. A second, different model catches a whole class of them β€” and running cheap reviewers in parallel is now economically trivial.
When to use: high-stakes diffs, security-sensitive changes.

7. The Calibrated-Uncertainty Prompt 

Answer, but tag every claim with a confidence: [certain] / [likely] / [guess]. For anything
you can't verify from the provided context or your tools, say "I don't know" instead of
guessing, and tell me exactly what you'd need to be sure.
Enter fullscreen mode Exit fullscreen mode

Why it works: it converts silent overconfidence into a visible signal you can act on. Layered guardrails like this β€” explicit permission to refuse, plus grounding β€” reportedly cut hallucination rates 71–89% versus unguarded prompting (2026 strategies).
When to use: research, analysis, anything factual an agent will act on.

πŸ›‘οΈ Job 4 β€” Run Agents That Don't Wander

8. The Long-Horizon Checkpoint Prompt 

This is a long task. Work in phases. After EACH phase:
(1) append a one-paragraph progress note and the current state to PROGRESS.md,
(2) run the tests,
(3) if green, continue; if red, STOP and summarize what's blocking.
Don't hold the whole task in your head β€” use PROGRESS.md as your memory.
Enter fullscreen mode Exit fullscreen mode

Why it works: it fights context rot directly by externalizing memory to a file, and it makes a multi-hour run safely resumable if the agent (or the API) drops. This is context engineering in one prompt.
When to use: multi-hour and unattended/autonomous runs.

9. The Guardrail / Policy-Adherence Prompt 

Hard rules for this task β€” follow ALL of them, even if it means NOT finishing:
- Never modify {protected paths}.
- Never run destructive or irreversible commands without asking first.
- Stay within {scope}. If the task pushes you outside it, stop and ask.
Completing the task while breaking a rule counts as FAILURE, not success.
Enter fullscreen mode Exit fullscreen mode

Why it works: the real bar for a production agent isn't "did it finish" β€” it's "did it finish without violating policy." That last line reframes success the way τ²-bench evaluations do β€” they score policy adherence as a first-class metric, not just task completion β€” and it's the difference between an agent you can trust unattended and one you can't.
When to use: any agent with real side effects β€” file writes, deploys, spend, customer contact.

10. The Tool-Discipline Prompt 

Prefer tools over memory. Before answering from what you "know," check whether a tool
(search, file read, code execution) can get ground truth β€” if so, use it. Don't call tools
you don't need. Before each call, state in one line which tool and why.
Enter fullscreen mode Exit fullscreen mode

Why it works: it improves tool selection and sequencing (the thing agents are still weakest at) and cuts confabulation by defaulting to verification. The one-line narration also makes the trace debuggable.
When to use: tool-using / MCP agents.

πŸ“š Job 5 β€” Ground It in Truth

11. The Grounded-Answer Prompt 

Answer ONLY from the sources below. Cite the specific source for each claim. If the answer
isn't in the sources, say "Not in the provided sources" β€” do not fall back on outside
knowledge.
---
{sources}
Enter fullscreen mode Exit fullscreen mode

Why it works: it makes answers auditable and refuses gracefully instead of inventing. This is the backbone of every reliable RAG agent I run.
When to use: RAG, document Q&A, policy/compliance lookups.

12. The Retrieve-or-Not Prompt 

First decide: does answering this actually need retrieval, or do you already know it
reliably? If retrieval helps, say what you'd search for and why. If not, answer directly and
say why retrieval was unnecessary.
Enter fullscreen mode Exit fullscreen mode

Why it works: knowing when not to retrieve is an underrated skill β€” needless retrieval adds latency, cost, and irrelevant context that makes answers worse. This prompt makes the decision explicit.
When to use: mixed workloads and when designing RAG agents.

🧬 Job 6 β€” Compound Your Leverage

13. The Capture-as-Skill Prompt 

That workflow worked. Capture it as a reusable SKILL.md: a sharp name, a one-line
description of exactly WHEN to trigger it, the steps we just took, and any commands as
literal code. Push edge cases into a reference section. Make it runnable by future-you
without me in the loop.
Enter fullscreen mode Exit fullscreen mode

Why it works: it turns a one-off success into a permanent capability. Do this consistently and your agent quietly gets better at your work every week β€” the compounding is the whole point.
When to use: right after any workflow you know you'll repeat.

14. The Eval-Writer Prompt 

From our real work this week, generate a 20-task eval set to compare models: each task =
an input, the expected behavior, and a pass/fail check. Cover the common cases plus the 3
hardest edge cases. Output as a table I can run.
Enter fullscreen mode Exit fullscreen mode

Why it works: public benchmarks are saturated and gamed. A 20-task eval built from your traffic will rank models differently than any leaderboard β€” and it's the only ranking that reflects your bill and your users.
When to use: choosing a model, or monitoring one after an upgrade.

15. The Blameless Postmortem Prompt 

Write a blameless postmortem for {incident}: timeline, root cause (do a 5-whys), what made
it hard to detect, blast radius, and 3 concrete, owner-assignable action items ranked by
leverage. No blame, no vagueness β€” every action item must be independently verifiable.
Enter fullscreen mode Exit fullscreen mode

Why it works: it's the manager's staple, and agents are genuinely good at it β€” they hold the whole timeline in context and don't get defensive. The "verifiable action items" clause stops it from producing feel-good mush.
When to use: after any incident, outage, or bad deploy.

The Other 85 (Raid the Shelf)

The gold 15 are the ones I use daily. Here's the rest of the rotation by category β€” titles only; the pattern is usually obvious from the name, and most are variations on the six jobs above.

Planning & scoping: "Ask me 5 questions before you start" Β· "Rank these approaches with trade-offs" Β· "Write the ADR for this decision" Β· "Estimate effort and risk per subtask" Β· "What's the smallest first slice that ships value?" Β· "List everything that could go wrong."

Debugging: "Form 3 hypotheses, then design the cheapest test to falsify each" Β· "Bisect this regression" Β· "Explain this stack trace in plain English, then fix" Β· "Add temporary logging, reproduce, remove logging" Β· "Diff the working vs broken environment."

Testing: "Write tests for the behavior, not the implementation" Β· "Generate edge cases I didn't think of" Β· "Add a property-based test" Β· "What's untested in this diff?" Β· "Turn this bug report into a test."

Refactoring & migration: "Rename safely across the repo" Β· "Extract this into a pure function with tests" Β· "Migrate one module as a template, then stop" Β· "Find and remove dead code (prove it's dead first)" Β· "Modernize this file to our current conventions."

Code review: "Review for correctness, security, and readability β€” separately" Β· "Is this diff backward-compatible?" Β· "Flag anything that needs a migration or a feature flag" Β· "Check error handling and edge cases only."

Docs & communication: "Write the PR description from the diff" Β· "Draft the changelog entry" Β· "Explain this system to a new hire in 200 words" Β· "Turn these notes into an exec summary" Β· "Write the runbook for this service."

Data, RAG & knowledge: "Chunk and summarize this doc for retrieval" Β· "Extract structured fields as JSON with a schema" Β· "Reconcile these two conflicting sources" Β· "Build a glossary from this corpus" Β· "Answer, then list what you're still missing."

DevOps & infra: "Explain this Terraform plan's blast radius before I apply" Β· "Write the rollback plan first" Β· "Right-size this resource from the metrics" Β· "Draft the alert and its runbook together" Β· "What's the single point of failure here?"

Agent orchestration: "Design a planner + N workers for this" Β· "When should this agent escalate to a human?" Β· "Write the system prompt for a {role} subagent" Β· "Add a verification step before the final answer" Β· "Define this agent's stop condition."

Research & analysis: "Steelman the opposing view" Β· "Give me the 3 numbers that would change my mind" Β· "Summarize, then give the one non-obvious insight" Β· "What would an expert critique about this analysis?" Β· "Find the assumption this whole plan rests on."

Meta & leverage: "Improve this prompt and explain what you changed" Β· "Turn this into a reusable template with {slots}" Β· "What context are you missing to do this well?" Β· "Critique my instructions before following them" Β· "Compress this prompt to half the tokens without losing meaning."

That's the ~100. Steal freely.

How I Actually Run These

  • In Claude Code / agent CLIs: the guardrail and convention prompts (#4, #9) live in a CLAUDE.md at the repo root β€” keep it under ~200 lines, because a tight set of real rules beats a long list that buries them (2026 guide). The Spec-First contract (#1) is just how I start every session.
  • As system prompts / roles: the verification and calibration prompts (#5, #7, #10) belong in the system layer so every turn inherits them.
  • As Skills / Routines: anything I run twice becomes a Skill (via #13) and then a scheduled Routine. That's how prompts stop being copy-paste and start being infrastructure.
  • Across a model fleet: the routing prompt (#2) tags work CHEAP vs JUDGMENT so I can send the bulk to a cheap or open model and reserve the frontier tier for the hard 10%.
  • Via MCP: the second-opinion prompt (#6) runs on a different model wired in over MCP, so a rival model adversarially reviews the primary's work.
  • Tune the effort knob instead of over-instructing. 2026 models expose a reasoning-effort dial (Claude's effort + adaptive thinking; OpenAI's reasoning_effort). Turn it up for reasoning, coding, and long-horizon loops; down for writing, summarization, and classification. It's cheaper and more reliable than padding a prompt with "think harder."

The Anti-Patterns (Why Most Prompts Get Cut)

The 70 prompts I deleted mostly failed the same ways:

  1. No definition of done. The agent optimized for "sounds finished" instead of "passes the check."
  2. Over-prompting. A 2,000-token instruction wall that blew the instruction budget and buried the one rule that mattered.
  3. Vague triggers. "Help me be productive" is not a task. Agents need a verb and an object.
  4. Forced confidence. No escape hatch to say "I don't know," so the model guessed β€” confidently, wrongly.
  5. No stop condition. The agent looped, wandered, or "improved" things nobody asked about until someone killed it.
  6. Over-eager trigger language (a 2026 trap). "CRITICAL: you MUST use this tool" now backfires on Opus 5-class models β€” it causes over-triggering and spurious subagents. Plain "use this tool when…" works better on modern models.
  7. Legacy over-verification. Old "always double-check everything, be exhaustive" instructions waste tokens and add latency on models that already self-verify by default. Delete them when you migrate; tune depth with the effort dial instead.

Fix those seven and an average prompt becomes a good one.

Final Take: Your Prompt Library Is a Product

A year ago, prompting was a party trick. In 2026, for anyone running agents in production, your prompt library is part of your infrastructure β€” versioned, tested, and pruned like code. The models got strong enough that the bottleneck moved: it's no longer "can the agent do it?" but "did I specify the contract well enough that I'd trust the result unattended?"

Start with the fifteen above. Put the guardrails in your CLAUDE.md, the verifiers in your system prompt, and the spec-first habit in your muscle memory. Capture your wins as Skills so the library compounds. And delete ruthlessly β€” the best prompt library isn't the biggest one, it's the one where every prompt earns its place.

The agents are ready. The leverage is in how well you brief them.

About the Author

Suraj Khaitan β€” Senior Agentic AI Manager | Building and scaling production agentic systems on the cloud

Connect on LinkedIn | Follow for more engineering and architecture write-ups

Which prompt is load-bearing in your daily agent work? Drop it in the comments β€” I retire one from my rotation every month and I'm always hunting for the replacement.

Sources & further reading: Primary β€” Anthropic: Effective context engineering for AI agents Β· Anthropic: Building effective agents Β· Anthropic: How we built our multi-agent research system Β· Anthropic: Writing effective tools for AI agents Β· Claude docs: prompting best practices Β· OpenAI: GPT-5 prompting guide Β· Google: Gemini prompt design strategies. Patterns & benchmarks β€” ReAct Β· Reflexion Β· Chain-of-Verification Β· τ²-bench (policy adherence) Β· Why multi-agent systems fail (MAST) Β· Artificial Analysis leaderboard. Model standings reflect figures as of late July 2026 and are effort/harness-dependent. A few practitioner figures (instruction budgets, hallucination-reduction %, self-critique catch rates) are reported heuristics, not lab-verified β€” treat as directional.

Top comments (0)