Ready-made AI prompts

Turn a rough outline into a full draft that keeps your structure and does not pad.

Tighten prose while keeping the author's voice and every factual claim intact.

A summary that separates what the source says from what it implies.

Blog posts written by AI tend toward the statistically average article on the topic — technically correct, entirely forgettable. Beating that means supplying an angle and an audience that the model could not have guessed.

Newsletters live or die on sounding like a person. Models default to a broadcast register — "In this issue we will explore" — which is exactly the voice subscribers unsubscribe from.

Thank you notes are short, which makes every generic sentence proportionally more damaging. A note that could have been sent to anyone reads as an obligation discharged rather than gratitude expressed.

A wedding speech is performed aloud to a room containing everyone the couple knows, which rules out most of the material that would actually be funny. The genuine constraint is safety, and it is the one people misjudge.

A complete session with encounters balanced to your party, and no railroading.

A mechanic with its failure modes and degenerate strategies identified up front.

A character with a consistent voice and dialogue that reacts to what the player did.

Encounter design fails on maths and on assumption. Generated encounters are routinely mis-balanced for the party level, and they assume players will fight — which is the one thing a real table reliably does not do.

Campaign hooks fail by requiring the party to care about something abstract. A hook only works if it threatens or promises something a specific character already wants, which means it cannot be written before the characters exist.

Findings with a triggering input, ranked by severity — and permission to find nothing.

Ranked hypotheses with a test for each, instead of one confident guess.

Tests derived from requirements rather than from the implementation, so they can fail.

A walkthrough pitched at your actual level, with the non-obvious decisions called out.

A query with its assumptions stated, so you can check them before running it.

Asked to review, a model will always find something — so a clean file produces invented nitpicks. Requiring a triggering input for every finding is the filter that separates real bugs from plausible-sounding speculation.

Debugging prompts fail when they lead with a theory, because the model confirms it. They also fail by producing one confident cause when the honest output is a ranked list of hypotheses with tests attached.

Tests generated alongside an implementation assert whatever that implementation does, bugs included. Deriving them from the specification instead is what makes a test capable of failing, which is the only property that matters.

Refactoring means changing structure without changing behaviour, and models routinely do both while describing only the first. The behaviour-identical constraint has to be stated explicitly or improvements smuggle in bug fixes.

Most wrong SQL is correct code applied to a wrong assumption about the data. The second failure is invented column names, which look right and fail at runtime rather than at review.

Regular expressions are write-only: they look plausible and fail on cases nobody tested. Supplying explicit should-match and should-not-match examples turns an unverifiable string into something checkable.

Most generated Dockerfiles work and are wrong in the same three ways: a single stage that ships the whole toolchain, a `latest` base tag that breaks silently months later, and everything running as root.

API documentation fails on the error cases. The happy path is easy to describe and rarely what someone is reading the docs for — they are there because something returned a 422 and they do not know why.

One specific reason to reply, one ask, and no invented claims about your product.

Hero, benefits and CTA built from what your product actually does.

Specifications turned into copy without inventing a single feature.

Cold email fails in the first two lines or not at all. The hard constraint is honesty: models invent customer counts and case studies to fill a persuasion-shaped gap, and an invented claim in an outbound email is a real liability.

A press release is read by someone deciding in ten seconds whether it is news. The inverted pyramid is not stylistic preference — burying the hook below a paragraph of company background guarantees it is deleted.

Case studies are read by sceptical people, so a fabricated statistic or an invented quote destroys the whole document. The other failure is leading with the product, which loses the reader before the relevant part.

Sequences are written as a story the sender knows and the reader does not, because most people only ever see two of the emails. Each one has to stand alone, which is the opposite of how sequences are usually drafted.

LinkedIn truncates after roughly two lines, so a post that buries its point in paragraph two is a post nobody reads. The banned phrases matter more here than anywhere: the platform has a house style that reads as insincere.

Separates what was decided from what was discussed, and flags what was left open.

Bad news delivered clearly, without padding that obscures what is happening.

A comparison that states the trade-off and names the strongest case against your choice.

Agendas fail by being lists of topics rather than a plan for reaching decisions. Without a time box and a stated purpose per item, the first topic expands to fill the hour and the decision never happens.

Reviews go wrong when feedback is about personality rather than behaviour, because personality feedback cannot be acted on. The banned phrases here are the classic examples: unfalsifiable, and impossible to improve against.

Job descriptions are written to filter and read as warnings. Long requirement lists deter the strong candidates who self-assess honestly and are ignored by everyone else, which inverts the intended filter.

Apologies fail through the passive voice and the conditional. "I am sorry if this caused inconvenience" is not an apology, and readers recognise the construction immediately — it makes the situation worse than saying nothing.

An SOP written by someone who knows the process skips the steps they do experience as automatic. The test is not whether it is complete to you — it is whether someone who has never done it could follow it alone.

Applications are scored against published criteria by someone working through a checklist. Writing beautifully about your mission while never explicitly addressing criterion three loses points that no amount of eloquence recovers.

Achievement-shaped bullets built only from things you actually did.

