Initial commit

2025-11-29 18:28:34 +08:00
commit 390afca02b
220 changed files with 86013 additions and 0 deletions
--- a/skills/prompt-engineering/SKILL.md
+++ b/skills/prompt-engineering/SKILL.md
@@ -0,0 +1,302 @@
+---
+name: prompt-engineering
+category: backend
+tags: [prompt-engineering, few-shot-learning, chain-of-thought, optimization, templates, system-prompts, llm-performance, ai-patterns]
+version: 1.0.0
+description: This skill should be used when creating, optimizing, or implementing advanced prompt patterns including few-shot learning, chain-of-thought reasoning, prompt optimization workflows, template systems, and system prompt design. It provides comprehensive frameworks for building production-ready prompts with measurable performance improvements.
+---
+
+# Prompt Engineering
+
+This skill provides comprehensive frameworks for creating, optimizing, and implementing advanced prompt patterns that significantly improve LLM performance across various tasks and models.
+
+## When to Use This Skill
+
+Use this skill when:
+- Creating new prompts for complex reasoning or analytical tasks
+- Optimizing existing prompts for better accuracy or efficiency
+- Implementing few-shot learning with strategic example selection
+- Designing chain-of-thought reasoning for multi-step problems
+- Building reusable prompt templates and systems
+- Developing system prompts for consistent model behavior
+- Troubleshooting poor prompt performance or failure modes
+- Scaling prompt systems for production use cases
+
+## Core Prompt Engineering Patterns
+
+### 1. Few-Shot Learning Implementation
+
+Select examples using semantic similarity and diversity sampling to maximize learning within context window constraints.
+
+#### Example Selection Strategy
+- Use `references/few-shot-patterns.md` for comprehensive selection frameworks
+- Balance example count (3-5 optimal) with context window limitations
+- Include edge cases and boundary conditions in example sets
+- Prioritize diverse examples that cover problem space variations
+- Order examples from simple to complex for progressive learning
+
+#### Few-Shot Template Structure
+```
+Example 1 (Basic case):
+Input: {representative_input}
+Output: {expected_output}
+
+Example 2 (Edge case):
+Input: {challenging_input}
+Output: {robust_output}
+
+Example 3 (Error case):
+Input: {problematic_input}
+Output: {corrected_output}
+
+Now handle: {target_input}
+```
+
+### 2. Chain-of-Thought Reasoning
+
+Elicit step-by-step reasoning for complex problem-solving through structured thinking patterns.
+
+#### Implementation Patterns
+- Reference `references/cot-patterns.md` for detailed reasoning frameworks
+- Use "Let's think step by step" for zero-shot CoT initiation
+- Provide complete reasoning traces for few-shot CoT demonstrations
+- Implement self-consistency by sampling multiple reasoning paths
+- Include verification and validation steps in reasoning chains
+
+#### CoT Template Structure
+```
+Let's approach this step-by-step:
+
+Step 1: {break_down_the_problem}
+Analysis: {detailed_reasoning}
+
+Step 2: {identify_key_components}
+Analysis: {component_analysis}
+
+Step 3: {synthesize_solution}
+Analysis: {solution_justification}
+
+Final Answer: {conclusion_with_confidence}
+```
+
+### 3. Prompt Optimization Workflows
+
+Implement iterative refinement processes with measurable performance metrics and systematic A/B testing.
+
+#### Optimization Process
+- Use `references/optimization-frameworks.md` for comprehensive optimization strategies
+- Measure baseline performance before optimization attempts
+- Implement single-variable changes for accurate attribution
+- Track metrics: accuracy, consistency, latency, token efficiency
+- Use statistical significance testing for A/B validation
+- Document optimization iterations and their impacts
+
+#### Performance Metrics Framework
+- **Accuracy**: Task completion rate and output correctness
+- **Consistency**: Response stability across multiple runs
+- **Efficiency**: Token usage and response time optimization
+- **Robustness**: Performance across edge cases and variations
+- **Safety**: Adherence to guidelines and harm prevention
+
+### 4. Template Systems Architecture
+
+Build modular, reusable prompt components with variable interpolation and conditional sections.
+
+#### Template Design Principles
+- Reference `references/template-systems.md` for modular template frameworks
+- Use clear variable naming conventions (e.g., `{user_input}`, `{context}`)
+- Implement conditional sections for different scenario handling
+- Design role-based templates for specific use cases
+- Create hierarchical template composition patterns
+
+#### Template Structure Example
+```
+# System Context
+You are a {role} with {expertise_level} expertise in {domain}.
+
+# Task Context
+{if background_information}
+Background: {background_information}
+{endif}
+
+# Instructions
+{task_instructions}
+
+# Examples
+{example_count}
+
+# Output Format
+{output_specification}
+
+# Input
+{user_query}
+```
+
+### 5. System Prompt Design
+
+Design comprehensive system prompts that establish consistent model behavior, output formats, and safety constraints.
+
+#### System Prompt Components
+- Use `references/system-prompt-design.md` for detailed design guidelines
+- Define clear role specification and expertise boundaries
+- Establish output format requirements and structural constraints
+- Include safety guidelines and content policy adherence
+- Set context for background information and domain knowledge
+
+#### System Prompt Framework
+```
+You are an expert {role} specializing in {domain} with {experience_level} of experience.
+
+## Core Capabilities
+- List specific capabilities and expertise areas
+- Define scope of knowledge and limitations
+
+## Behavioral Guidelines
+- Specify interaction style and communication approach
+- Define error handling and uncertainty protocols
+- Establish quality standards and verification requirements
+
+## Output Requirements
+- Specify format expectations and structural requirements
+- Define content inclusion and exclusion criteria
+- Establish consistency and validation requirements
+
+## Safety and Ethics
+- Include content policy adherence
+- Specify bias mitigation requirements
+- Define harm prevention protocols
+```
+
+## Implementation Workflows
+
+### Workflow 1: Create New Prompt from Requirements
+
+1. **Analyze Requirements**
+   - Identify task complexity and reasoning requirements
+   - Determine target model capabilities and limitations
+   - Define success criteria and evaluation metrics
+   - Assess need for few-shot learning or CoT reasoning
+
+2. **Select Pattern Strategy**
+   - Use few-shot learning for classification or transformation tasks
+   - Apply CoT for complex reasoning or multi-step problems
+   - Implement template systems for reusable prompt architecture
+   - Design system prompts for consistent behavior requirements
+
+3. **Draft Initial Prompt**
+   - Structure prompt with clear sections and logical flow
+   - Include relevant examples or reasoning demonstrations
+   - Specify output format and quality requirements
+   - Incorporate safety guidelines and constraints
+
+4. **Validate and Test**
+   - Test with diverse input scenarios including edge cases
+   - Measure performance against defined success criteria
+   - Iterate refinement based on testing results
+   - Document optimization decisions and their rationale
+
+### Workflow 2: Optimize Existing Prompt
+
+1. **Performance Analysis**
+   - Measure current prompt performance metrics
+   - Identify failure modes and error patterns
+   - Analyze token efficiency and response latency
+   - Assess consistency across multiple runs
+
+2. **Optimization Strategy**
+   - Apply systematic A/B testing with single-variable changes
+   - Use few-shot learning to improve task adherence
+   - Implement CoT reasoning for complex task components
+   - Refine template structure for better clarity
+
+3. **Implementation and Testing**
+   - Deploy optimized prompts with controlled rollout
+   - Monitor performance metrics in production environment
+   - Compare against baseline using statistical significance
+   - Document improvements and lessons learned
+
+### Workflow 3: Scale Prompt Systems
+
+1. **Modular Architecture Design**
+   - Decompose complex prompts into reusable components
+   - Create template inheritance hierarchies
+   - Implement dynamic example selection systems
+   - Build automated quality assurance frameworks
+
+2. **Production Integration**
+   - Implement prompt versioning and rollback capabilities
+   - Create performance monitoring and alerting systems
+   - Build automated testing frameworks for prompt validation
+   - Establish update and deployment workflows
+
+## Quality Assurance
+
+### Validation Requirements
+- Test prompts with at least 10 diverse scenarios
+- Include edge cases, boundary conditions, and failure modes
+- Verify output format compliance and structural consistency
+- Validate safety guideline adherence and harm prevention
+- Measure performance across multiple model runs
+
+### Performance Standards
+- Achieve >90% task completion for well-defined use cases
+- Maintain <5% variance across multiple runs for consistency
+- Optimize token usage without sacrificing accuracy
+- Ensure response latency meets application requirements
+- Demonstrate robust handling of edge cases and unexpected inputs
+
+## Integration with Other Skills
+
+This skill integrates seamlessly with:
+- **langchain4j-ai-services-patterns**: Interface-based prompt design
+- **langchain4j-rag-implementation-patterns**: Context-enhanced prompting
+- **langchain4j-testing-strategies**: Prompt validation frameworks
+- **unit-test-parameterized**: Systematic prompt testing approaches
+
+## Resources and References
+
+- `references/few-shot-patterns.md`: Comprehensive few-shot learning frameworks
+- `references/cot-patterns.md`: Chain-of-thought reasoning patterns and examples
+- `references/optimization-frameworks.md`: Systematic prompt optimization methodologies
+- `references/template-systems.md`: Modular template design and implementation
+- `references/system-prompt-design.md`: System prompt architecture and best practices
+
+## Usage Examples
+
+### Example 1: Classification Task with Few-Shot Learning
+```
+Classify customer feedback into categories using semantic similarity for example selection and diversity sampling for edge case coverage.
+```
+
+### Example 2: Complex Reasoning with Chain-of-Thought
+```
+Implement step-by-step reasoning for financial analysis with verification steps and confidence scoring.
+```
+
+### Example 3: Template System for Customer Service
+```
+Create modular templates with role-based components and conditional sections for different inquiry types.
+```
+
+### Example 4: System Prompt for Code Generation
+```
+Design comprehensive system prompt with behavioral guidelines, output requirements, and safety constraints.
+```
+
+## Common Pitfalls and Solutions
+
+- **Overfitting examples**: Use diverse example sets with semantic variety
+- **Context window overflow**: Implement strategic example selection and compression
+- **Inconsistent outputs**: Specify clear output formats and validation requirements
+- **Poor generalization**: Include edge cases and boundary conditions in training examples
+- **Safety violations**: Incorporate comprehensive content policies and harm prevention
+
+## Performance Optimization
+
+- Monitor token usage and implement compression strategies
+- Use caching for repeated prompt components
+- Optimize example selection for maximum learning efficiency
+- Implement progressive disclosure for complex prompt systems
+- Balance prompt complexity with response quality requirements
+
+This skill provides the foundational patterns and methodologies for building production-ready prompt systems that consistently deliver high performance across diverse use cases and model types.