@ckelsoe/prompt-architect 3.0.0

package/skills/prompt-architect/references/frameworks/chain-of-thought.md

@@ -0,0 +1,424 @@
+# Chain of Thought (CoT) Framework
+
+## Overview
+
+Chain of Thought is a prompting technique that encourages step-by-step reasoning and makes the thinking process explicit. Instead of jumping to answers, it guides Claude to break down complex problems, show intermediate steps, and verify logic along the way.
+
+## Core Concept
+
+CoT works by:
+1. Breaking complex problems into smaller steps
+2. Making reasoning explicit at each step
+3. Showing work rather than just final answers
+4. Verifying logic progressively
+5. Enabling error detection and correction
+
+## When to Use Chain of Thought
+
+**Ideal for:**
+- Mathematical problem-solving
+- Logical reasoning tasks
+- Complex multi-step analysis
+- Debugging and troubleshooting
+- Decision-making with trade-offs
+- Tasks where "showing your work" matters
+
+**Not needed for:**
+- Simple lookups or facts
+- Straightforward transformations
+- Tasks with obvious single steps
+- Creative writing without logic requirements
+
+## Implementation Approaches
+
+### Approach 1: Explicit Instruction
+Directly instruct Claude to think step-by-step.
+
+**Example:**
+```
+Solve this problem step-by-step, showing your reasoning at each stage:
+
+A company's revenue grew 15% in Q1, decreased 8% in Q2, grew 20% in Q3, and grew 5% in Q4. If they started the year with $1M in quarterly revenue, what was their Q4 revenue?
+
+Think through this carefully:
+1. Calculate Q1 revenue
+2. Calculate Q2 revenue
+3. Calculate Q3 revenue
+4. Calculate Q4 revenue
+5. Verify your calculation
+```
+
+### Approach 2: Zero-Shot CoT
+Use trigger phrases that activate reasoning.
+
+**Magic phrases:**
+- "Let's think step by step."
+- "Let's work through this systematically."
+- "Let's break this down."
+- "Think carefully about this."
+
+**Example:**
+```
+What's the best database choice for a real-time analytics platform handling 1M events/second with complex aggregations? Let's think step by step.
+```
+
+### Approach 3: Few-Shot CoT
+Provide examples showing step-by-step reasoning.
+
+**Example:**
+```
+Example 1:
+Q: If a train travels 120 miles in 2 hours, what's its speed?
+A: Let's break this down:
+1. Speed = Distance / Time
+2. Distance = 120 miles
+3. Time = 2 hours
+4. Speed = 120 / 2 = 60 mph
+Therefore: 60 mph
+
+Example 2:
+Q: A store offers 20% off, then an additional 10% off. What's the total discount on a $100 item?
+A: Let's work through this:
+1. First discount: 20% of $100 = $20
+2. Price after first discount: $100 - $20 = $80
+3. Second discount: 10% of $80 = $8
+4. Final price: $80 - $8 = $72
+5. Total discount: $100 - $72 = $28
+6. Total discount percentage: 28/100 = 28%
+Therefore: 28% total discount (not 30%)
+
+Now solve:
+Q: [Your problem]
+A: Let's break this down:
+```
+
+### Approach 4: Structured CoT
+Provide a template for reasoning.
+
+**Example:**
+```
+Analyze whether we should migrate to microservices using this reasoning structure:
+
+STEP 1 - CURRENT STATE:
+[Describe current architecture]
+
+STEP 2 - PROBLEMS:
+[What problems exist?]
+
+STEP 3 - MICROSERVICES BENEFITS:
+[How would microservices help?]
+
+STEP 4 - MICROSERVICES COSTS:
+[What are the downsides?]
+
+STEP 5 - ALTERNATIVES:
+[What else could we do?]
+
+STEP 6 - COMPARISON:
+[Compare options systematically]
+
+STEP 7 - RECOMMENDATION:
+[Final decision with reasoning]
+```
+
+## Best Practices
+
+### 1. Be Explicit About Steps
+```
+Good:
+"Calculate the ROI step by step:
+1. Calculate total costs
+2. Calculate total revenue
+3. Calculate profit (revenue - costs)
+4. Calculate ROI (profit / costs * 100)
+5. Interpret the result"
+
+Poor:
+"Calculate the ROI"
+```
+
+### 2. Request Verification
+```
+Good:
+"After solving, verify your answer makes sense and check your math."
+
+Poor:
+[No verification step]
+```
+
+### 3. Encourage Self-Correction
+```
+Good:
+"If you find an error in your reasoning, acknowledge it and correct your approach."
+
+Poor:
+[No mention of error handling]
+```
+
+### 4. Ask for Uncertainty Acknowledgment
+```
+Good:
+"If you're uncertain at any step, state your assumptions and why you made them."
+
+Poor:
+[Assumes certainty at all steps]
+```
+
+## Complete Examples
+
+### Example 1: Debugging
+
+**Without CoT:**
+```
+Why isn't this code working?
+[code snippet]
+```
+
+**With CoT:**
+```
+Debug this code by thinking through it step-by-step:
+
+[code snippet]
+
+Use this process:
+1. Read the code and state what it's supposed to do
+2. Identify the input and expected output
+3. Trace through execution line by line
+4. Note any suspicious patterns or red flags
+5. Form hypotheses about the bug
+6. Test each hypothesis against the code
+7. Identify the root cause
+8. Propose a fix
+9. Verify the fix addresses the issue
+```
+
+### Example 2: System Design
+
+**Without CoT:**
+```
+Design a URL shortener.
+```
+
+**With CoT:**
+```
+Design a URL shortener by working through these steps:
+
+STEP 1 - REQUIREMENTS:
+Think through what the system needs to do.
+- Functional requirements?
+- Non-functional requirements?
+- Scale expectations?
+
+STEP 2 - API DESIGN:
+What endpoints do we need?
+- Consider: creation, retrieval, analytics
+
+STEP 3 - DATA MODEL:
+How should we store URLs?
+- What fields are needed?
+- What indexes?
+
+STEP 4 - URL GENERATION:
+How do we create short codes?
+- Base62 encoding? Hash? Counter?
+- Collision handling?
+
+STEP 5 - SCALABILITY:
+How does this scale?
+- Bottlenecks?
+- Caching strategy?
+- Database sharding?
+
+STEP 6 - TRADE-OFFS:
+What are we optimizing for vs. sacrificing?
+
+For each step, explain your reasoning.
+```
+
+### Example 3: Decision Making
+
+**Without CoT:**
+```
+Should we use MongoDB or PostgreSQL?
+```
+
+**With CoT:**
+```
+Decide between MongoDB and PostgreSQL by reasoning through:
+
+STEP 1 - USE CASE ANALYSIS:
+What are we building and what data patterns will we have?
+- Data structure (structured/unstructured?)
+- Relationships (complex/simple?)
+- Query patterns (known/unknown?)
+
+STEP 2 - MONGODB EVALUATION:
+Pros for our use case:
+[List and explain]
+Cons for our use case:
+[List and explain]
+
+STEP 3 - POSTGRESQL EVALUATION:
+Pros for our use case:
+[List and explain]
+Cons for our use case:
+[List and explain]
+
+STEP 4 - CRITICAL REQUIREMENTS:
+What are our non-negotiables?
+- [Requirement 1 and why it matters]
+- [Requirement 2 and why it matters]
+
+STEP 5 - SCORING:
+Rate each database against our requirements.
+
+STEP 6 - DECISION:
+Based on the analysis above, choose one and explain why.
+
+STEP 7 - VALIDATE:
+Does this decision make sense? Any red flags?
+```
+
+## Combining CoT with Other Frameworks
+
+### CoT + CO-STAR
+```
+CONTEXT: [Situation]
+OBJECTIVE: [Goal]
+...
+
+PROCESS (Chain of Thought):
+Work through this step-by-step:
+1. [Step 1]
+2. [Step 2]
+...
+```
+
+### CoT + RISEN
+```
+ROLE: [Expertise]
+INSTRUCTIONS: Use step-by-step reasoning for each stage
+STEPS:
+1. [Step 1] - Think through: [reasoning points]
+2. [Step 2] - Consider: [reasoning points]
+...
+```
+
+### CoT + RISE
+```
+ROLE: [Analyst]
+INPUT: [Data]
+STEPS:
+1. [Action] - Reasoning: [Why this step?]
+2. [Action] - Reasoning: [What are we looking for?]
+...
+```
+
+## Advanced Techniques
+
+### Self-Consistency
+Generate multiple reasoning paths and choose the most common answer:
+
+```
+Solve this problem using three different approaches:
+
+APPROACH 1:
+[Method 1 with step-by-step reasoning]
+
+APPROACH 2:
+[Method 2 with step-by-step reasoning]
+
+APPROACH 3:
+[Method 3 with step-by-step reasoning]
+
+COMPARISON:
+Which approach is most reliable and why?
+
+FINAL ANSWER:
+Based on the most consistent result.
+```
+
+### Uncertainty Quantification
+```
+For each step, rate your confidence:
+1. [Step 1] - Confidence: High/Medium/Low - Because: [reason]
+2. [Step 2] - Confidence: High/Medium/Low - Because: [reason]
+
+If any step has low confidence, explore alternatives.
+```
+
+### Backward Chaining
+```
+Start with the desired outcome and work backwards:
+
+GOAL: [What we want to achieve]
+
+STEP -1: To achieve this, what must be true immediately before?
+STEP -2: To achieve that, what must be true before it?
+STEP -3: Keep working backwards...
+STEP -N: What's our starting point?
+
+Now verify the forward path makes sense.
+```
+
+## Common Patterns
+
+### Mathematical Problem Solving
+```
+1. Understand: Restate the problem in your own words
+2. Identify: What do we know? What do we need to find?
+3. Plan: What formula or approach applies?
+4. Execute: Work through the math step-by-step
+5. Verify: Does the answer make sense? Check units, magnitude
+```
+
+### Logical Reasoning
+```
+1. Premises: State what we know to be true
+2. Inference: What can we deduce from premises?
+3. Test: Do our deductions hold up?
+4. Conclusion: What can we conclude?
+5. Verify: Are there any logical fallacies?
+```
+
+### Troubleshooting
+```
+1. Observe: What's the symptom?
+2. Hypothesize: What could cause this?
+3. Test: How can we test each hypothesis?
+4. Eliminate: Rule out what doesn't fit
+5. Identify: What's the root cause?
+6. Solve: How do we fix it?
+7. Verify: Did it work?
+```
+
+## Quality Indicators
+
+**Good CoT reasoning shows:**
+- ✅ Each step builds on previous ones
+- ✅ Assumptions are stated explicitly
+- ✅ Calculations/logic are shown
+- ✅ Intermediate results are verified
+- ✅ Uncertainties are acknowledged
+- ✅ Final answer follows logically
+
+**Poor CoT reasoning shows:**
+- ❌ Jumping to conclusions
+- ❌ Skipping intermediate steps
+- ❌ Hiding assumptions
+- ❌ No verification
+- ❌ Unjustified leaps in logic
+
+## Assessment Checklist
+
+When using Chain of Thought:
+- [ ] Problem is complex enough to warrant CoT
+- [ ] Steps are explicitly requested
+- [ ] Reasoning structure is provided or suggested
+- [ ] Verification is included
+- [ ] Self-correction is encouraged
+- [ ] Each step is actionable
+- [ ] Logic flow is clear
+- [ ] Assumptions are acknowledged
+- [ ] Final answer connects to reasoning
+- [ ] Work shown, not just answer

