oprogramadorreal/optimus-claude / skills/prompt
prompt
VerifiedCrafts optimized, copy-ready prompts for any AI tool — LLMs, coding agents, image generators, workflow tools. Extracts intent, selects the right template, runs a diagnostic scan, and delivers a token-efficient prompt. Accepts input in any language; English output by default. Use when writing, fixing, improving, or adapting a prompt for any AI tool.
| File | Kind | Size |
|---|---|---|
| README.md | markdown | 6.9 KB |
| SKILL.md | skill md | 13.6 KB |
| agents/openai.yaml | config | 198 B |
| references/templates.md | markdown | 16.6 KB |
| references/tool-routing.md | markdown | 23.1 KB |
references/templates.md
View on GitHub# Prompt Templates Reference
14 prompt architectures. Load only the template matching the task — do not load the entire file.
## Table of Contents
| Template | Best For |
|----------|----------|
| [A — RTF](#template-a--rtf) | Simple one-shot tasks |
| [B — CO-STAR](#template-b--co-star) | Professional documents, business writing |
| [C — RISEN](#template-c--risen) | Complex multi-step projects |
| [D — CRISPE](#template-d--crispe) | Creative work, brand voice |
| [E — Chain of Thought](#template-e--chain-of-thought) | Logic, math, analysis, debugging |
| [F — Few-Shot](#template-f--few-shot) | Consistent structured output, pattern replication |
| [G — File-Scope](#template-g--file-scope) | Cursor, Windsurf, Copilot — code editing AI |
| [H — ReAct + Stop Conditions](#template-h--react--stop-conditions) | Claude Code, Codex, Devin — autonomous agents |
| [I — Visual Descriptor](#template-i--visual-descriptor) | Midjourney, OpenAI image tools, Stable Diffusion, Sora |
| [J — Reference Image Editing](#template-j--reference-image-editing) | Editing an existing image with a reference |
| [K — ComfyUI](#template-k--comfyui) | ComfyUI node-based image workflows |
| [L — Prompt Decompiler](#template-l--prompt-decompiler) | Breaking down, adapting, or splitting existing prompts |
| [M — Exploration + Plan Architecture](#template-m--exploration--plan-architecture) | Claude Code plan mode — codebase exploration and planning |
| [N — Dynamic Workflow Orchestration](#template-n--dynamic-workflow-orchestration) | Claude Code dynamic workflows — fan-out / parallel subagent work |
## Template A — RTF
*Role, Task, Format — fast one-shot tasks where the request is clear and simple.*
```
Role: [One sentence defining who the AI is]
Task: [Precise verb + what to produce]
Format: [Exact output format and length]
```
## Template B — CO-STAR
*Professional documents, business writing, reports, marketing content.*
```
Context: [Background the AI needs to understand the situation]
Objective: [Exact goal — what success looks like]
Style: [Writing style: formal / conversational / technical / narrative]
Tone: [Emotional register: authoritative / empathetic / urgent / neutral]
Audience: [Who reads this — their knowledge level and expectations]
Response: [Format, length, and structure of the output]
```
## Template C — RISEN
*Complex multi-step projects requiring a clear sequence.*
```
Role: [Expert identity]
Instructions: [Overall task in plain terms]
Steps:
1. [First action]
2. [Second action]
3. [Continue as needed]
End Goal: [What the final output must achieve]
Narrowing: [Constraints, scope limits, what to exclude]
```
## Template D — CRISPE
*Creative work, brand voice, iterative content.*
```
Capacity: [What capability or expertise the AI should have]
Role: [Specific persona to adopt]
Insight: [Key background insight that shapes the response]
Statement: [The core task or question]
Personality: [Tone and style — witty / authoritative / casual / sharp]
Experiment: [Request variants or alternatives to explore]
```
## Template E — Chain of Thought
*Logic-heavy tasks, math, debugging, multi-factor analysis — only when the target's tool-routing.md entry does not steer reasoning itself. The Claude and Reasoning-Native entries do: follow them instead (Claude's one-line nudge; a clear task and output contract for reasoning-native) with Template A or C. The scaffold asks for the visible working the deliverable needs, not a transcript of the model's private reasoning. Not for simple or creative tasks.*
```
[Task statement]
Before the answer, show your working in <working> tags:
1. The problem in one sentence and the constraints the solution must respect.
2. The candidate approaches, and which one you chose and why.
3. [Task-specific intermediate results — e.g. equations and values, traced state, causes ruled out]
Give the final answer in <answer> tags.
```
## Template F — Few-Shot
*When the output format is easier to show than describe. XML tags — Claude parses XML reliably.*
```
[Task instruction]
Here are examples of the exact format needed:
<examples>
<example>
<input>[example input 1]</input>
<output>[example output 1]</output>
</example>
<example>
<input>[example input 2]</input>
<output>[example output 2]</output>
</example>
</examples>
Now apply this exact pattern to: [actual input]
```
## Template G — File-Scope
*Cursor, Windsurf, GitHub Copilot — any code editing AI. Prevents the most common failure: editing the wrong file or breaking existing logic.*
```
File: [exact/path/to/file.ext]
Function/Component: [exact name]
Current Behavior:
[What this code does right now]
Desired Change:
[What it should do after the edit]
Scope:
Only modify [function / component / section].
Do NOT touch: [list everything to leave unchanged]
Constraints:
- Language/framework: [specify version]
- Do not add dependencies not in [manifest file]
- Preserve existing [type signatures / API contracts / variable names]
Done When:
[Exact condition that confirms the change worked]
```
## Template H — ReAct + Stop Conditions
*Claude Code, Codex, Devin, autonomous agents. State boundaries and completion conditions appropriate to the task. Fill the scaffold from the user's actual scope and authorization; do not introduce a new approval gate for an action already approved.*
```
Objective:
[Single, unambiguous goal in one sentence]
Starting State:
[Current file structure / codebase state / environment]
Target State:
[What should exist when the agent is done]
Allowed Actions:
- [Specific action the agent may take]
- Install only packages listed in [manifest file]
Forbidden Actions:
- Do NOT modify files outside [directory/scope]
- Do NOT run the dev server or deploy
- Do NOT push to git
- Do NOT delete files without showing a diff first
- Do NOT expand the agreed architecture or scope without approval; make routine choices within it
Stop Conditions:
Pause and ask for human review when a decision remains outside the user's existing authorization:
- A file would be permanently deleted
- A new external service or API needs to be integrated
- Two valid paths exist and the choice affects architecture
- An error cannot be resolved in 2 attempts
- The task requires changes outside the stated scope
Reporting:
Say in a line what you're about to do before the first tool call; while working, speak up on something important or a change of direction.
Lead your final message with the outcome, followed by a summary of every file changed and what's next — a recap that stands on its own for a reader who saw none of the work.
```
## Template I — Visual Descriptor
*Midjourney, OpenAI image tools, Stable Diffusion, Sora, Runway — image or video generation.*
```
Subject: [Main subject — specific, not vague]
Action/Pose: [What the subject is doing]
Setting: [Where the scene takes place]
Style: [photorealistic / cinematic / anime / oil painting / vector / etc.]
Mood: [dramatic / serene / eerie / joyful / etc.]
Lighting: [golden hour / studio / neon / overcast / candlelight / etc.]
Color Palette: [dominant colors or named palette]
Composition: [wide shot / close-up / aerial / Dutch angle / etc.]
Aspect Ratio: [16:9 / 1:1 / 9:16 / 4:3]
Negative Prompts: [blurry, watermark, extra fingers, distortion, low quality]
Style Reference: [artist / film / aesthetic reference if applicable]
```
**Video:** add camera movement (slow dolly, static shot, crane up), duration, and cut style. **Seedance 2** is the exception — its prompt shape differs entirely; apply its Video AI entry in tool-routing.md instead of this field list.
## Template J — Reference Image Editing
*When the user has an existing image to modify. Always add the setup note: "Attach your reference image to [tool name] before sending this prompt."*
```
Reference image: [attached / URL]
What to keep exactly the same: [list everything that must not change]
What to change: [specific edit only — be precise]
How much to change: [subtle / moderate / significant]
Style consistency: maintain the exact style, lighting, and mood of the reference
Negative prompt: [what to avoid introducing]
```
**Tool syntax:** apply tool-routing.md's Image AI — Editing entry.
## Template K — ComfyUI
*Node-based image workflows. Positive and Negative paste into different text-encode nodes: output each as its own fenced block in its own marker pair, with its label above the opening marker.*
Positive prompt:
```
[subject], [style], [mood], [lighting], [composition], [quality boosters]
```
Negative prompt:
```
[what to exclude: blurry, low quality, watermark, extra limbs, bad anatomy, distorted]
```
**Setup note** (after the Target line, outside the markers): checkpoint [model name], 20-30 steps, resolution [width x height — divisible by 64]. SD 1.5 / SDXL: Euler a, CFG 7. Flux.1: euler, CFG 1.0 plus a FluxGuidance node at ~3.5 (schnell: 4 steps); at CFG 1 the negative prompt has no effect.
## Template L — Prompt Decompiler
*When the user pastes an existing prompt to break down, adapt, simplify, or split.*
Detect the task: **Break down** (explain what each part does), **Adapt** (rewrite for a different tool, preserving intent — ask for whichever of the source and target tool the user did not name), **Simplify** (remove redundancy and tighten), or **Split** (divide a complex one-shot into a cleaner sequence).
Wrap each pasteable prompt block below — the `Recommended fix`, the `Adapted for [target tool]` block, and each split `[prompt block]` — in its own pair of the SKILL.md output-contract boundary markers. Labels, analysis, and commentary lines stay outside the markers.
**Break down format:**
```
Original prompt: [paste]
Structure analysis:
- Role/Identity: [what role is assigned and why]
- Task: [what action is being requested]
- Constraints: [what limits are set]
- Format: [what output shape is expected]
- Weaknesses: [what is missing or could cause wrong output]
Recommended fix: [rewritten version with gaps filled]
```
**Adapt format:**
```
Original ([source tool]): [original prompt]
Adapted for [target tool]:
[rewritten prompt using target tool syntax and best practices]
Key changes made:
- [change 1 and why]
- [change 2 and why]
```
**Split format:**
```
Original prompt: [paste]
This prompt is doing [N] things. Split into [N] sequential prompts:
Prompt 1 — [what it handles]:
[prompt block]
Prompt 2 — [what it handles]:
[prompt block]
Run these in order. Each output feeds the next.
```
## Template M — Exploration + Plan Architecture
*For Claude Code plan mode — produces a PROMPT the user pastes into a new plan-mode conversation. NEVER produce the plan itself.*
- Plan-mode Claude reads the project's CLAUDE.md and explores the codebase on its own — the prompt tells it WHAT to figure out, not pre-answers
- Verify and optimize user input: read referenced files to confirm findings, ask if something seems incorrect, synthesize into clear context — do not copy verbatim. Resolve entity names to paths, but do not explore code structure or internals beyond what the user provided — never pre-do plan-mode's exploration
- Preserve the user's explicit methodology instructions — if the user says to search the web, verify assumptions, ask questions, or use specific tools, carry those instructions into the prompt (typically in "What to Figure Out"). Do not silently drop them during synthesis
- NEVER include plan-mode-redundant guardrails ("YOU ARE IN PLAN MODE", "DO NOT EDIT CODE", "read-only", "do not execute") — plan mode enforces read-only automatically. One carve-out: the review-loop block in `$CLAUDE_PLUGIN_ROOT/skills/brainstorm/references/plan-mode-handoff.md` keeps its "plan mode is read-only" clause, where it explains the toggle-off-then-follow-up write mechanic rather than guardrailing exploration
```
## Goal
[The problem or change in one clear paragraph — include WHY if it shapes the approach.]
## Context
[Verified, optimized synthesis of the user's input: findings, constraints, prior
decisions, referenced documents — no exploration details beyond what the user provided.]
## Starting Hints (omit if the user named no locations)
[Files, directories, or patterns the user mentioned as relevant.]
## What to Figure Out
[Questions plan-mode Claude should answer through exploration. Frame as questions,
not pre-explored findings; include any research method the user requested.]
1. [Question about feasibility, approach, or architecture]
2. [Question about existing patterns to follow or reuse]
3. [Question about risks, trade-offs, or open decisions]
## Plan Deliverable
The plan should include:
- [Section the user needs — e.g., "Proposed approach with rationale"]
- [Section the user needs — e.g., "Files to create or modify, with what changes"]
- [Section the user needs — e.g., "Implementation sequence and dependencies"]
- [Section the user needs — e.g., "Risks and open questions"]
## Scope
- Focus on: [areas relevant to the goal]
- Out of scope: [areas to skip — saves tokens]
```
**When to use:** plan-mode codebase exploration ending in an implementation plan the prompt defines but does not pre-answer. **When NOT to use:** executing changes directly — Template H.
## Template N — Dynamic Workflow Orchestration
*For Claude Code dynamic workflows — produces a single NATURAL-LANGUAGE PROMPT the user pastes into an active Claude Code session to launch a workflow of REAL parallel subagents (exempt from Invariant 1 — the passes are real, not simulated). NEVER author a .js workflow script, and do NOT prescribe the workflow's phases or agent counts — describe the task, outcome, and constraints; Claude Code designs the orchestration and writes the script.*
- Express orchestration as **intent**, in natural language — open with "Run a workflow to…" (the scaffold below does). The prompt must clearly ask for a workflow of parallel agents, not a turn-by-turn task
- Describe the task, the quality bar (e.g. "cross-check findings before reporting"), and the required output. A pattern-type hint (fan-out / pipeline / cross-agent corroboration) is optional preference, never a prescribed phase plan with agent counts
- Scope is MANDATORY (cost + runaway risk): bound the target set and give an early-stop condition. Concurrency and total-agent caps are the runtime's own fixed limits, not knobs the prompt sets or needs to restate; the prompt's job is only to keep the target set from sprawling
- Permissions: workflow child tools follow the host's subagent permission rules; do not claim every mode auto-approves edits. For analysis/audit work the prompt MUST say "read-only: do not edit, write, move, or delete any file; report findings only." This states task scope independently of runtime permissions
- Launch approval is the host's (SKILL.md Step 7 tells the user); do not invent an extra approval gate inside the generated task
```
Run a workflow to [TASK — what to do across what bounded target set: files / dirs / items].
Desired outcome: [what a good result looks like — the deliverable's purpose, not the steps].
You design the orchestration — decide the phases, how many agents, and how they divide and (where useful) cross-check the work. I'm giving you the task, the constraints, and the quality bar; you write the script and choose the shape.
Quality bar: [intent only — e.g. "be thorough: cover every item in scope"; "have findings corroborated by an agent that did not produce them, and drop what corroboration cannot confirm"; "approach this from several independent angles and reconcile them"]. Don't just run more agents — apply whatever verification makes the result trustworthy.
Scope:
- In scope: [explicit targets]. Out of scope: [skip].
- Mode: [READ-ONLY — do NOT edit, write, move, or delete any file; report findings only. OR agents may edit only within <path>; do NOT touch <forbidden>].
- Stop early if [condition]; keep work bounded to the in-scope targets above.
Output: [exact shape — e.g., one markdown report grouping findings by file with file:line evidence].
```
*Match the prompt's weight to the task: the block above is the full scaffold for a non-trivial fan-out; for a simple, clearly-bounded task one or two sentences naming the task, scope, read-only-vs-edit, and output shape are enough. Orchestration stays Claude Code's to design at any length.*
**When to use:** Claude Code fan-out / parallel work at scale — audit every X, review N files independently, research several angles, or draft a plan from several angles then weigh them. **When NOT to use:** a single linear task (Template H), read-only plan-mode exploration (Template M), any non-Claude-Code tool, or when the user wants the .js script itself.
*Setup: dynamic workflows may need enabling in `/config` on some plans.*
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness. | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is available | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |