@ckelsoe/prompt-architect 3.0.0

package/skills/prompt-architect/references/frameworks/rtf.md

@@ -0,0 +1,358 @@
+# RTF Framework
+
+## Overview
+
+RTF is the simplest prompting framework, focusing on Role, Task, and Format. It's ideal for straightforward, well-defined tasks where minimal context is needed and the primary concern is output formatting.
+
+## Components
+
+### R - Role
+**Purpose:** Define the expertise or perspective needed.
+
+**Questions to Ask:**
+- What expertise is required?
+- What viewpoint matters?
+
+**Examples:**
+- "You are a technical writer..."
+- "Act as a Python expert..."
+- "You're a hiring manager..."
+
+### T - Task
+**Purpose:** State what needs to be done clearly and concisely.
+
+**Questions to Ask:**
+- What exactly needs to be done?
+- What's the deliverable?
+- What's the core action?
+
+**Examples:**
+- "Write a function that sorts a list..."
+- "Create a job description for..."
+- "Explain how authentication works..."
+
+### F - Format
+**Purpose:** Specify how the output should be structured.
+
+**Questions to Ask:**
+- What format should output take?
+- How should it be structured?
+- What's the preferred presentation?
+- Any specific formatting requirements?
+
+**Examples:**
+- "Provide as a markdown table..."
+- "Format as JSON with fields..."
+- "Write as a bullet list with..."
+
+## Template Structure
+
+```
+ROLE: [Expertise or perspective]
+
+TASK: [What needs to be done]
+
+FORMAT: [How output should be structured]
+```
+
+## Complete Examples
+
+### Example 1: Code Generation
+
+**Before RTF:**
+"Write a sorting function."
+
+**After RTF:**
+```
+ROLE: You are a Python developer who writes clean, efficient code.
+
+TASK: Write a function that sorts a list of dictionaries by a specified key, with support for ascending/descending order.
+
+FORMAT: Provide the solution as:
+1. Function signature with type hints
+2. Docstring with examples
+3. Implementation
+4. 2-3 usage examples
+```
+
+### Example 2: Content Creation
+
+**Before RTF:**
+"Write about API security."
+
+**After RTF:**
+```
+ROLE: You are a technical documentation specialist.
+
+TASK: Create a quick reference guide for API authentication best practices, covering OAuth 2.0, JWT, and API keys.
+
+FORMAT: Structured as:
+- Title
+- One-paragraph overview
+- Three sections (one per auth method) with:
+  * When to use
+  * Pros and cons (bullet points)
+  * Implementation example
+- Resources section with links
+```
+
+### Example 3: Data Presentation
+
+**Before RTF:**
+"Show me the comparison."
+
+**After RTF:**
+```
+ROLE: You are a data analyst presenting to executives.
+
+TASK: Compare three cloud providers (AWS, Azure, GCP) across cost, performance, and features for a mid-size company.
+
+FORMAT: Provide as:
+- Markdown table with providers as columns
+- Rows: Cost (tier 1-3), Performance metrics, Key features, Pros, Cons
+- Below table: 2-3 sentence recommendation
+- Keep total output under 300 words
+```
+
+## Best Use Cases
+
+1. **Quick Tasks**
+   - Simple explanations
+   - Short code snippets
+   - Brief comparisons
+   - Format conversions
+
+2. **Format-Critical Tasks**
+   - When output structure is primary concern
+   - Template filling
+   - Structured data generation
+   - Report formatting
+
+3. **Well-Defined Problems**
+   - Requirements are clear
+   - No ambiguity
+   - Standard approach exists
+   - Minimal context needed
+
+4. **One-Off Requests**
+   - Not part of larger workflow
+   - Standalone task
+   - Doesn't need extensive setup
+
+## Selection Criteria
+
+**Choose RTF when:**
+- ✅ Task is simple and well-defined
+- ✅ Minimal context required
+- ✅ Output format is primary concern
+- ✅ Quick, focused execution needed
+- ✅ No complex methodology required
+- ✅ One-off or standalone task
+
+**Avoid RTF when:**
+- ❌ Complex multi-step process (use RISEN)
+- ❌ Rich context needed (use CO-STAR)
+- ❌ Audience/tone matters (use CO-STAR)
+- ❌ Specific methodology required (use RISEN)
+- ❌ Input transformation needed (use RISE)
+
+## Common Mistakes
+
+1. **Insufficient Task Description**
+   - Be specific about what's needed
+   - Include key requirements
+   - Define scope clearly
+
+2. **Vague Format Requirements**
+   - Specify exact structure
+   - Mention required sections
+   - Define length/detail level
+
+3. **Missing Role Context**
+   - Even simple tasks benefit from role
+   - Expertise level affects output
+   - Don't skip role definition
+
+4. **Using RTF for Complex Tasks**
+   - If you need more than 3-4 sentences per component
+   - Switch to more comprehensive framework
+
+## RTF Variations
+
+### Minimal RTF
+For very simple tasks:
+```
+As a [ROLE], [TASK] in [FORMAT].
+```
+
+Example:
+```
+As a Python developer, write a function to validate email addresses in a code block with docstring.
+```
+
+### Extended RTF
+When slightly more detail needed:
+```
+ROLE: [Expertise]
+
+TASK: [What needs doing]
+
+REQUIREMENTS:
+- [Key requirement 1]
+- [Key requirement 2]
+
+FORMAT: [Output structure]
+```
+
+### RTF with Examples
+When showing examples helps:
+```
+ROLE: [Expertise]
+
+TASK: [What needs doing]
+
+EXAMPLES OF GOOD OUTPUT:
+[Show 1-2 examples]
+
+FORMAT: [Follow this structure]
+```
+
+## When to Upgrade from RTF
+
+**Upgrade to RISE if:**
+- Need to specify input characteristics
+- Processing steps matter
+- Input → output transformation
+
+**Upgrade to RISEN if:**
+- Multiple steps required
+- Need constraints/boundaries
+- Methodology matters
+- Success criteria complex
+
+**Upgrade to CO-STAR if:**
+- Audience considerations important
+- Tone/style matter
+- Rich context needed
+- Content creation task
+
+## Quick Reference
+
+| Component | Focus | Key Question |
+|-----------|-------|--------------|
+| Role | Expertise | "Who should do this?" |
+| Task | Action | "What needs to be done?" |
+| Format | Structure | "How should it look?" |
+
+## Format Specification Best Practices
+
+### Good Format Specifications:
+```
+FORMAT:
+Return as JSON with structure:
+{
+  "summary": "1-2 sentence overview",
+  "items": [
+    {
+      "name": "string",
+      "priority": "high|medium|low",
+      "details": "string"
+    }
+  ],
+  "total_count": number
+}
+```
+
+```
+FORMAT:
+Markdown document with:
+- H1 title
+- Brief intro paragraph
+- 3-5 H2 sections, each with:
+  * 2-3 paragraphs
+  * Bullet points for key takeaways
+- Conclusion paragraph
+- Total length: 500-700 words
+```
+
+### Poor Format Specifications:
+```
+FORMAT: Make it nice
+```
+
+```
+FORMAT: JSON or something
+```
+
+## Real-World Examples
+
+### API Documentation
+```
+ROLE: Senior API documentation writer
+
+TASK: Document the POST /users endpoint that creates a new user account with email, password, and optional profile data.
+
+FORMAT:
+Structure as:
+- Endpoint details (method, path, auth required)
+- Request body parameters (table: name, type, required, description)
+- Response codes (200, 400, 409 with meanings)
+- Example request (curl)
+- Example response (JSON)
+- Notes section for special behaviors
+```
+
+### Code Review Comment
+```
+ROLE: Experienced code reviewer
+
+TASK: Review this function for security vulnerabilities and performance issues. Identify specific problems and suggest fixes.
+
+FORMAT:
+For each issue found:
+🔴 ISSUE: [Brief title]
+LINE: [Line number]
+PROBLEM: [What's wrong]
+FIX: [How to fix it]
+SEVERITY: [High/Medium/Low]
+
+End with overall assessment (2-3 sentences).
+```
+
+### Meeting Summary
+```
+ROLE: Executive assistant
+
+TASK: Summarize this meeting transcript, focusing on decisions made and action items.
+
+FORMAT:
+Meeting Summary: [Title]
+Date: [Date]
+
+KEY DECISIONS:
+- [Decision 1]
+- [Decision 2]
+
+ACTION ITEMS:
+- [ ] [Task] - Assigned to [Person] - Due: [Date]
+
+DISCUSSION POINTS:
+- [Topic 1]: [Brief summary]
+
+NEXT STEPS:
+[What happens next]
+```
+
+## Assessment Checklist
+
+When applying RTF, verify:
+- [ ] Role defines clear expertise
+- [ ] Task is specific and unambiguous
+- [ ] Task scope is well-defined
+- [ ] Format requirements are detailed
+- [ ] Format is appropriate for task
+- [ ] All three components work together
+- [ ] Task isn't too complex for RTF
+- [ ] No need for richer framework
+- [ ] Output structure is clear
+- [ ] Length/detail level specified

