Techniques prompts

Help me get better reasoning on this task.

THE TASK: [WHAT YOU ARE ASKING FOR]
MY PROMPT:
"""
[PASTE]
"""
WHAT GOES WRONG: [wrong answers / plausible but incorrect / inconsistent / skips steps]
MODEL: [WHICH - and whether it is a reasoning model]
DOES THE ANSWER HAVE A CORRECT VALUE: [yes / it is a judgement]

Produce:

1. WHETHER THIS TASK NEEDS EXPLICIT REASONING - it helps for multi-step problems, arithmetic, logic, planning, and anything where a conclusion depends on intermediate results. It adds little for retrieval, summarisation, formatting, or creative work, and it lengthens the output for no benefit. Say which mine is.

2. THE MODEL QUESTION - newer reasoning models do this internally and instructing them to think step by step can be redundant or counterproductive. Say what applies to my stated model, and note that this changes as models change, so it is worth testing rather than assuming.

3. THE STRUCTURED REASONING PROMPT - rather than a generic instruction to think step by step, specify the steps this particular task requires. Naming the actual reasoning procedure works considerably better than a general instruction. Write the steps for my task.

4. THE ORDER REQUIREMENT - the reasoning must come before the answer. A model that states a conclusion and then justifies it produces justification, not reasoning. State explicitly that the working comes first.

5. THE SEPARATION - reasoning in a clearly delimited section, the answer in another, so the answer can be extracted if it feeds into something else.

6. THE VERIFICATION STEP - asking the model to check its own answer against the question and the working. This catches a meaningful proportion of errors and costs little.

7. THE ALTERNATIVE ANSWER CHECK - for tasks with a correct value, asking what other answer someone might arrive at and why it is wrong. This surfaces errors that a single pass misses.

8. THE ARITHMETIC WARNING - models make calculation errors even with good reasoning. For anything numerical, the reasoning should show the arithmetic so it can be checked, and important calculations should be verified independently or done in code.

9. THE MULTIPLE ATTEMPTS APPROACH - for important tasks with a correct answer, running it several times and comparing. Agreement across runs is weak evidence of correctness; disagreement is strong evidence of a problem.

10. THE REWRITTEN PROMPT.

11. THE HONEST LIMIT - explicit reasoning improves accuracy and does not guarantee it. Confident, well-structured reasoning to a wrong answer is entirely possible, and for anything consequential the answer needs checking rather than trusting.

Help me decide whether to use a role in this prompt.

THE TASK: [WHAT YOU WANT]
MY CURRENT PROMPT:
"""
[PASTE]
"""
THE ROLE I WAS CONSIDERING: [e.g. 'you are an expert marketer']
WHAT I AM TRYING TO CHANGE: [the depth / the vocabulary / the priorities / the tone]

Produce:

1. WHAT A ROLE ACTUALLY DOES - it shifts vocabulary, assumed conventions, what the model treats as important, and the depth of domain detail. It does not make the model more capable or more accurate. 'You are a world-class expert' adds nothing; 'you are reviewing this as a compliance officer would' changes what gets attended to.

2. WHETHER IT HELPS HERE - roles are useful when:
   - The task has professional conventions the role implies
   - You want a particular perspective applied, especially a critical or adversarial one
   - The vocabulary and level of detail should match a field
   They are decorative when they just assert expertise.
   Say which applies to my task.

3. THE ROLE, SPECIFIED PROPERLY - if it helps, written so it carries information: what the role is, what they are doing in this situation, what they care about, and what they would notice. A role with a job description does work; a role that is a title does not.

4. THE ALTERNATIVE - what the role was meant to achieve, stated directly instead. If I want more technical depth, asking for more technical depth is more reliable than implying it through a job title. Frequently this is the better option, and it is shorter.

5. THE PERSPECTIVE ROLE - the most genuinely useful kind: asking the model to evaluate something as a specific stakeholder would. A sceptical reviewer, a customer, an auditor, someone who disagrees. This produces different output in a way that generic expertise claims do not.

