Frontier prompter

Frontier Prompter

Rewrites a raw prompt / task / goal into a prompt aimed at your frontier/premium model (the strongest, most autonomous model you have on hand) or any top-tier autonomous agent. The rewrite is not cosmetic — it restructures the ask so a very capable model steers correctly on a short instruction, commits instead of dithering, and proves its work.

The core idea

Strong models don't need a rulebook; they need intent, the outcome, the context to reach it, and a few guardrails at the exact spots they'd otherwise go wrong. Over-specifying steps or piling on "don't"s actively hurts: a strong model in a well-tooled environment steers on a short outcome statement as well as on an enumerated rulebook, and negation aimed at writing style backfires because the attention mechanism fixates on the concept you forbid. So format lean and outcome-first, and spend the "don'ts" only where they earn their place.

How to format a prompt (work through in order; drop any that don't apply)

1. Lead with intent — the why. One or two sentences on why this task exists and the outcome it serves. Given the intent, a strong model connects the task to the right context instead of guessing what you meant. Put this first, before the role.
2. Assign a lean role + the single outcome. Name what the model is and the one outcome that defines success — e.g. "lead with the outcome, keep it lean, pause only when the work genuinely needs the human." Resist a numbered behavior rulebook; it competes with the outcome for attention.
3. Order the context: read-first. If there are files/inputs, list them in the order they should be read, one line of why each matters. Tell the model to gather only what it needs to act, then commit — not to research everything first.
4. Say what good looks like (positive framing). State the quality bar as things to DO ("every item names the artifact it ships or the dollar it moves"), never as things to avoid. Positive targets are what the model aims at; "don't be verbose" just makes it think about verbosity.
5. Match effort to the work. If the task has a few capability-sensitive parts and a lot of routine ones, say which get top-tier effort and why, and push the rest to cheaper tiers. Naming the why models good effort-matching and stops the expensive tier being burned on routine work.
6. Add the anticipated-failure guardrails (light, rationalized negation). This is where negation earns its place. Ask: given this specific task, where would a capable model's analysis most plausibly go off track? Then write a SMALL set (aim 2-5) of "Do not X — because Y" guardrails aimed only at those spots. Every one is action-gating (premature action, scope drift, re-deriving what's already settled, fabricating what it can't verify) and carries its reason. Do NOT convert style/quality wishes into "don't"s — those belong in step 4 as positive targets.
7. Close with prove-it verification. Give a falsifiable finish line: the model points to the evidence (file / result) behind each claim or decision, reports only what it can show, and says plainly when something is unverified rather than guessing. Embed this in the verification criteria — not as a trailing afterthought.

Output shape

Emit the formatted prompt as a clean, copyable block. Default skeleton (adapt to the task — not every task needs every section):

Intent (why this exists): <1-2 lines>

You are <lean role>. <the one outcome that defines success>. Lead with the outcome,
keep it lean, and pause only when the work genuinely needs the human.

Read first (in order): <file — why> · <file — why> ...
Gather only what you need to act, then commit — don't research everything first.

What good looks like: <positive quality targets>

Effort: top tier for <X> and <Y> because <capability-sensitive reason>; everything
else on <cheaper tier / local / human>.

Guardrails (2-5 max, action-gating only, each with its reason):
- Do not <premature or out-of-scope action> — because <reason>.

Verification (prove it): point to the evidence behind each claim/decision; report only
what you can show; if something is unverified, say so plainly instead of guessing.

The negative-prompting rule (keep it, or the skill drifts back to a wall of don'ts)

• Negation is a scalpel for action-gating and anticipated failure points — "do not fix/send/publish until told," "do not re-research what's decided," "do not fabricate a source." These sharply reduce premature-action and over-reach failures (in the cited research, action-gating negation lifted a bug-detection task from 39% to 89%).
• Negation is a footgun for writing-style/quality — "don't be verbose / vague / generic" makes the model dwell on exactly that. Reframe every such wish as a positive target (step 4).
• Keep the do-not list short and rationalized. A wall of don'ts reads as distrust, competes with the outcome for attention, and past ~150-200 instructions degrades the whole prompt. Two to five load-bearing guardrails beat twenty.

Effort tiers (reference)

A top-tier model typically runs a few times the cost of the mid tier, and the strongest models keep their extended thinking on by default. Default high; reserve extra-high for genuinely capability-sensitive multi-stage synthesis; medium/low for routine work. Naming which parts are capability-sensitive (and why) is itself a signal the executor uses to match effort.

Example

Input (raw): "Have the model go through my research folder and make a plan to ship my content and money stuff."

Output (formatted):

Intent (why this exists): the strategy is already settled in the research folder; the
recurring failure mode is planning-rich / ship-poor. This session commits to decisions
and produces a lean plan that SHIPS — not more research or documentation.

You are the planner for this initiative. Success = a lean, ship-biased execution plan
where every item moves a real artifact or a dollar. Lead with the outcome, keep it lean,
pause only when the work genuinely needs the human.

Read first (in order): research/00-brief.md (the decision agenda + candidate initiatives —
your contract) · the spine plan (scope + guardrails) · the allocation brief (what gets top
tier). Gather only what you need to decide, then commit.

What good looks like: >=70% of effort on ship tasks; each Status-Board item names its
artifact or dollar; decisions recorded once, not re-litigated.

Effort: top tier for the deep synthesis artifacts (correctness is proof-of-work; honesty
under autonomy matters); everything else on the cheaper tier / local / you.

Guardrails:
- Do not re-research the briefs — because the strategy is settled and re-deriving it repeats
  the exact planning-over-shipping failure this exists to break.
- Do not write a plan-for-the-plan — because the window is for artifacts, not meta.
- Do not let infra/planning items outnumber ship items — because that IS the failure mode;
  if they do, reject the draft and re-weight toward shipping.

Verification (prove it): every decision cites the research finding that justifies it; report
only what you can show; flag any unverified assumption plainly.

The Example above is a full worked hand-off that applies every step in this skill — read it as the concrete model to pattern-match your own prompt against.

Before you hand the prompt back

Quick self-check: Does it open with intent? Is the outcome stated once and clearly? Is the quality bar phrased positively? Are there at most a handful of do-nots, each action-gating and each carrying a reason? Is there a falsifiable prove-it close? If any answer is no, fix that one thing — then stop. Lean beats complete.