技能元提示
- 作者仓库星标 3,406
- 作者仓库 claude-octopus
- 领域
- 人工智能
- 作者声明的智能体
- 未找到明确声明;不据此推断已兼容或已测试
- 静态检查
- 88 / 100 · 启发式扫描,不代表运行安全
- 运行环境证据
- 未执行;当前没有隔离运行测试证据
- 作者 / 版本 / 许可证
- @nyldn · 未声明许可证
- 上下文用量评级
- 较高消耗
- 接入复杂程度
- 需简单配置
- 是否需要外部接口密钥
- 不需要
- 兼容的系统
- 未声明(默认跨平台)
- 运行环境要求
- Python
- 检测到的文件与系统行为
-
- 只读
- 允许写入 / 修改
- 命令执行
- 网络行为
- 仅限本地
- 安装命令数
- 无(仅作为资料)
需要注意: 未声明工具权限范围;实际权限由运行环境决定。
第 2-4 阶段:分析与设计
收集需求后,进行内部分析:
> **Host: Codex CLI** — This skill was designed for Claude Code and adapted for Codex.
> Cross-reference commands use installed skill names in Codex rather than `/octo:*` slash commands.
> Use the active Codex shell and subagent tools. Do not claim a provider, model, or host subagent is available until the current session exposes it.
> For host tool equivalents, see `skills/blocks/codex-host-adapter.md`.
# Meta-Prompt Generator Skill
## Overview
Generate well-structured, verifiable prompts for any use case. Applies proven meta-prompting techniques to minimize hallucination and maximize effectiveness.
```
┌─────────────────────────────────────────────────────────────────────────────┐
│ META-PROMPT GENERATION │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ Phase 1: Requirement Gathering │
│ → Understand the primary goal/role │
│ → Clarify expected outputs │
│ → Identify accuracy requirements │
│ ↓ │
│ Phase 2: Task Analysis │
│ → Apply Technique 1: Task Decomposition │
│ → Identify if complex enough for subtasks │
│ → Map dependencies between subtasks │
│ ↓ │
│ Phase 3: Expert Assignment │
│ → Apply Technique 5: Specialized Experts │
│ → Assign personas to subtasks │
│ → Apply Technique 2: Fresh Eyes Review │
│ ↓ │
│ Phase 4: Verification Design │
│ → Apply Technique 3: Iterative Verification │
│ → Build in checking steps │
│ → Apply Technique 4: No Guessing │
│ ↓ │
│ Phase 5: Prompt Assembly │
│ → Structure: Role, Context, Instructions, Constraints, Format │
│ → Add verification hooks │
│ → Include uncertainty disclaimers │
│ ↓ │
│ Phase 6: Output & Iteration │
│ → Present generated prompt │
│ → Offer refinement │
│ │
└─────────────────────────────────────────────────────────────────────────────┘
```
## The Five Techniques
### Technique 1: Task Decomposition
**What:** Break complex tasks into smaller, manageable subtasks.
**When to use:**
- Task has multiple distinct steps
- Different expertise needed for different parts
- Risk of getting lost in complexity
**How to apply:**
1. List all components of the task
2. Identify dependencies (what must happen first)
3. Group related components
4. Order by logical sequence
**Example:**
```
Task: "Create a technical blog post about OAuth 2.0"
Decomposition:
1. Research Phase
- Gather OAuth 2.0 specifications
- Find common implementation examples
- Identify security best practices
2. Structure Phase
- Outline main sections
- Plan code examples
- Design diagrams/visuals
3. Writing Phase
- Write introduction
- Write technical sections
- Write conclusion/CTA
4. Review Phase
- Technical accuracy check
- Code example testing
- Readability review
```
### Technique 2: Fresh Eyes Review
**What:** Use different "experts" for creation vs. validation. Never use the same expert to both create and verify.
**When to use:**
- Output needs to be accurate
- Risk of blind spots from creator
- Quality assurance is critical
**How to apply:**
1. Assign Creator Expert for initial work
2. Assign different Reviewer Expert for validation
3. Reviewer should not have seen creation process
4. Loop back to Creator if issues found
**Example:**
```
Creator: "Expert Technical Writer" produces article
Reviewer: "Expert Security Engineer" verifies OAuth claims
Reviewer: "Expert Developer" tests code examples
NOT: Same expert writes AND reviews their own work
```
### Technique 3: Iterative Verification
**What:** Build explicit verification steps into the task, especially for error-prone outputs.
**When to use:**
- Mathematical calculations
- Code generation
- Factual claims
- Multi-step reasoning
**How to apply:**
1. After each significant output, add verification step
2. For calculations: "Now verify this by [alternative method]"
3. For code: "Test this code against [test cases]"
4. For claims: "Confirm this by [citing source]"
**Example:**
```
Step 1: Calculate discount price
Step 2: VERIFY - recalculate from opposite direction
Step 3: If mismatch, identify error and recalculate
Step 4: Only proceed when both methods match
```
### Technique 4: No Guessing
**What:** Never assume unverified facts. Disclaim uncertainty explicitly.
**When to use:**
- ALWAYS (this is a default behavior)
- Especially for: dates, statistics, quotes, technical specifications
**How to apply:**
1. If uncertain, say "I'm not certain about..."
2. If no data, say "I don't have information on..."
3. Ask for sources rather than inventing
4. Distinguish between "likely" and "confirmed"
**Disclaimer templates:**
```
"Note: This figure is approximate and should be verified."
"I don't have access to [specific data]. Please provide or verify."
"This is based on general patterns; your specific case may differ."
```
### Technique 5: Specialized Experts
**What:** Spawn domain-specific personas for complex subtasks.
**When to use:**
- Task requires specialized knowledge
- Different perspectives would improve quality
- Cross-functional work needed
**Available expert archetypes:**
| Expert | Use For |
|--------|---------|
| Expert Writer | Content, copy, documentation |
| Expert Mathematician | Calculations, proofs, statistics |
| Expert Python | Python code, data analysis |
| Expert Security | Security review, threat modeling |
| Expert Architect | System design, trade-offs |
| Expert Reviewer | Quality assurance, error-finding |
| Expert Strategist | Planning, prioritization |
**How to apply:**
```
"For this subtask, adopt the persona of Expert [X].
Your expertise includes [specific areas].
Focus exclusively on [your assigned task].
You have no memory of previous context—all needed information is below."
```
## Phase 1: Requirement Gathering
### Initial Prompt
```markdown
**Meta-Prompt Generator**
I'll help you create an effective, verifiable prompt.
**Questions:**
1. **What is the main goal?**
What should this prompt help someone accomplish?
2. **What's the expected output?**
(e.g., document, code, analysis, decision)
3. **How important is accuracy?**
- Critical (factual, technical, or high-stakes)
- Moderate (useful but not mission-critical)
- Flexible (creative, exploratory)
4. **Any specific constraints?**
(length, format, tone, tools available)
```
### Minimum Information Needed
- Primary goal (REQUIRED)
- Output type (REQUIRED)
- Accuracy requirements (can assume moderate)
- Constraints (optional, will use sensible defaults)
**If information is missing, ask ONE clarifying question at a time.**
## Phase 2-4: Analysis & Design
After gathering requirements, analyze internally:
### Task Complexity Assessment
| Complexity | Indicators | Approach |
|------------|------------|----------|
| **Simple** | Single step, one output | Direct prompt, no decomposition |
| **Moderate** | 2-3 steps, clear sequence | Light decomposition, one expert |
| **Complex** | 4+ steps, dependencies | Full decomposition, multiple experts |
### Expert Assignment Matrix
| Task Type | Creator Expert | Reviewer Expert |
|-----------|----------------|-----------------|
| Technical writing | Expert Writer | Expert Engineer |
| Code generation | Expert Developer | Expert Reviewer |
| Analysis | Expert Analyst | Expert Strategist |
| Creative | Expert Creative | Expert Editor |
### Verification Points
For the task, identify where verification is needed:
| Step | Risk | Verification Method |
|------|------|---------------------|
| [step] | [what could go wrong] | [how to verify] |
## Phase 5: Prompt Assembly
### Output Format
You MUST return the generated prompt in this exact format:
```markdown
# [Prompt Title]
## Role
[Short, direct role definition]
[Emphasize verification and uncertainty disclaimers]
## Context
[User's task and goals]
[Background information provided]
[Clarifications gathered]
## Instructions
### Phase 1: [First Phase Name]
1. [Step 1]
2. [Step 2]
3. **Verification:** [How to verify this phase]
### Phase 2: [Second Phase Name]
1. [Step 1]
2. [Step 2]
3. **Verification:** [How to verify this phase]
[Continue phases as needed...]
### Expert Assignments (if applicable)
- **[Expert Type]:** Handles [specific subtask]
- **[Reviewer Type]:** Validates [what they check]
## Constraints
- [Constraint 1]
- [Constraint 2]
- [Accuracy requirement: how to handle uncertainty]
## Output Format
[Specify exactly how the output should be structured]
[Include all required sections]
## Verification Checklist
Before considering complete:
- [ ] [Verification item 1]
- [ ] [Verification item 2]
- [ ] [Accuracy disclaimers added where needed]
## Examples (if provided)
[Context or examples from user]
```
## Phase 6: Output & Iteration
### Present the Prompt
```markdown
**Generated Meta-Prompt**
[The prompt in the format above]
**Techniques Applied:**
- ✓ Task Decomposition: [Yes/No, how]
- ✓ Fresh Eyes Review: [Yes/No, which experts]
- ✓ Iterative Verification: [Yes/No, where]
- ✓ No Guessing: [Where disclaimers needed]
- ✓ Specialized Experts: [Which ones assigned]
**Would you like me to:**
1. Refine any section
2. Add more verification steps
3. Adjust the complexity level
4. Execute this prompt now
```
## Example: Complete Meta-Prompt Generation
### User Request
"Create a prompt to help me write API documentation"
### Generated Prompt
```markdown
# API Documentation Generator
## Role
You are an Expert Technical Writer specializing in API documentation.
Your documentation will be reviewed by an Expert Developer for accuracy.
When uncertain about behavior, note "Verify with implementation" rather than guessing.
## Context
Creating comprehensive API documentation for developers.
Documentation should be usable without reading source code.
## Instructions
### Phase 1: API Discovery
1. List all endpoints with methods (GET, POST, etc.)
2. Document request/response schemas
3. Identify authentication requirements
4. **Verification:** Cross-reference with OpenAPI spec if available
### Phase 2: Documentation Writing
1. Write endpoint descriptions (what it does, not how)
2. Create request examples with all parameters
3. Create response examples for success and error cases
4. Document rate limits and constraints
5. **Verification:** Each example should be valid JSON/code
### Phase 3: Review Cycle
Expert Developer reviews for:
- Technical accuracy of examples
- Missing edge cases
- Unclear descriptions
### Expert Assignments
- **Expert Technical Writer:** Creates documentation prose
- **Expert Developer:** Validates examples and accuracy
## Constraints
- Use consistent terminology throughout
- Examples must be syntactically valid
- Note any undocumented or unclear behaviors
- Accuracy: Mark assumptions with "Assumed behavior - verify"
## Output Format
```markdown
# [Endpoint Name]
**Method:** [HTTP method]
**Path:** [/api/path]
**Auth:** [Required/Optional/None]
## Description
[What this endpoint does]
## Request
[Parameters, body schema, headers]
## Response
[Success and error responses with examples]
## Notes
[Rate limits, deprecation, related endpoints]
```
## Verification Checklist
- [ ] All endpoints documented
- [ ] All examples are valid
- [ ] Authentication clearly specified
- [ ] Error responses included
- [ ] Assumptions marked for verification
```
## Error Handling
### Unclear Requirements
```markdown
I need a bit more clarity to create an effective prompt.
**Specifically:**
[Question about the unclear part]
[Offer 2-3 options if applicable]
```
### Over-Complex Request
```markdown
This task has [N] distinct components. I recommend:
1. **Split into multiple prompts** - One per major component
2. **Simplify scope** - Focus on [core element] first
3. **Proceed as-is** - Full complexity, longer prompt
Which approach works best for you?
```
### Can't Apply Techniques
If techniques don't fit the task:
```markdown
ℹ️ **Note on Techniques**
This task is straightforward enough that some techniques
don't apply:
- Task Decomposition: Not needed (single step)
- Fresh Eyes: [Explain why/why not]
- Specialized Experts: Not needed (single domain)
The generated prompt focuses on clarity and verification instead.
```
## Integration
### With skill-content-pipeline
Generate prompts for content creation based on anatomy guides.
### With skill-thought-partner
Transform brainstorming insights into actionable prompts.
### With skill-prd
Enhance PRD generation with meta-prompting techniques.
### With flow-develop
Generate implementation prompts with built-in verification.
## The Bottom Line
```
Meta-prompt → Decompose → Assign experts → Build verification → Generate
Otherwise → Vague prompts → Hallucination → Unreliable output
```
**Structure breeds reliability. Verification breeds accuracy. Experts breed quality.**
章节与文件索引
按说明文件中的顺序排列。
技巧一:任务分解
技巧 2:新鲜的眼光回顾
技术 3:迭代验证
技巧 4:不要猜测
技术5:专业专家
文件/命令 -> /octo:* · skills/blocks/codex-host-adapter.md · goal/role · diagrams/visuals · conclusion/CTA · Yes/No · request/response · JSON/code
内容校验值 -> 68e8f2a09af0
当前原文的自动摘译,尚未人工审校。
技巧一:任务分解
内容:将复杂的任务分解为更小的、可管理的子任务。何时使用:任务有多个不同的步骤 不同部分需要不同的专业知识 迷失在复杂性中的风险
技巧 2:新鲜的眼光回顾
内容:使用不同的“专家”进行创建与验证。切勿使用同一位专家来创建和验证。何时使用:输出需要准确 创建者存在盲点的风险 质量保证至关重要
技术 3:迭代验证
内容:在任务中构建明确的验证步骤,特别是对于容易出错的输出。何时使用: 数学计算 代码生成 事实声明
技巧 4:不要猜测
内容:永远不要假设未经证实的事实。明确否认不确定性。何时使用:总是(这是默认行为) 特别适用于:日期、统计、报价、技术规格 如何应用:
技术5:专业专家
内容:为复杂的子任务生成特定领域的角色。何时使用: 任务需要专业知识 不同的视角可以提高质量 需要跨职能的工作