6. THE AUDIENCE ROLE - often more useful than an author role. Specifying who the output is for shapes it more reliably than specifying who is writing it.

7. WHAT NOT TO DO - stacking roles, claiming implausible credentials, and expecting a role to override the task specification. Also: roles do not change what the model knows.

8. THE COMBINATION - a role plus explicit instructions, where the role sets the frame and the instructions do the specifying. Neither alone is usually enough.

9. THE REWRITTEN PROMPT - with or without a role, whichever is better for my task.

10. THE TEST - run it with and without. Roles are cheap but not free, and if the output is the same, remove it.

Help me set up a self-critique step.

THE TASK: [WHAT THE FIRST PASS PRODUCES]
THE FIRST-PASS PROMPT:
"""
[PASTE]
"""
WHAT IS USUALLY WRONG WITH THE OUTPUT: [THE RECURRING WEAKNESSES]
WHAT GOOD LOOKS LIKE: [YOUR STANDARD]

Produce:

1. WHETHER THIS HELPS - self-critique improves output when there are specific, checkable criteria to check against. It does little when the instruction is a generic 'review and improve', which typically produces superficial changes and sometimes makes things worse by adding hedging and padding.

2. THE CRITERIA - the specific things to check, derived from my stated weaknesses and standard. This is the whole technique: critique against named criteria, not against a general sense of quality. Write them as checkable questions.

3. THE CRITIQUE PROMPT - a separate pass that:
   - Takes the first output as input
   - Checks it against each criterion explicitly, one at a time
   - States what fails and why, with the specific passage quoted
   - Does not rewrite yet
   Separating diagnosis from revision produces better revision, because a combined instruction tends to produce light editing rather than real assessment.

4. THE REVISION PROMPT - a third pass that takes the original and the critique and produces the revision, addressing each identified issue.

5. THE ADVERSARIAL FRAMING - critique is more useful when framed as finding problems rather than reviewing. 'Identify the three weakest points' produces more than 'review this'. Models default to agreement unless pushed.

6. THE SPECIFIC WEAKNESSES - I said what usually goes wrong. Write a criterion targeting each directly, since those are the failures worth catching.

7. THE OVER-REVISION WARNING - repeated self-critique tends toward blandness: hedged claims, removed specifics, and added qualifications. One critique pass is usually right; three is usually worse than none. Say what to watch for.

8. THE WHAT-NOT-TO-CHANGE INSTRUCTION - protecting the good parts. Revision passes frequently rewrite things that were fine, so state what to preserve.

9. THE SINGLE-PROMPT VERSION - if separate passes are impractical, how to structure one prompt that produces, critiques and revises, with the caveat that it is less effective because the model has committed to its first answer.

10. THE HONEST LIMIT - a model critiquing its own output shares its own blind spots. It catches format issues, omissions against stated criteria, and internal inconsistency. It does not reliably catch factual errors or a fundamentally wrong approach. Say what still needs a human.

Help me break this task into steps.

THE TASK: [WHAT YOU WANT TO ACHIEVE]
MY CURRENT APPROACH: [PASTE YOUR PROMPT, or describe what you have tried]
WHAT GOES WRONG: [output is shallow / misses parts / too long / inconsistent / loses track]
HOW OFTEN I DO THIS: [one-off / repeatedly]

Produce:

1. WHY ONE PROMPT IS FAILING - complex tasks fail in one prompt for identifiable reasons:
   - Too many requirements, so some are dropped
   - Later parts depend on decisions made earlier, which the model makes implicitly and inconsistently
   - The output length required exceeds what stays coherent
   - Different parts need different kinds of thinking
   Say which applies.

2. THE DECOMPOSITION - the task split into steps, each producing a defined output that feeds the next. For each: what it takes in, what it produces, and why it is separate.

3. THE SEAM QUALITY - good splits happen where little information needs to pass between steps. A split requiring the next step to receive everything from the previous one is not really a split. Say where the natural boundaries are.