package/skills/prompt-architect/references/frameworks/co-star.md

@@ -0,0 +1,256 @@
+# CO-STAR Framework
+
+## Overview
+
+CO-STAR is a comprehensive prompting framework that emphasizes context, audience, and communication style. It's particularly effective for content creation, writing tasks, and scenarios where tone and audience considerations significantly impact output quality.
+
+## Components
+
+### C - Context
+**Purpose:** Provide background information, situational details, and constraints.
+
+**Questions to Ask:**
+- What's the background situation?
+- What constraints exist?
+- What's happened previously?
+- What environment/platform is this for?
+- Are there any limitations or restrictions?
+
+**Examples:**
+- "You're working with a startup that has limited resources..."
+- "This is for a formal government report..."
+- "The user base is primarily non-technical..."
+
+### O - Objective
+**Purpose:** Define the clear, specific goal to be achieved.
+
+**Questions to Ask:**
+- What exactly do you want accomplished?
+- What does success look like?
+- What's the primary outcome?
+- Are there secondary goals?
+
+**Examples:**
+- "Create a comprehensive product comparison..."
+- "Generate ideas for reducing customer churn..."
+- "Explain the concept in simple terms..."
+
+### S - Style
+**Purpose:** Specify the writing style, format, and structural preferences.
+
+**Questions to Ask:**
+- What writing style is appropriate?
+- Should it be formal or casual?
+- Are there format requirements?
+- Should it follow a specific structure?
+- Any style guides to follow?
+
+**Examples:**
+- "Use a journalistic style with short paragraphs..."
+- "Follow AP style guidelines..."
+- "Write in a conversational, blog-post style..."
+
+### T - Tone
+**Purpose:** Set the emotional quality and attitude of the response.
+
+**Questions to Ask:**
+- What emotional quality should it have?
+- Should it be serious or light-hearted?
+- Authoritative or humble?
+- Urgent or measured?
+
+**Examples:**
+- "Professional yet friendly..."
+- "Urgent and action-oriented..."
+- "Empathetic and supportive..."
+- "Confident and authoritative..."
+
+### A - Audience
+**Purpose:** Identify who will consume the output and their characteristics.
+
+**Questions to Ask:**
+- Who is the target audience?
+- What's their expertise level?
+- What do they care about?
+- What are their pain points?
+- What's their context?
+
+**Examples:**
+- "Senior executives with limited technical knowledge..."
+- "Junior developers learning the framework..."
+- "Parents of elementary school children..."
+
+### R - Response
+**Purpose:** Define the expected output format and structure.
+
+**Questions to Ask:**
+- What format should the output take?
+- How long should it be?
+- Should it include specific sections?
+- Are there structural requirements?
+- What level of detail is needed?
+
+**Examples:**
+- "Provide a 500-word article with 3 main sections..."
+- "Create a bulleted list of 10 items..."
+- "Generate a table comparing features..."
+
+## Template Structure
+
+```
+CONTEXT:
+[Background information, situation, constraints]
+
+OBJECTIVE:
+[Clear, specific goal to achieve]
+
+STYLE:
+[Writing style, format preferences]
+
+TONE:
+[Emotional quality, formality level]
+
+AUDIENCE:
+[Target audience characteristics]
+
+RESPONSE FORMAT:
+[Expected output structure and format]
+```
+
+## Complete Example
+
+### Before CO-STAR:
+"Write about the benefits of exercise."
+
+### After CO-STAR:
+```
+CONTEXT:
+I'm creating content for a health blog aimed at busy professionals who struggle to find time for fitness. Previous articles have focused on nutrition, and this is part of a series on lifestyle improvements.
+
+OBJECTIVE:
+Create an engaging article that convinces time-pressed professionals that exercise is worth prioritizing, focusing on benefits beyond just physical health.
+
+STYLE:
+Use a conversational blog style with short paragraphs (2-3 sentences), subheadings every 150-200 words, and occasional bullet points for key takeaways. Include specific examples and avoid medical jargon.
+
+TONE:
+Encouraging and motivating without being preachy. Acknowledge their time constraints and show empathy for their challenges. Be practical and realistic rather than idealistic.
+
+AUDIENCE:
+Professionals aged 30-50 who work 50+ hour weeks, have limited free time, may have families, and currently don't exercise regularly. They're skeptical of fitness advice that seems unrealistic for their lifestyle.
+
+RESPONSE FORMAT:
+800-word article with:
+- Engaging headline
+- Brief introduction (2-3 sentences)
+- 4-5 main sections with subheadings
+- Bullet points highlighting key benefits
+- Practical conclusion with next steps
+```
+
+## Best Use Cases
+
+1. **Content Creation**
+   - Blog posts, articles, marketing copy
+   - When multiple stakeholders will review
+   - When brand voice matters
+
+2. **Communication Tasks**
+   - Emails to specific audiences
+   - Presentations
+   - Reports with specific readers
+
+3. **Creative Writing**
+   - When tone significantly impacts effectiveness
+   - When audience understanding is critical
+   - When style consistency matters
+
+4. **Educational Content**
+   - Teaching materials
+   - Explanations for specific skill levels
+   - Documentation for user groups
+
+## Selection Criteria
+
+**Choose CO-STAR when:**
+- ✅ Task involves writing or content creation
+- ✅ Multiple stakeholders or diverse audience
+- ✅ Tone and style significantly impact success
+- ✅ Rich contextual requirements exist
+- ✅ Brand or voice consistency matters
+- ✅ Audience characteristics are well-defined
+
+**Avoid CO-STAR when:**
+- ❌ Task is purely analytical/technical
+- ❌ Audience doesn't matter
+- ❌ Tone is irrelevant
+- ❌ Simple, quick task without context needs
+- ❌ Format is the only concern
+
+## Common Mistakes
+
+1. **Too Much Context**
+   - Include only relevant background
+   - Avoid tangential information
+   - Focus on what impacts the task
+
+2. **Vague Objective**
+   - Be specific about desired outcome
+   - Quantify when possible
+   - Clarify success criteria
+
+3. **Confusing Style and Tone**
+   - Style = structural/format choices
+   - Tone = emotional quality
+   - Keep them separate
+
+4. **Generic Audience Description**
+   - Be specific about audience characteristics
+   - Include their knowledge level
+   - Mention their goals/pain points
+
+## Variations and Combinations
+
+### CO-STAR + Chain of Thought
+Use for complex content that requires reasoning:
+```
+[Standard CO-STAR components]
+
+PROCESS:
+Think through this step-by-step:
+1. Identify key themes
+2. Organize supporting evidence
+3. Structure argument flow
+4. Draft with examples
+```
+
+### CO-STAR + RISEN
+For content creation with specific methodology:
+```
+[Use CO-STAR for context/audience/tone]
+[Use RISEN's Steps for the creation process]
+[Use CO-STAR's Response for output format]
+```
+
+## Quick Reference
+
+| Component | Focus | Key Question |
+|-----------|-------|--------------|
+| Context | Background | "What's the situation?" |
+| Objective | Goal | "What do you want achieved?" |
+| Style | Format/Structure | "How should it be written?" |
+| Tone | Emotional Quality | "What feeling should it convey?" |
+| Audience | Reader | "Who is this for?" |
+| Response | Output | "What should the output look like?" |
+
+## Assessment Checklist
+
+When applying CO-STAR, verify:
+- [ ] Context provides necessary background without excess
+- [ ] Objective is specific and measurable
+- [ ] Style guidance is clear and actionable
+- [ ] Tone matches audience and objective
+- [ ] Audience is well-defined with characteristics
+- [ ] Response format is detailed and specific
+- [ ] All components work together cohesively
+- [ ] Nothing contradicts other components