STAR answers built from what you actually did, with the follow-ups you will be asked.

Cover letters fail by being interchangeable — the same three paragraphs would work for any employer, which tells the reader nothing. The hard part is being specific about this company without flattery.

A resignation letter is a permanent record read by people you may need a reference from. The temptation is to explain, and explanation is exactly what turns a routine document into something quoted back at you.

Personal statements are read in batches of hundreds, so the opening line is doing almost all the work. The trap is writing about the subject rather than about what you actually did with it.

LinkedIn truncates the About section after two lines, and most people spend those two lines on a job title the reader can already see. The second problem is the third-person voice, which reads as a press release about yourself.

An explanation pitched at one specific level, with one analogy carried throughout.

A timed plan with differentiation and a fallback for when it runs short.

Cards that test recall rather than recognition, with no ambiguous answers.

Explanations fail by being pitched at nobody in particular, and by switching analogies halfway through. The second is subtle: each metaphor is fine alone, and together they leave the reader with two incompatible models.

Multiple-choice questions are easy to write badly: the correct answer is often the longest option, and the distractors are obviously wrong. Good distractors come from real misconceptions, which is why they have to be supplied.

Study plans fail by allocating equal time to every topic and scheduling reading rather than retrieval. They also assume perfect adherence, so one bad week destroys the whole schedule.

A descriptor stack in slot order, with a negative prompt covering the usual artefacts.

A character brief specific enough to be reproducible across a set of images.

Image models cannot render reliable text, so a logo prompt that asks for a wordmark produces garbled letterforms. The workable approach is generating a mark and setting the type separately in a vector tool.

Generated product shots are unusable commercially if the product is not exactly your product — the model will subtly redesign it. They work for mood, lighting and composition references rather than final imagery.

YouTube retention is decided in the first fifteen seconds, and a channel introduction spends all of them. Scripts also have to be written for speech, which is a different register from prose and the one models default away from.

The failure mode is asking a well-known guest the questions they have answered a hundred times, which produces their rehearsed answers. Getting something new requires knowing what has already been covered.

Titles and thumbnails compete in a feed, which pushes everyone toward overclaiming — and a title that overdelivers on the promise tanks retention, which hurts more than the extra clicks help.

JSON that parses, with nulls where the source is silent instead of invented values.

Categorisation you can audit, with an explicit "unclear" option instead of forced guesses.

The formula, what each part does, and what breaks it.

The dangerous failure is not malformed JSON — that fails loudly. It is a field the source never mentioned, filled with a plausible invention, which parses cleanly and travels downstream unnoticed.

Without an explicit "unclear" option, every ambiguous item gets forced into a category and the error becomes invisible in the output. The boundary cases are where all the disagreement lives, and they need somewhere to go.

Spreadsheet formulas fail silently. A wrong result looks like a number rather than an error, so the useful output is not just the formula but the list of conditions under which it quietly stops being right.

Separates established fact from contested claim, and admits what it cannot verify.

Summarisation systematically strips uncertainty: "may be associated with" becomes "is linked to", and a tentative finding becomes a fact. The distortion is invisible unless you compare against the source.

Research is where fabricated citations do the most damage, because a plausible-looking reference is repeated before anyone checks it. The other failure is presenting a contested claim as settled.

Competitor analysis is where fabrication is most tempting and least visible: pricing, headcount and feature lists all sound checkable and are frequently invented. The second failure is a feature grid that answers no actual decision.

User stories fail when the "so that" clause restates the goal — "so that I can log in" adds nothing — and when only the happy path is specified, leaving every error state to be discovered in QA.

Personas usually collect demographic detail that changes no decision — a name, an age, a favourite coffee — while omitting the goals and constraints that would. If two personas imply the same product choice, they are one persona.

Release notes are skimmed for one thing: does this break me? Burying a breaking change under six feature bullets is the failure mode, and it costs the reader more than the notes saved.

Error messages get written last, by whoever implemented the error path, in the voice of the system rather than the user. The result states what failed internally and not what the person should now do.

Tool rules, failure handling and stop conditions — the parts agent prompts usually omit.

A RAG prompt that says "not in the documents" instead of filling the gap.

A judge prompt with binary criteria, so scores are repeatable rather than impressionistic.

System prompts fail two ways: rules stated as preferences get overridden by a persistent user, and no fallback means the bot invents an answer when it does not know. Both surface only in production.

Generated itineraries pack in far more than a day holds and quietly assume a car. Opening hours and seasonal closures are also the sort of specific fact models get confidently wrong.

Meal plans fail on waste and on hidden ingredients. Seven unrelated recipes mean seven part-used jars, and dietary restrictions get violated by things like fish sauce in a "vegetarian" curry.

The hard part is the opening sentence and the first objection, which is where most preparation stops. Scripting the whole conversation also backfires — the other person has not read it, and a rehearsed reply to something they did not say is worse than none.

Generated training plans tend to prescribe an intermediate volume regardless of stated fitness, and to ignore equipment constraints. The important failure is programming around an injury the plan was told about.