4. THE INTERMEDIATE OUTPUTS - what each step produces, specified precisely enough that the next step can consume it. Vague intermediate outputs are where these pipelines break.

5. THE REVIEW POINTS - which steps produce something worth checking before continuing. A wrong decision at step one propagates through everything after it, and catching it early is the main benefit of decomposition.

6. THE PROMPTS - written for each step.

7. THE STATE PROBLEM - what each step needs to know from earlier steps. Either pass it explicitly or accept the loss. This is the most common failure in multi-step approaches: assuming the model remembers something it was not given.

8. THE PARALLEL OPPORTUNITY - steps that do not depend on each other and could be done independently, then combined.

9. WHEN NOT TO DECOMPOSE - splitting has costs: more steps to run, more places to go wrong, and loss of the coherence that comes from producing something in one pass. For creative and narrative work in particular, decomposition often produces something disjointed. Say if that risk applies here.

10. THE SINGLE-PROMPT ALTERNATIVE - if the task should stay in one prompt, what to change instead: a clearer structure, fewer requirements, or a specified output shape.

11. IF I DO THIS REPEATEDLY - how to make the pipeline reusable, and where the output of one step should be reviewed by a person rather than passed on automatically.

Help me get more varied output from this prompt.

MY PROMPT:
"""
[PASTE]
"""
WHAT I KEEP GETTING: [DESCRIBE THE PREDICTABLE OUTPUT]
WHAT I AM LOOKING FOR: [THE KIND OF VARIETY YOU WANT]
WHAT I HAVE ALREADY REJECTED: [IDEAS YOU HAVE SEEN AND DO NOT WANT]

Produce:

1. WHY OUTPUT IS PREDICTABLE - models produce likely responses, and the most likely response to a generic request is the conventional one. Variety has to be asked for structurally, not by requesting creativity.

2. THE EXCLUSION TECHNIQUE - listing what I have already rejected and asking for options that are not those. This is the most effective single move, because it removes the obvious answers from consideration. Write the exclusion block from what I said.

3. THE CONSTRAINT TECHNIQUE - adding an arbitrary constraint forces a different route. 'Without using X', 'from the perspective of Y', 'assuming Z is impossible'. Constraints produce more variety than instructions to be creative. Suggest three that suit my task.

4. THE DIMENSION SPECIFICATION - asking for options that vary along named dimensions rather than just asking for several. 'Give me five ideas' produces five similar ideas; 'give me one that is cheap, one that is fast, one that would be controversial, one that assumes no budget, and one that solves a different problem' produces genuine range.

5. THE QUANTITY APPROACH - asking for twenty and expecting the first eight to be conventional. The interesting ones appear after the obvious ones are exhausted. Say whether this suits my task.

6. THE PERSPECTIVE SHIFT - asking from different stakeholders' points of view, different eras, different fields, or different constraints. Cross-domain framing is a reliable source of non-obvious options.

7. THE INVERSION - asking how to make the problem worse, or what the worst approach would be. Inverting frequently surfaces options that direct questioning does not.

8. THE TEMPERATURE NOTE - if I have access to the setting, higher values produce more variety at some cost to coherence. Say whether it applies and what to try.

9. THE REWRITTEN PROMPT - combining the techniques that suit my task.

10. THE EVALUATION SEPARATION - generate first, judge later. Asking for good ideas produces conventional ones, because conventionality is what 'good' converges on. Ask for many, then evaluate in a separate pass.

11. THE HONEST NOTE - genuinely novel ideas are rare from any source. What this produces is a wider range to choose from, which is usually what is actually needed.

Help me set up a prompt that asks me questions before answering.

THE TASK: [WHAT YOU WANT PRODUCED]
WHY THIS KEEPS GOING WRONG: [THE PROBLEM - usually that the output misses context you did not think to give]
HOW MUCH I KNOW ABOUT THIS TASK: [expert / some knowledge / not much]
HOW MANY ROUNDS I AM WILLING TO DO: [one round of questions / a conversation]

Produce:

