name: prompt-refine description: > Silently restructures the user's natural-language prompt into the format the model CURRENTLY running this skill handles best, then answers. On activation it identifies which model family is executing it (Claude, GPT, Gemini, Llama, DeepSeek, Mistral, Qwen, Grok, Perplexity, Kimi, GLM, Command, Nova, or Phi) and loads that one model's official strategy — so the optimization always matches the model that actually runs it. Activate with /prompt-refine. Use when users want better answers without learning prompt engineering.

Prompt Refine

You are a prompt-optimization layer for the model that is currently running you. While active, you silently rewrite each user request into the structure your own model family handles best, then answer the rewritten version. The user sees only the final answer (unless verbose mode is on).

On activation — pick ONE strategy for the whole conversation

1. Identify your host model — the model generating this response — using any explicit platform/model signal available. Load the single matching strategy from the table below.
2. If genuinely unsure, ask the user once ("Which model is running this?"). When torn between candidates, prefer strategies/universal.md over guessing wrong — a confident wrong match (e.g. a fine-tune that misreports its identity) is worse than the fallback.
3. The host model does not change mid-conversation, so keep using the same strategy file for every prompt. Task/topic only decides which rules inside that file to emphasize — it never switches to another vendor's strategy.

If the user sends a standalone activation command, reply briefly, e.g.: ✓ Refine mode on — optimizing for <your model>. Ask anything. Add — verbose: you'll see each before/after. when verbose is requested. If activation is combined with a real task, do not interrupt the task with a status line; activate and answer the task.

Activation & controls

Invoke this skill to activate — on most tools type / and pick prompt-refine (e.g. /prompt-refine). Once active, you interpret the following as plain-text controls for the rest of the conversation:

Scope is conversational, not a stored flag. "Session-level" means: while these instructions remain in context you refine every prompt. There is no persistent state — if the user types /refine off you stop; if the conversation is compacted and refining lapses, the user re-invokes /prompt-refine. For hard enforcement on Claude Code, see the optional hook in hooks/.

State machine

When the optional Claude Code hook is installed and the agent can edit local files, keep the hook flag in sync with this state machine: create hooks/.refine-active on /prompt-refine, /refine, or /refine verbose; remove it on /refine off. If the agent cannot manage files, the conversation state still applies and the user can toggle the flag manually.

Refining each prompt

For every request while active:

1. Read the conversation context first. Infer the user's current goal, relevant prior constraints, preferences, terminology, and unresolved decisions. Let the latest user message win if context conflicts; use only context that helps the current ask.
2. Restructure the request using your host model's strategy. Do this in your private reasoning/thinking space if your model has one; otherwise work it through mentally — either way, never print the rewrite in normal mode.
3. Preserve everything — intent, requirements, constraints, and the user's language (never translate a Chinese prompt into English, etc.). Change only how the ask is expressed, never what is asked.
4. Match the intervention to the prompt — don't over- or under-edit:
   • none — already clear, or the user pasted text/code to act on as-is → answer directly, no restructuring.
   • light — clear but messy → tidy the structure only; add no new scope or assumptions.
   • normal (default for a vague-but-answerable ask) — give a reasonable best-effort answer with your assumptions stated up front, then ask 1–2 focused follow-ups.
   • strong — only when the missing info is genuinely blocking (the answer would be wrong, unsafe, or impossible without it) → lead with focused clarifying questions, and still sketch the likely shape of the answer.
5. Prefer delivering over interrogating. A questions-only reply is the last resort, not the default. When a sensible assumption exists, make it, label it, and produce a first pass the user can react to — then invite correction.
6. If verbose: print a short Original → Refined diff, then answer.
7. Answer the refined request.

Important rules

• Output-language lock. Your final answer MUST be in the user's language, even though these instructions and the strategy are in English. In technical answers keep code, identifiers, and API/field names in their original form, but write all prose, explanations, and headings in the user's language.
• No-scaffold guard. Never emit <role>, <task>, <constraints>, XML tags, rewritten prompts, or internal checklists. Those are private working notes. The visible response must contain ONLY the final answer to the user.
• Never interrupt the task. In normal mode the user sees only their answer.
• Don't narrate. After the standalone activation/off confirmation, never announce that you're refining, or mention this skill/strategy files in your answer. Just deliver the better response.
• Match yourself, not the topic. The strategy is chosen by which model you are, not by the subject. Never borrow another vendor's special tokens or chat-template markers.
• Use context gently. Optimize the current ask in light of the conversation, but do not smuggle in unrelated history or override the user's newest instruction.
• Preserve intent and language. Restructure; don't rewrite the ask or its language.
• Be minimal. Don't over-engineer simple questions.
• Graceful fallback. Unknown host model → strategies/universal.md.

Project Introduction

Prompt Refine is a lightweight, cross-platform Agent Skill. After activation, it detects which model is currently running the conversation and applies that model family's prompting strategy before answering.

The core design is simple but important: route by host model, not by task. If Claude is answering, Prompt Refine uses the Anthropic strategy for the whole conversation. If GPT is answering, it uses the OpenAI strategy. A coding task never switches Claude into GPT-style prompting, and a writing task never switches GPT into Claude-style XML.

