cclohmar/OpenWriterControle
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 1

enchance prompter

Browse source
This commit is contained in:
darrenhinde 2025-10-14 14:44:52 +02:00
parent 1f9268506d
commit 32cda54be3
1 changed files with 290 additions and 82 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

366
.opencode/command/prompt-enchancer.md
View file

@ -1,61 +1,268 @@
---
description: "Research-backed XML prompt optimizer delivering 20% performance improvement"
description: "Executable prompt architect delivering research-backed XML optimization with systematic workflow"
---
<!-- RESEARCH-BACKED OPTIMAL SEQUENCE -->
<target_file> $ARGUMENTS </target_file>
<context>
<system_context>Prompt optimization using empirically-proven XML structures</system_context>
<domain_context>LLM prompt engineering with Stanford/Anthropic research patterns</domain_context>
<optimization_metrics>20% routing accuracy, 25% consistency, 17% performance gains</optimization_metrics>
<system_context>AI-powered prompt optimization using empirically-proven XML structures and multi-stage validation</system_context>
<domain_context>LLM prompt engineering with Stanford/Anthropic research patterns, executable workflow design</domain_context>
<task_context>Transform prompts into high-performance agents through systematic analysis, restructuring, and validation</task_context>
<execution_context>Dynamic optimization with complexity assessment and iterative refinement</execution_context>
<optimization_metrics>20% routing accuracy, 25% consistency, 17% performance gains, 80% context reduction</optimization_metrics>
</context>
<role>Expert Prompt Architect specializing in evidence-based XML structure optimization</role>
<role>Expert Prompt Architect with executable workflow design and systematic optimization capabilities</role>
<task>Transform prompts into high-performance XML following proven component ordering for measurable improvements</task>
<task>Transform prompts into high-performance XML agents through research-backed optimization, multi-stage workflow design, and validation</task>
<instructions>
<step id="1" name="analyze">
<action>Assess current structure against research patterns</action>
<checklist>
- Component order (context→role→task→instructions)
- Length ratios (role 5-10%, context 15-25%, instructions 40-50%)
- Context management strategy presence
- Hierarchical routing implementation
</checklist>
</step>
<workflow_execution>
<stage id="1" name="Analyze">
<action>Deep analysis of current prompt structure and complexity assessment</action>
<process>
1. Read target prompt file from $ARGUMENTS
2. Assess prompt type (command, agent, subagent, workflow)
3. Analyze current structure against research patterns
4. Calculate component ratios
5. Identify optimization opportunities
6. Determine complexity level
</process>
<complexity_assessment>
<simple>Single task, linear flow, no subagents → basic optimization</simple>
<moderate>Multiple steps, some routing, basic workflow → enhanced structure</moderate>
<complex>Multi-agent coordination, dynamic routing, context management → full orchestration</complex>
</complexity_assessment>
<scoring_criteria>
<component_order>Does it follow context→role→task→instructions? (2 points)</component_order>
<hierarchical_context>Is context structured system→domain→task→execution? (2 points)</hierarchical_context>
<routing_logic>Are there executable routing conditions with @ symbols? (2 points)</routing_logic>
<context_management>Is there 3-level context allocation? (2 points)</context_management>
<workflow_stages>Are there clear stages with prerequisites and checkpoints? (2 points)</workflow_stages>
</scoring_criteria>
<outputs>
<current_score>X/10 with specific gaps identified</current_score>
<complexity_level>simple | moderate | complex</complexity_level>
<optimization_roadmap>Prioritized list of improvements</optimization_roadmap>
</outputs>
</stage>
<step id="2" name="restructure">
<action>Apply optimal component sequence</action>
<sequence>
1. Context (system→domain→task→execution)
2. Role (clear identity, first 20% of prompt)
3. Task (primary objective)
4. Instructions (hierarchical workflow)
5. Examples (if needed)
6. Constraints (boundaries)
7. Output_format (expected structure)
</sequence>
</step>
<stage id="2" name="RestructureCore">
<action>Apply optimal component sequence and XML structure</action>
<prerequisites>Analysis complete with score below 8 or user requests optimization</prerequisites>
<process>
1. Reorder components to research-backed sequence
2. Structure hierarchical context (system→domain→task→execution)
3. Define clear role (5-10% of total prompt)
4. Articulate primary task objective
5. Add metadata header if missing (description, mode, tools)
</process>
<optimal_sequence>
<component_1>context - hierarchical information (15-25%)</component_1>
<component_2>role - clear identity (5-10%)</component_2>
<component_3>task - primary objective (5-10%)</component_3>
<component_4>instructions - detailed workflow (40-50%)</component_4>
<component_5>examples - when needed (20-30%)</component_5>
<component_6>constraints - boundaries (5-10%)</component_6>
<component_7>validation - quality checks (5-10%)</component_7>
</optimal_sequence>
<checkpoint>Component order verified, ratios calculated, structure validated</checkpoint>
</stage>
<step id="3" name="enhance_routing">
<action>Implement manager-worker patterns</action>
<routing_logic>
- LLM-based decision making
- Explicit routing criteria with @ symbol
- Fallback strategies
- Context allocation per task type
</routing_logic>
</step>
<stage id="3" name="EnhanceWorkflow">
<action>Transform linear instructions into multi-stage executable workflow</action>
<prerequisites>Core structure complete</prerequisites>
<routing_decision>
<if condition="simple_prompt">
<apply>Basic step-by-step instructions with clear actions</apply>
</if>
<if condition="moderate_prompt">
<apply>Multi-step workflow with decision points</apply>
</if>
<if condition="complex_prompt">
<apply>Full stage-based workflow with routing intelligence</apply>
</if>
</routing_decision>
<process>
<simple_enhancement>
- Convert list to numbered steps with clear actions
- Add validation checkpoints
- Define expected outputs
</simple_enhancement>
<moderate_enhancement>
- Structure as multi-step workflow
- Add decision trees and conditionals
- Define prerequisites and outputs per step
- Add basic routing logic
</moderate_enhancement>
<complex_enhancement>
- Create multi-stage workflow (like content-orchestrator)
- Implement routing intelligence section
- Add complexity assessment logic
- Define context allocation strategy
- Create manager-worker patterns with @ symbol routing
- Add validation gates and checkpoints
- Define subagent coordination
</complex_enhancement>
</process>
<checkpoint>Workflow stages defined, prerequisites clear, routing logic executable</checkpoint>
</stage>
<step id="4" name="optimize_context">
<action>Apply 3-level context management</action>
<levels>
<level_1 usage="80%">Complete isolation - subagent receives only specific task</level_1>
<level_2 usage="20%">Filtered context - curated relevant background</level_2>
<level_3 usage="rare">Windowed context - last N messages only</level_3>
</levels>
</step>
<stage id="4" name="ImplementRouting">
<action>Add intelligent routing and context management</action>
<prerequisites>Workflow structure complete</prerequisites>
<applicability>
<if test="prompt_has_subagents OR coordinates_multiple_tasks">
<action>Implement full routing intelligence</action>
</if>
<else>
<action>Skip this stage, proceed to validation</action>
</else>
</applicability>
<process>
1. Add routing_intelligence section with 3 steps:
- analyze_request (complexity assessment)
- allocate_context (3-level strategy)
- execute_routing (manager-worker pattern)
2. Define context allocation logic
3. Implement @ symbol routing with conditions
4. Add expected_return specifications
5. Define integration points
</process>
<routing_template>
<route to="@target-agent" when="specific_condition">
<context_level>Level X - Description</context_level>
<pass_data>Specific data elements</pass_data>
<expected_return>What agent should return</expected_return>
<integration>How to use returned data</integration>
</route>
</routing_template>
<context_levels>
<level_1 usage="80%">Complete isolation - only task description</level_1>
<level_2 usage="20%">Filtered context - relevant background only</level_2>
<level_3 usage="rare">Windowed context - recent history included</level_3>
</context_levels>
<checkpoint>Routing logic complete, context strategy defined, @ symbols used correctly</checkpoint>
</stage>
<stage id="5" name="AddValidation">
<action>Implement validation gates and quality checkpoints</action>
<prerequisites>Core workflow and routing complete</prerequisites>
<process>
1. Add validation section with pre_flight and post_flight checks
2. Insert checkpoints after critical stages
3. Define success criteria and metrics
4. Add failure handling for each stage
5. Implement quality standards section
</process>
<validation_patterns>
<pre_flight>Prerequisites check before execution</pre_flight>
<stage_checkpoints>Validation after each critical stage</stage_checkpoints>
<post_flight>Final quality verification</post_flight>
<scoring>Numeric scoring with thresholds (e.g., 8+ to proceed)</scoring>
</validation_patterns>
<checkpoint>Validation gates added, quality metrics defined, failure handling complete</checkpoint>
</stage>
<stage id="6" name="OptimizeContext">
<action>Add context engineering section for dynamic allocation</action>
<prerequisites>Routing and validation complete</prerequisites>
<applicability>Complex prompts with multi-agent coordination</applicability>
<process>
1. Add context_engineering section
2. Define determine_context_level function with logic
3. Define prepare_context function for each level
4. Add integration patterns for context providers
5. Document context efficiency metrics
</process>
<functions_to_add>
<determine_context_level>
Logic-based function that returns context level based on task type and complexity
</determine_context_level>
<prepare_context>
Specifications for what to include at each context level
</prepare_context>
<integrate_responses>
How to handle and use subagent responses
</integrate_responses>
</functions_to_add>
<checkpoint>Context functions defined, allocation logic clear, efficiency measurable</checkpoint>
</stage>
<stage id="7" name="ValidateOptimization">
<action>Validate complete optimized prompt against research patterns</action>
<prerequisites>All optimization stages complete</prerequisites>
<process>
1. Re-score against 10-point criteria
2. Verify component ratios
3. Test routing logic for completeness
4. Check context management implementation
5. Validate workflow executability
6. Calculate expected performance improvements
</process>
<validation_criteria>
<structure_score>Component order and ratios optimal (8+/10)</structure_score>
<routing_score>Routing logic complete and executable (if applicable)</routing_score>
<context_score>Context management strategy defined (if applicable)</context_score>
<workflow_score>Multi-stage workflow with checkpoints (8+/10)</workflow_score>
<usability_score>Ready for deployment without modification (9+/10)</usability_score>
</validation_criteria>
<performance_calculation>
<component_reordering>12-17% gain from optimal sequence</component_reordering>
<routing_improvement>20% with LLM-based decisions</routing_improvement>
<consistency_gain>25% with structured XML</consistency_gain>
<context_efficiency>80% reduction in unnecessary context</context_efficiency>
</performance_calculation>
<checkpoint>Score 8+/10, performance gains calculated, ready for delivery</checkpoint>
</stage>
<stage id="8" name="DeliverOptimized">
<action>Present optimized prompt with analysis and implementation guide</action>
<prerequisites>Validation passed with 8+/10 score</prerequisites>
<output_format>
## Optimization Analysis
**Original Score**: X/10
**Optimized Score**: Y/10
**Improvement**: +Z points
**Complexity Level**: [simple | moderate | complex]
**Key Optimizations Applied**:
- Component reordering: [details]
- Workflow enhancement: [details]
- Routing logic: [details] (if applicable)
- Context management: [details] (if applicable)
- Validation gates: [details]
**Expected Performance Gains**:
- Routing accuracy: +X%
- Consistency: +X%
- Context efficiency: +X%
- Overall performance: +X%
---
## Optimized Prompt
[Full optimized prompt in XML format]
---
## Implementation Notes
**Deployment Readiness**: [Ready | Needs Testing | Requires Customization]
**Key Features**:
- [List of key capabilities added]
**Usage Guidelines**:
- [How to use the optimized prompt]
**Customization Points**:
- [Where users might need to adjust for their use case]
</output_format>
</stage>
</workflow_execution>
</instructions>
<proven_patterns>
@ -77,45 +284,46 @@ description: "Research-backed XML prompt optimizer delivering 20% performance im
<routing_patterns>
<subagent_references>Always use @ symbol (e.g., @context-provider, @research-assistant-agent)</subagent_references>
<delegation_syntax>Route to @[agent-name] when [condition]</delegation_syntax>
<context_specification>Always specify context_level for each route</context_specification>
<return_specification>Define expected_return for every subagent call</return_specification>
</routing_patterns>
<workflow_patterns>
<stage_structure>id, name, action, prerequisites, process, checkpoint, outputs</stage_structure>
<decision_trees>Use if/else logic with clear conditions</decision_trees>
<validation_gates>Checkpoints with numeric thresholds (e.g., 8+ to proceed)</validation_gates>
<failure_handling>Define what happens when validation fails</failure_handling>
</workflow_patterns>
</proven_patterns>
<output_template>
## Analysis Results
- Current Structure Score: [X/10]
- Optimization Opportunities: [LIST]
- Expected Performance Gain: [X%]
## Optimized Prompt Structure
```xml
<context>
[HIERARCHICAL CONTEXT: system→domain→task→execution]
</context>
<role>[AGENT IDENTITY - 5-10% of prompt]</role>
<task>[PRIMARY OBJECTIVE]</task>
<instructions>
[WORKFLOW WITH ROUTING USING @ SYMBOLS]
</instructions>
[ADDITIONAL COMPONENTS AS NEEDED]
```
## Implementation Notes
- Component reordering impact: +[X]% performance
- Context management efficiency: [X]% reduction
- Routing accuracy improvement: +[X]%
- Subagent references: @agent-name format maintained
</output_template>
<quality_principles>
<quality_standards>
<research_based>Stanford multi-instruction study + Anthropic XML research</research_based>
<performance_focused>Measurable 20% routing improvement</performance_focused>
<performance_focused>Measurable 20% routing improvement minimum</performance_focused>
<context_efficient>80% reduction in unnecessary context</context_efficient>
<immediate_usability>Ready for deployment without modification</immediate_usability>
</quality_principles>
<executable_logic>All routing and decision logic is implementable</executable_logic>
</quality_standards>
<validation>
<pre_flight>Target file exists, prompt content readable, complexity assessable</pre_flight>
<post_flight>Score 8+/10, all applicable stages complete, performance gains calculated</post_flight>
</validation>
<performance_metrics>
<baseline>Original prompt performance and structure score</baseline>
<optimized>Improved score with specific gains in routing, consistency, context efficiency</optimized>
<expected_improvements>
<routing_accuracy>+20% with LLM-based decisions and @ symbol routing</routing_accuracy>
<consistency>+25% with structured XML component ordering</consistency>
<context_efficiency>80% reduction in unnecessary context data</context_efficiency>
<position_sensitivity>12-17% gain from optimal component sequence</position_sensitivity>
</expected_improvements>
</performance_metrics>
<principles>
<systematic_optimization>Follow 8-stage workflow for consistent results</systematic_optimization>
<complexity_aware>Apply appropriate level of optimization based on prompt complexity</complexity_aware>
<research_backed>Every optimization grounded in Stanford/Anthropic research</research_backed>
<executable_focus>Transform static instructions into dynamic, executable workflows</executable_focus>
<context_conscious>Minimize context while maximizing effectiveness</context_conscious>
</principles>