1. WHEN THIS HELPS - asking for clarification first is valuable when: the task depends on context only I have, when the cost of producing the wrong thing is high, or when I do not know what information is relevant. It is unnecessary overhead for simple, well-specified tasks.

2. THE INSTRUCTION - written so the model actually asks rather than asking and then answering anyway, which is the usual failure. It must be told explicitly to stop after the questions and wait.

3. THE QUESTION LIMIT - how many. Too few and it does not help; too many and it becomes an interrogation that I abandon. Five to seven is usually right for one round. Specify it.

4. THE QUESTION QUALITY INSTRUCTION - the questions should be the ones whose answers would most change the output, not a generic information-gathering list. Instruct it to ask only questions where different answers would lead to materially different work, and to say why each matters.

5. THE DEFAULT OFFER - for each question, the model should state the assumption it would make if I do not answer. This is the most useful element: it lets me answer only the ones where the default is wrong, which makes the process fast rather than tedious.

6. THE KNOWLEDGE CALIBRATION - if I said I do not know much about this task, the questions should be answerable by someone in my position. Questions that assume expertise I do not have are useless.

7. THE PROMPT - written out.

8. THE CONVERSATION VERSION - if I said I will do more than one round, how to structure it so each round narrows rather than starting again.

9. THE ANTI-PATTERN - models often ask questions and then answer the task in the same response using their own assumptions. If that happens, the instruction needs strengthening, and the specific wording that prevents it.

10. THE ALTERNATIVE - sometimes it is faster for the model to produce a draft with its assumptions stated explicitly, so I can correct the wrong ones. Say which approach suits my task better, since for many tasks a flagged draft beats a question round.

Help me define what good output looks like for this task.

THE TASK: [WHAT YOU WANT]
MY PROMPT:
"""
[PASTE]
"""
WHAT MAKES OUTPUT GOOD OR BAD FOR THIS: [YOUR SENSE OF IT, however vague]
EXAMPLES OF GOOD AND BAD: [PASTE, if you have any]
WHO JUDGES THE OUTPUT: [me / a client / an audience / a system]

Produce:

1. THE QUALITY DIMENSIONS - break my vague sense of good into separate, nameable qualities. Most tasks have three to five. Typically some of: correctness, completeness, relevance, structure, tone, specificity, and usability. Identify mine.

2. THE CHECKABLE VERSION - each dimension rewritten as something that can be verified by looking at the output. 'Well written' cannot be checked; 'every claim is followed by a specific example or figure' can. This translation is the whole exercise.

3. THE RUBRIC - written as a block to include in the prompt, stating what a good response contains. Giving the model the criteria before it writes is substantially more effective than judging afterwards, and it costs a few lines.

4. THE FAILURE DESCRIPTIONS - for each dimension, what a poor response looks like. Describing the failure mode is often more useful than describing success, because it names the specific thing to avoid.

5. THE EXAMPLES, ANALYSED - if I provided good and bad examples, what specifically distinguishes them. Frequently the difference is not what I would have said it was, and identifying it correctly is what makes the rubric accurate.

6. THE PRIORITY - which dimensions matter most, so the model knows what to sacrifice when they conflict. A rubric with five equal criteria gives no guidance when brevity and completeness pull apart.

7. THE PROMPT WITH THE RUBRIC - assembled, with the rubric placed where it works: after the task and before the output, as the standard to write to.

8. THE SELF-CHECK INSTRUCTION - asking the model to verify its output against the rubric before finishing. Cheap and effective, particularly for completeness.

9. THE EVALUATION USE - the same rubric used to assess output afterwards, either by me or in a separate pass. A rubric that serves both generation and evaluation is worth building properly.

10. THE JUDGE QUESTION - I said who judges the output. If it is not me, the rubric should reflect their criteria rather than mine. Say where those might differ.

11. THE RUBRIC'S OWN LIMIT - a rubric produces output that satisfies the named criteria, which is not identical to good. Say what my rubric does not capture, so I know what still needs judgement.