package/skills/prompt-architect/references/frameworks/self-refine.md

@@ -0,0 +1,205 @@
+# Self-Refine Framework
+
+## Overview
+
+Self-Refine is an iterative output improvement framework where a single model acts as its own generator, critic, and refiner — with no external training, no additional models, and no labeled data required. The core loop: generate an initial output → produce specific, actionable feedback → refine using that feedback → repeat until a stopping criterion is met.
+
+**Research basis:** "Self-Refine: Iterative Refinement with Self-Feedback" (Madaan et al., arXiv 2303.17651, NeurIPS 2023). Tested across 7 task types — improvement of 5-40% over single-pass generation from GPT-3.5 and GPT-4. Humans preferred Self-Refined outputs in blind evaluation. Project site: selfrefine.info.
+
+## The Core Loop
+
+```
+GENERATE → FEEDBACK → REFINE → [repeat] → STOP
+```
+
+Each phase:
+1. **Generate**: Produce an initial output (can be your first draft or AI-generated)
+2. **Feedback**: Analyze the output for specific, actionable weaknesses across defined dimensions
+3. **Refine**: Rewrite addressing every feedback point — with the feedback visible as context
+4. **Stop**: When quality threshold met, max iterations reached, or feedback says "looks good"
+
+**Key insight:** Maintaining a history of previous outputs + feedback in context prevents regression and helps the model track progress across iterations.
+
+## Components
+
+### Initial Output
+**Purpose:** The starting point. Can be a first AI generation or something you've already written that needs improvement.
+
+### Feedback Dimensions
+**Purpose:** The specific aspects to evaluate. Defining these explicitly produces much better critiques than asking for generic feedback.
+
+**Common dimensions by task type:**
+- **Code**: correctness, efficiency, readability, edge cases, error handling
+- **Writing**: clarity, structure, tone, specificity, conciseness, audience fit
+- **Reasoning**: logical validity, completeness, unsupported claims, missed considerations
+- **Plans/strategies**: feasibility, completeness, risks, measurability
+
+### Refinement Instruction
+**Purpose:** Directs the model to rewrite addressing every feedback point, using the critique as a direct specification.
+
+### Stop Condition
+**Purpose:** When to stop iterating. Options:
+- Fixed iterations (e.g., "run 2 refinement cycles")
+- Quality signal ("stop when feedback has no major issues")
+- Manual review (you decide when it's good enough)
+
+## Template Structure
+
+### Single Cycle (most common)
+```
+INITIAL OUTPUT:
+[Paste the output to improve, or ask the AI to generate a first draft]
+
+FEEDBACK DIMENSIONS:
+Review the output above for:
+1. [Dimension 1 — e.g., "Clarity: Is every sentence clear and unambiguous?"]
+2. [Dimension 2 — e.g., "Completeness: What important points are missing?"]
+3. [Dimension 3 — e.g., "Tone: Is the voice appropriate for the audience?"]
+4. [Dimension 4 — add as needed]
+
+For each dimension: identify specific problems with quoted examples,
+explain why each is a problem, and suggest concrete improvements.
+
+REFINEMENT:
+Now rewrite the output addressing every point of your feedback.
+Show the refined version only (no commentary).
+```
+
+### Multi-Cycle with History
+```
+ITERATION 1:
+[Generate initial output or paste existing]
+
+ITERATION 1 FEEDBACK:
+Analyze for [dimensions]. Be specific and actionable.
+
+ITERATION 2:
+Rewrite addressing all feedback above.
+[AI produces refined version]
+
+ITERATION 2 FEEDBACK:
+Analyze the refined version for any remaining issues.
+
+ITERATION 3 (if needed):
+Rewrite addressing remaining issues.
+
+STOP when feedback says "no major issues remaining."
+```
+
+### Self-Refine as a Single Compound Prompt
+```
+TASK: [What you want to produce]
+
+GENERATE: Write an initial [output type] for the above.
+
+FEEDBACK: Review your output for: [dimension 1], [dimension 2], [dimension 3].
+List specific issues with quoted examples and concrete suggestions.
+
+REFINE: Rewrite addressing all feedback. Show only the final refined version.
+```
+
+## Complete Examples
+
+### Example 1: Code Review and Improvement
+
+```
+INITIAL OUTPUT:
+def get_user_data(user_id):
+    db = connect_to_database()
+    result = db.query(f"SELECT * FROM users WHERE id = {user_id}")
+    return result
+
+FEEDBACK DIMENSIONS:
+Review for:
+1. Security: Any injection vulnerabilities or unsafe patterns?
+2. Error handling: What happens if the DB is unavailable or user doesn't exist?
+3. Resource management: Are connections properly managed?
+4. Code quality: Any Python best practices violations?
+
+REFINEMENT:
+Rewrite the function addressing all feedback points.
+```
+
+### Example 2: Writing Improvement
+
+```
+INITIAL OUTPUT:
+[Paste a paragraph or email draft]
+
+FEEDBACK DIMENSIONS:
+Review for:
+1. Clarity: Any sentences that are ambiguous or require re-reading?
+2. Conciseness: What can be cut without losing meaning?
+3. Opening: Does the first sentence earn the reader's attention?
+4. Call to action: Is the desired reader action explicit and easy to take?
+
+REFINEMENT:
+Rewrite addressing every point. Match the original length or shorter.
+```
+
+### Example 3: Strategic Plan
+
+```
+INITIAL OUTPUT:
+[Paste a strategy or plan]
+
+FEEDBACK DIMENSIONS:
+Review for:
+1. Completeness: What important scenarios or stakeholders are not addressed?
+2. Feasibility: Which actions assume resources or capabilities we may not have?
+3. Measurability: Which outcomes have no defined success metric?
+4. Risk: What's the biggest single point of failure?
+
+REFINEMENT:
+Revise the plan addressing all feedback. Add a risk mitigation note for the
+biggest single point of failure identified.
+```
+
+## Best Use Cases
+
+1. **Any Output Quality Improvement**
+   - Code, writing, plans, analysis, summaries
+   - When the first draft is never the final draft
+
+2. **Domain-Specific Quality Gates**
+   - Code correctness + security
+   - Medical/legal content accuracy
+   - Brand voice compliance
+
+3. **Iterative Document Refinement**
+   - Proposals, reports, documentation
+   - Any output where multiple review dimensions apply
+
+4. **Self-QA Before Submitting**
+   - Run Self-Refine before using any AI output in high-stakes contexts
+
+## Selection Criteria
+
+**Choose Self-Refine when:**
+- ✅ You have an output that needs improvement
+- ✅ Multiple quality dimensions apply
+- ✅ The first pass is rarely final
+- ✅ You want systematic critique, not just vague "make it better"
+
+**Avoid when:**
+- ❌ You need a specific type of critique → use CAI Critique-Revise (principle-based) or Devil's Advocate (opposing argument)
+- ❌ Task is brand new (nothing to refine yet) → generate first, then Self-Refine
+- ❌ Simple task → direct prompt is faster
+
+## Self-Refine vs. Similar Frameworks
+
+| | Self-Refine | CAI Critique-Revise | BAB | Chain of Density |
+|---|---|---|---|---|
+| Direction | Any output → improvement | Output vs. explicit principle | Before state → after state | Content → denser compression |
+| Critique type | Multi-dimensional quality | Principle-aligned alignment | Transformation rules | Density/information |
+| Iterations | Configurable loop | One cycle (or more) | Single transform | N passes |
+| Best for | General quality improvement | Alignment/compliance | Rewriting existing content | Summarization |
+
+## Quick Reference
+
+| Phase | Purpose | Key Question |
+|-------|---------|--------------|
+| Generate | Initial output | "What's a first pass?" |
+| Feedback | Specific critique | "What's wrong and why?" |
+| Refine | Improved version | "Fix every problem found" |
+| Stop | Termination | "Is it good enough?" |