Prompting cheat sheet

When writing reports, explanations, or analyses, write in clear flowing prose
using complete paragraphs. Reserve markdown for inline code, code blocks, and
simple headings. Do not use ordered or unordered lists unless you're presenting
truly discrete items or I explicitly ask for one. Incorporate items naturally
into sentences instead.

Format your response in plain text only. Do not use LaTeX, MathJax, or markup
such as \( \), $, or \frac{}{}. Write math using standard text characters.

1. "Write X."
2. "Review the draft against these criteria: [...]. List every problem.
    Do not rewrite anything."
3. "Now rewrite, addressing every problem you listed."
4. (optional) "Now argue the revision is still wrong. Take the position of a
    hostile reviewer who wants to reject it."

Before you start, ask me up to five questions whose answers would materially
change your response. Don't ask questions you can answer from what I've given you.

Give me three genuinely different approaches. They must differ in kind, not
degree. For each: the approach, what it optimises for, what it sacrifices, and
who it's wrong for. Then recommend one and say what would change your
recommendation.

Step 1: Write a rubric for what makes an excellent [thing]. Five criteria, each
with a concrete test.
Step 2: Now write the [thing], optimising for that rubric.
Step 3: Score your output against it. Where below 4/5, revise.

1. Extract every passage relevant to the question into <quotes> tags with locations.
2. Answer using only those quotes, in <answer> tags.
3. If the quotes are insufficient, say what's missing rather than filling the gap.

Analyse from four perspectives, each in its own section: a CFO focused on
payback and downside risk; a senior engineer who'll maintain it; a customer who
uses it; a competitor who wants us to make a mistake. Then synthesise: where do
they agree, where do they conflict, what would resolve the conflicts?

By default, implement changes rather than only suggesting them. If my intent is
unclear, infer the most useful likely action and proceed, using tools to
discover missing details instead of guessing.

Do not jump into implementation or change files unless clearly instructed. When
my intent is ambiguous, default to information, research, and recommendations.

Consider the reversibility and potential impact of your actions. Take local,
reversible actions freely, but for actions that are hard to reverse, affect
shared systems, or could be destructive, ask before proceeding.

Warrants confirmation: deleting files or branches, dropping tables, rm -rf,
git push --force, git reset --hard, amending published commits, pushing code,
commenting on PRs, sending messages, modifying shared infrastructure.

When you hit an obstacle, don't use destructive actions as a shortcut. Don't
bypass safety checks (e.g. --no-verify) or discard unfamiliar files.

Only make changes that are directly requested or clearly necessary.
Scope: don't add features, refactor, or make improvements beyond what was asked.
Documentation: don't add docstrings or comments to code you didn't change.
Defensive coding: don't add error handling for scenarios that can't happen.
Only validate at system boundaries.
Abstractions: don't create helpers for one-time operations. Don't design for
hypothetical future requirements.

Write a high-quality, general-purpose solution. Don't hard-code values or write
solutions that only work for the test cases. Tests verify correctness; they
don't define the solution. If a test is wrong, tell me rather than working
around it.

Never speculate about code you have not opened. If I reference a specific file,
read it before answering. Investigate relevant files BEFORE answering questions
about the codebase.

If you create temporary files or scripts for iteration, remove them at the end.

If you intend to call multiple tools and there are no dependencies between them,
make all independent calls in parallel. When reading 3 files, run 3 tool calls
at once. If some calls depend on previous ones for their parameters, call those
sequentially. Never use placeholders or guess missing parameters.

Execute operations sequentially with brief pauses between each step.

Thinking adds latency and should only be used when it will meaningfully improve
answer quality — typically for problems requiring multistep reasoning. When in
doubt, respond directly.

After receiving tool results, carefully reflect on their quality and determine
optimal next steps before proceeding.

When deciding how to approach a problem, choose an approach and commit to it.
Avoid revisiting decisions unless you encounter new information that directly
contradicts your reasoning.

This is a long task. Plan your work clearly.
Keep state in files: tests.json for structured status, progress.txt for notes.
Use git commits as checkpoints.
Focus on incremental progress. Before running low on context, save your progress
and state so a fresh session can continue.
It's encouraged to spend your entire output context on the task — just don't run
out with significant uncommitted work.

Run pwd. Review progress.txt, tests.json, and the git log. Run the integration
test manually before implementing anything new.

Your context window will be automatically compacted as it approaches its limit,
allowing you to continue working indefinitely from where you left off. Do not
stop tasks early due to token budget concerns. As you approach the limit, save
your progress and state before the context refreshes. Never artificially stop a
task early regardless of remaining context.

Use subagents when tasks can run in parallel, require isolated context, or
involve independent workstreams that don't need to share state. For simple
tasks, sequential operations, single-file edits, or tasks needing context
continuity, work directly rather than delegating.

Typography: choose beautiful, distinctive fonts. Avoid Inter, Roboto, Arial,
system fonts.
Colour: commit to a cohesive aesthetic. Use CSS variables. Dominant colours with
sharp accents beat timid even palettes. Avoid purple gradients on white.
Motion: high-impact moments. One well-orchestrated page load with staggered
reveals beats scattered micro-interactions.
Backgrounds: create atmosphere and depth. Layer gradients, patterns, contextual
effects.
Make unexpected choices that feel designed for this specific context.