enhance-prompts（增强提示）

enhance-prompts

Analyze prompts for clarity, structure, examples, and output reliability.

Parse Arguments

const args = '$ARGUMENTS'.split(' ').filter(Boolean);
const targetPath = args.find(a => !a.startsWith('--')) || '.';
const fix = args.includes('--fix');

Differentiation from enhance-agent-prompts

Workflow

1. Run Analyzer - Execute the JavaScript analyzer to get findings: node -e "const a = require('./lib/enhance/prompt-analyzer.js'); console.log(JSON.stringify(a.analyzeAllPrompts('.'), null, 2));" For a specific path: a.analyzeAllPrompts('./plugins/enhance') For a single file: a.analyzePrompt('./path/to/file.md')
2. Parse Results - The analyzer returns JSON with summary and findings
3. Filter - Apply certainty filtering based on --verbose flag
4. Report - Format findings as markdown output
5. Fix - If --fix flag, apply auto-fixes from findings

The JavaScript analyzer (lib/enhance/prompt-analyzer.js) implements all detection patterns including AST-based code validation. The patterns below are reference documentation.

Prompt Engineering Knowledge Reference

System Prompt Structure

Effective system prompts include: Role/Identity, Capabilities & Constraints, Instruction Priority, Output Format, Behavioral Directives, Examples, Error Handling.

Minimal Template:

<system>
You are [ROLE]. [PURPOSE].
Key constraints: [CONSTRAINTS]
Output format: [FORMAT]
When uncertain: [HANDLING]
</system>

XML Tags (Claude-Specific)

Claude is fine-tuned for XML tags. Use: <role>, <constraints>, <output_format>, <examples>, <instructions>, <context>

<constraints>
- Maximum response length: 500 words
- Use only Python 3.10+ syntax
</constraints>

Few-Shot Examples

• 2-5 examples is optimal (research-backed)
• Include edge cases and ensure format consistency
• Start zero-shot, add examples only if needed
• Show both good AND bad examples when relevant

Chain-of-Thought (CoT)

Key: Modern models (Claude 4.x, o1/o3) perform CoT internally. "Think step by step" is redundant.

Role Prompting

Helps: Creative tasks, tone/style, roleplay Doesn't help: Accuracy tasks, factual retrieval, complex reasoning

Better: "Approach systematically, showing work" vs "You are an expert"

Instruction Hierarchy

Priority: System > Developer > User > Retrieved Content

Include explicit priority in prompts with multiple constraint sources.

Negative Prompting

Positive alternatives are more effective than negatives:

Structured Output

• Prompt-based: ~35.9% reliability
• Schema enforcement: 100% reliability
• Always provide schema example and validate output

Context Window Optimization

Lost-in-the-Middle: Models weigh beginning and end more heavily.

Place critical constraints at start, examples in middle, error handling at end.

Extended Thinking

High-level instructions ("Think deeply") outperform step-by-step guidance. "Think step-by-step" is redundant with modern models.

Anti-Patterns Quick Reference

Detection Patterns

1. Clarity Issues (HIGH Certainty)

Vague Instructions: "usually", "sometimes", "try to", "if possible", "might", "could"

Negative-Only Constraints: "don't", "never", "avoid" without stating what TO do

Aggressive Emphasis: Excessive CAPS (CRITICAL, IMPORTANT), multiple!!

2. Structure Issues (HIGH/MEDIUM Certainty)

Missing XML Structure: Complex prompts (>800 tokens) without XML tags

Inconsistent Sections: Mixed heading styles, skipped levels (H1→H3)

Critical Info Buried: Important instructions in middle 40%, constraints after examples

3. Example Issues (HIGH/MEDIUM Certainty)

Missing Examples: Complex tasks without few-shot, format requests without example

Suboptimal Count: Only 1 example (optimal: 2-5), more than 7 (bloat)

Missing Contrast: No good/bad labeling, no edge cases

4. Context Issues (MEDIUM Certainty)

Missing WHY: Rules without explanation

Missing Priority: Multiple constraint sections without conflict resolution

5. Output Format Issues (HIGH/MEDIUM Certainty)

Missing Format: Substantial prompts without format specification

JSON Without Schema: Requests JSON but no example structure

6. Anti-Patterns (HIGH/MEDIUM/LOW Certainty)

Redundant CoT (HIGH): "Think step by step" with modern models

Overly Prescriptive (MEDIUM): 10+ numbered steps, micro-managing reasoning

Prompt Bloat (LOW): Over 2500 tokens, redundant instructions

Vague References (HIGH): "The above code", "as mentioned"

Auto-Fix Implementations

1. Aggressive Emphasis

Replace CRITICAL→critical,!!→!, remove excessive caps

2. Negative-Only to Positive

Suggest positive alternatives for "don't" statements

Output Format

## Prompt Analysis: {prompt-name}

**File**: {path}
**Type**: {system|agent|skill|template}
**Token Count**: ~{tokens}

### Summary
- HIGH: {count} issues
- MEDIUM: {count} issues

### Clarity Issues ({n})
| Issue | Location | Fix | Certainty |

### Structure Issues ({n})
| Issue | Location | Fix | Certainty |

### Example Issues ({n})
| Issue | Location | Fix | Certainty |

Pattern Statistics

<bad_example>

You should usually follow best practices when possible.

Why it's bad: Vague qualifiers reduce determinism. </bad_example>

<good_example>

Follow these practices:
1. Validate input before processing
2. Handle null/undefined explicitly

Why it's good: Specific, actionable instructions. </good_example>

Example: Negative-Only Constraints

<bad_example>

- Don't use vague language
- Never skip validation

Why it's bad: Only states what NOT to do. </bad_example>

<good_example>

- Use specific, deterministic language
- Always validate input; return structured errors

Why it's good: Each constraint includes positive action. </good_example>

Example: Redundant Chain-of-Thought

<bad_example>

Think through this step by step:
1. First, analyze the input
2. Then, identify the key elements

Why it's bad: Modern models do this internally. Wastes tokens. </bad_example>

<good_example>

Analyze the input carefully before responding.

Why it's good: High-level guidance without micro-managing. </good_example>

Example: Missing Output Format

<bad_example>

Respond with a JSON object containing the analysis results.

Why it's bad: No schema or example. </bad_example>

<good_example>

## Output Format
{"status": "success|error", "findings": [{"severity": "HIGH"}]}

Why it's good: Concrete schema shows exact structure. </good_example>

Example: Critical Info Buried

<bad_example>

# Task
[task]
## Background
[500 words...]
## Important Constraints  <- buried at end

Why it's bad: Lost-in-the-middle effect. </bad_example>

<good_example>

# Task
## Critical Constraints  <- at start
[constraints]
## Background

Why it's good: Critical info at start where attention is highest. </good_example>

Constraints

• Only apply auto-fixes for HIGH certainty issues
• Preserve original structure and formatting
• Validate against embedded knowledge reference above