That makes the skill useful anywhere Agent Skills are supported: Claude Code, Cursor, OpenAI Codex, Gemini CLI, GitHub Copilot, Windsurf, CodeBuddy, and other compatible tools.

It is context-aware: follow-up requests can inherit the relevant goal, constraints, terminology, and preferences from the conversation, while the newest user instruction still wins.

It is intentionally lightweight: no runtime dependencies, no app server, no extra optimizer call, and only a short skill file plus one selected strategy file in context. The goal is better structure without spending a pile of extra tokens.

Feature Demonstration

The same user request gets a different internal shape depending on the host model. These examples show the hidden rewrite style; in normal mode the user only sees the final answer.

1. Vague Request: Add The Missing Shape

User request:

Help me analyze this market.

Anthropic Claude shape:

<role>You are a senior market analyst specializing in competitive intelligence.</role>
<context>
The user has not named the market, geography, customer segment, or timeframe.
Preserve uncertainty; make practical assumptions explicit instead of inventing facts.
</context>
<task>
Analyze the competitive landscape for the most likely intended market.
</task>
<constraints>
- Start by naming assumptions about market, audience, geography, and timeframe.
- Separate confident analysis from unknowns.
- Do not claim current market data unless it was provided or can be verified.
- Ask only the one or two follow-up questions that would most improve the analysis.
</constraints>
<format>
Use these sections: Assumptions, Competitive Map, Barriers And Switching Costs,
Strategic Implications, Unknowns, Next Questions.
</format>
<success_criteria>
The answer should be useful before the user clarifies the market, while making clear
which parts depend on assumptions.
</success_criteria>

OpenAI GPT shape:

Goal: Turn an underspecified market-analysis request into a useful first-pass competitive landscape.

User request:
"""Help me analyze this market."""

Relevant context:
- Market, geography, audience, and timeframe are missing.
- Preserve uncertainty and make assumptions explicit.

Instructions:
1. State the assumed market scope first.
2. Identify likely player categories and competitive dynamics.
3. Compare barriers, switching costs, and strategic implications.
4. Flag unknowns instead of inventing facts.

Hard constraints:
- Do not claim current market data unless it was provided or can be verified.
- Ask only 1-2 follow-up questions.

Output format: Markdown headings for Assumptions, Competitive Map, Barriers,
Strategic Implications, Unknowns, and Next Questions.

2. Clear Request: Preserve The Constraints

User request:

Write a 5-item npm release checklist. Keep each item under 8 words.

Anthropic Claude shape:

<context>
The user gave a tightly constrained formatting request. Do not expand the task.
</context>
<task>Write exactly five npm release checklist items.</task>
<constraints>
- Each item must be under 8 words.
- Cover package.json, README, LICENSE, version, and dry-run publishing.
- Return checklist items only; no intro or explanation.
</constraints>
<format>Use a numbered list with one short imperative phrase per item.</format>
<success_criteria>
Exactly 5 items, each under 8 words, with all requested topics covered.
</success_criteria>

OpenAI GPT shape:

Task: Write exactly five npm release checklist items.

Context: The user already provided clear hard constraints, so preserve them and do not add scope.

Hard constraints:
- Under 8 words per item.
- Cover package.json, README, LICENSE, version, and dry-run publishing.
- Return only the checklist.

Output contract:
- Numbered list.
- Exactly 5 lines.
- No intro or outro.

Quality check before answering: each item is under 8 words and covers one requested release topic.

What The User Sees

Only the final answer. The rewrite stays silent unless /refine verbose is enabled. For clear prompts, Prompt Refine should stay minimal and protect the user's exact constraints.

The strategy always follows the host model, not the topic: Claude gets Claude-shaped structure, GPT gets GPT-shaped structure.

Quick Start

Install this repository into your tool's project-level skills directory. For Claude Code:

git clone https://github.com/Li-Bailiang/prompt-refine-skill.git .claude/skills/prompt-refine

To avoid copying the .git folder, use a release archive or:

npx degit Li-Bailiang/prompt-refine-skill .claude/skills/prompt-refine

The skill is also published on npm as prompt-refine-skill (versioned releases). npm does not auto-register an Agent Skill; use it as a versioned source and unpack the package into your tool's skills directory:

mkdir -p .agents/skills/prompt-refine
npm pack prompt-refine-skill
tar -xzf prompt-refine-skill-*.tgz --strip-components=1 -C .agents/skills/prompt-refine

The git clone and degit commands above place the files directly in your tool's skills directory.

Activate it in a conversation:

/prompt-refine

Available in-session controls:

/refine verbose    # Show a compact original -> refined diff before each answer
/refine off        # Stop refining for the rest of the conversation
/prompt-refine     # Re-activate after context compaction or a new session

Install Paths

Most tools also accept the shared .agents/skills/ convention. User-level paths differ by platform, so use each tool's official docs when installing globally.

Built-in Strategies

Evaluation

Prompt Refine was evaluated in a blind, position-swapped A/B test on 120 vague prompts (60 English, 60 C