@ckelsoe/prompt-architect 3.0.0

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

@@ -0,0 +1,235 @@
+# CARE Framework
+
+## Overview
+
+CARE (Context, Ask, Rules, Examples) is a practitioner framework from Nielsen Norman Group that adds an explicit **Rules** component to the standard context-task-examples pattern. This makes it particularly effective for tasks where constraints, guardrails, or quality standards need to be enforced — the Rules component directly addresses what the AI should and should not do, reducing the need for post-hoc correction.
+
+**Origin:** Nielsen Norman Group (nngroup.com) — a leading UX and AI research firm. The NNg formulation focuses on making prompts "CAREFUL" — ensuring AI outputs are constrained, targeted, and appropriately scoped.
+
+## Components
+
+### C — Context
+**Purpose:** Provide the background and situation needed to understand the task — who you are, what the situation is, and why this task matters.
+
+**Questions to Ask:**
+- Who are you in this situation?
+- What's the broader context?
+- Why is this task being done?
+
+**Examples:**
+- "I am a UX designer preparing for a usability study..."
+- "We are a healthcare startup building a patient-facing mobile app..."
+- "I am a manager writing a performance review for a direct report..."
+
+### A — Ask
+**Purpose:** State the specific request — what you want the AI to produce or do.
+
+**Questions to Ask:**
+- What is the exact deliverable?
+- What should the output be?
+
+**Examples:**
+- "Write a set of 5 interview questions for testing navigation usability..."
+- "Draft a 3-paragraph executive summary of this technical report..."
+- "Create a rubric for evaluating onboarding email effectiveness..."
+
+### R — Rules
+**Purpose:** Define explicit constraints, guardrails, standards, and dos/don'ts that govern the output. This is the defining component of CARE — it makes requirements explicit rather than assumed.
+
+**Questions to Ask:**
+- What must be included?
+- What must be avoided?
+- What quality standards apply?
+- What are the constraints (length, format, tone, reading level)?
+- What would make this output wrong or unusable?
+
+**Examples:**
+- "Rules: Use plain language (max grade 8 reading level). Avoid medical jargon. Each question must be open-ended, not yes/no. Do not suggest answers in the question wording."
+- "Rules: Under 300 words. No bullet points — prose only. Must include a clear recommendation. Do not mention competitor names."
+- "Rules: Must comply with ADA language guidelines. No deficit-based language. First-person framing only."
+
+### E — Examples
+**Purpose:** Provide 1-3 examples that demonstrate the desired output format, tone, style, or quality level.
+
+**Questions to Ask:**
+- Is there an existing example of what good looks like?
+- What format should it match?
+- What tone should it mirror?
+
+**Examples:**
+- "Example question: 'Walk me through how you would find the settings for your account.'"
+- "Example summary paragraph: [paste existing example]"
+- "Example format: [show template]"
+
+## Template Structure
+
+```
+CONTEXT:
+[Who you are, the situation, why this task exists]
+
+ASK:
+[The specific request and deliverable]
+
+RULES:
+[Explicit constraints — what must be included, what must be avoided,
+quality standards, format requirements, length limits, tone requirements,
+compliance requirements, reading level, etc.]
+
+EXAMPLES:
+[1-3 examples of desired output format, tone, or style]
+```
+
+## Complete Examples
+
+### Example 1: UX Research
+
+**Before CARE:**
+"Write interview questions for our usability study."
+
+**After CARE:**
+```
+CONTEXT:
+I am a UX researcher preparing for a moderated usability study on our
+mobile banking app's new money transfer flow. Participants are adults
+aged 35-65 who are non-technical but regular smartphone users. The
+study will be conducted remotely via Zoom with screen sharing.
+
+ASK:
+Write 6 interview questions for the post-task debrief, focusing on
+comprehension, confidence, and friction points in the transfer flow.
+
+RULES:
+- All questions must be open-ended (no yes/no questions)
+- Use plain, everyday language — no banking or UX jargon
+- Do not suggest answers within the question (no leading questions)
+- Each question should address one thing only (no double-barreled)
+- Avoid "why" questions (use "what made you..." instead)
+- Questions should take no more than 3 minutes each to answer
+
+EXAMPLES:
+Good: "What went through your mind when you reached the confirmation screen?"
+Bad: "Was the confirmation screen clear and easy to understand?" (yes/no, leading)
+```
+
+### Example 2: Healthcare Content
+
+**Before CARE:**
+"Write patient education content about diabetes management."
+
+**After CARE:**
+```
+CONTEXT:
+I am a health content writer for a patient portal used by adults with
+Type 2 diabetes. Many patients have low health literacy. The content
+will appear in a mobile app alongside their care plan.
+
+ASK:
+Write a 200-word article explaining why blood sugar monitoring matters
+and how often to check.
+
+RULES:
+- Maximum 6th grade reading level (use Flesch-Kincaid as guide)
+- Avoid medical jargon; if medical term must be used, define it
+- Use active voice and second-person ("you") throughout
+- No numbers or statistics unless critical — prefer plain descriptions
+- Must include a clear, simple call to action at the end
+- Do not recommend specific monitoring frequency — use "as directed by your doctor"
+- Comply with plain language guidelines (short sentences, common words)
+
+EXAMPLES:
+Good sentence: "Checking your blood sugar helps you and your doctor
+understand how your body responds to food and activity."
+Bad sentence: "Glycemic monitoring enables patients to assess metabolic
+response to dietary and physical stimuli."
+```
+
+### Example 3: Technical Writing
+
+**Before CARE:**
+"Write error messages for our app."
+
+**After CARE:**
+```
+CONTEXT:
+I am a product designer writing UI error messages for a B2B data analytics
+platform. Users are data analysts — technically literate but not developers.
+Errors occur during data upload, query execution, and report generation.
+
+ASK:
+Write error messages for these 3 error states: (1) file format not supported,
+(2) query timeout, (3) insufficient permissions to view a report.
+
+RULES:
+- Maximum 2 sentences per error message
+- Must include: what happened + what the user can do about it
+- Use plain language — no HTTP status codes, no stack traces, no internal IDs
+- Active voice, direct address ("You can..." not "The user can...")
+- Do not blame the user ("You uploaded the wrong format" is bad)
+- Must include a specific actionable next step (not just "try again")
+- Tone: calm, helpful, matter-of-fact — not apologetic or alarming
+
+EXAMPLES:
+Good: "This file type isn't supported. Try uploading a .CSV or .XLSX file."
+Bad: "ERROR 415: Unsupported Media Type. The file format you attempted to
+upload is not compatible with the system's ingestion pipeline."
+```
+
+## Best Use Cases
+
+1. **Compliance and Standards-Driven Content**
+   - Healthcare, legal, accessibility-compliant content
+   - Brand voice guidelines enforcement
+   - Plain language requirements
+
+2. **User-Facing Copy**
+   - UI text, error messages, onboarding
+   - When exact wording constraints matter
+   - When reading level or language standards apply
+
+3. **Research and Interview Materials**
+   - Survey questions, interview guides
+   - When question bias must be avoided
+   - When methodological standards apply
+
+4. **Any Task With Explicit Guardrails**
+   - Legal constraints ("do not mention X")
+   - Style guide compliance
+   - Format requirements that must not be violated
+
+## Selection Criteria
+
+**Choose CARE when:**
+- ✅ Explicit rules/constraints need to be enforced
+- ✅ Quality standards are specific and non-negotiable
+- ✅ Examples help clarify the standard
+- ✅ The "what not to do" is as important as "what to do"
+- ✅ Compliance, accessibility, or style guide requirements exist
+
+**Avoid CARE when:**
+- ❌ No specific rules apply → use simpler RTF, CTF, or APE
+- ❌ Rich audience/tone work needed → use CO-STAR
+- ❌ Multi-step process → use RISEN
+- ❌ Transforming existing content → use BAB
+- ❌ Need explicit Do/Don't lists with more structure → use TIDD-EC
+
+## CARE vs. TIDD-EC
+
+Both have explicit constraint components. Key differences:
+
+| | CARE | TIDD-EC |
+|---|---|---|
+| Rules format | Single Rules section (combined) | Separate Do and Don't sections |
+| Examples position | At end | In the middle |
+| Context | Yes | Yes |
+| Best for | Constraint + example-driven tasks | High-precision tasks needing detailed positive/negative guidance |
+
+**Rule of thumb:** If you need separate "do this" and "don't do this" lists → TIDD-EC. If rules can be combined in one section and examples are critical → CARE.
+
+## Quick Reference
+
+| Component | Focus | Key Question |
+|-----------|-------|--------------|
+| Context | Situation | "What's the background?" |
+| Ask | Request | "What do I need?" |
+| Rules | Constraints | "What must / must not be done?" |
+| Examples | Standard | "What does good look like?" |

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

@@ -0,0 +1,479 @@
+# Chain of Density (CoD) Framework
+
+## Overview
+
+Chain of Density is an iterative refinement technique that progressively improves outputs through multiple passes. Each iteration increases information density, removes redundancy, and enhances quality without significantly increasing length. It's based on the insight that iteration often produces better results than trying to get everything perfect in one shot.
+
+## Core Concept
+
+Instead of requesting the perfect output immediately, CoD:
+1. Starts with a basic/verbose version
+2. Iteratively refines through multiple passes
+3. Increases information density each time
+4. Removes fluff and redundancy
+5. Enhances clarity and precision
+6. Converges on optimal output
+
+Think of it as "progressive enhancement" for prompts.
+
+## When to Use Chain of Density
+
+**Ideal for:**
+- Summarization tasks
+- Content compression
+- Iterative improvement of writing
+- Optimizing explanations
+- Refining complex outputs
+- Tasks where quality improves with iteration
+
+**Not needed for:**
+- Simple one-shot tasks
+- When first draft is sufficient
+- Time-critical quick tasks
+- Tasks with fixed formats that can't improve
+
+## Implementation Approaches
+
+### Approach 1: Explicit Multi-Pass
+Request multiple iterations upfront.
+
+**Example:**
+```
+Create a summary of this article using Chain of Density:
+
+ITERATION 1:
+Write a verbose summary hitting all main points (150-200 words)
+
+ITERATION 2:
+Refine the summary: increase information density, remove redundancy, keep it under 150 words
+
+ITERATION 3:
+Further refine: make every word count, increase precision, keep it under 120 words
+
+ITERATION 4:
+Final pass: maximize information density while maintaining clarity (100 words max)
+
+ITERATION 5:
+Ultimate compression: distill to absolute essentials (50 words max)
+
+After all iterations, explain what improved in each pass.
+```
+
+### Approach 2: Recursive Refinement
+Use output from one iteration as input to the next.
+
+**Example:**
+```
+PASS 1: Write a first draft explanation of quantum entanglement for a general audience.
+
+PASS 2: Review your explanation. What's unclear? What's redundant? Rewrite it, addressing these issues.
+
+PASS 3: Review again. Where can you be more precise? Where can you use better examples? Rewrite.
+
+PASS 4: Final review. Every sentence should earn its place. Remove or improve anything that doesn't. Final version.
+
+Show all passes so we can see the evolution.
+```
+
+### Approach 3: Targeted Improvement
+Focus each iteration on specific aspect.
+
+**Example:**
+```
+Write a product description, then improve it iteratively:
+
+DRAFT:
+[Initial version]
+
+ITERATION 1 - CLARITY:
+Rewrite focusing on making it clearer and easier to understand.
+
+ITERATION 2 - IMPACT:
+Rewrite focusing on making it more compelling and persuasive.
+
+ITERATION 3 - CONCISION:
+Rewrite focusing on removing every unnecessary word.
+
+ITERATION 4 - PRECISION:
+Rewrite focusing on being more specific and accurate.
+
+FINAL:
+Combine the best elements from all iterations.
+```
+
+### Approach 4: Constraint-Based Refinement
+Add tighter constraints with each iteration.
+
+**Example:**
+```
+Explain this technical concept through progressive refinement:
+
+VERSION 1: Explain in 500 words or less
+VERSION 2: Reduce to 300 words without losing key information
+VERSION 3: Reduce to 150 words, keeping only essentials
+VERSION 4: Create a 50-word version capturing the core idea
+VERSION 5: One sentence (25 words max)
+
+Each version should be complete and self-contained.
+```
+
+## Best Practices
+
+### 1. Define What to Optimize
+```
+Good:
+"Iterate to improve:
+- Information density
+- Clarity
+- Conciseness
+- Precision"
+
+Poor:
+"Make it better"
+```
+
+### 2. Specify Number of Iterations
+```
+Good:
+"Refine through 4 iterations, showing each version"
+
+Poor:
+"Keep improving until it's good"
+```
+
+### 3. Show Evolution
+```
+Good:
+"Show each iteration and explain what changed and why"
+
+Poor:
+"Just give me the final version"
+```
+
+### 4. Set Clear Constraints
+```
+Good:
+"Each iteration should be 20% shorter while maintaining completeness"
+
+Poor:
+"Make it shorter"
+```
+
+## Complete Examples
+
+### Example 1: Summarization
+
+**Without CoD:**
+```
+Summarize this research paper.
+```
+
+**With CoD:**
+```
+Summarize this research paper using Chain of Density:
+
+[Paper content]
+
+ITERATION 1 (200 words):
+Create a comprehensive summary covering all major points. Prioritize completeness over brevity.
+
+ITERATION 2 (150 words):
+Refine the summary:
+- Remove redundant information
+- Combine related points
+- Increase information density
+
+ITERATION 3 (100 words):
+Further compression:
+- Keep only essential information
+- Make every sentence count
+- Maintain accuracy
+
+ITERATION 4 (75 words):
+Maximum density:
+- Distill to core findings
+- Remove all fluff
+- Preserve critical details
+
+For each iteration, highlight what you removed and why.
+```
+
+### Example 2: Code Documentation
+
+**Without CoD:**
+```
+Document this function.
+```
+
+**With CoD:**
+```
+Document this function through iterative refinement:
+
+[Code]
+
+DRAFT DOCUMENTATION:
+Write complete documentation with examples, edge cases, everything.
+
+ITERATION 1 - CLARITY:
+Review and rewrite confusing sections. Add examples where helpful.
+
+ITERATION 2 - CONCISION:
+Remove redundancy. Combine related points. Make it tighter.
+
+ITERATION 3 - PRECISION:
+Be more specific about types, behaviors, edge cases.
+
+ITERATION 4 - USABILITY:
+Optimize for developer experience. What do they need to know most?
+
+Show each version and explain key changes.
+```
+
+### Example 3: Email Refinement
+
+**Without CoD:**
+```
+Write an email announcing this feature.
+```
+
+**With CoD:**
+```
+Draft an announcement email, then refine it:
+
+DRAFT:
+Write a first draft covering all important information.
+
+ITERATION 1 - STRUCTURE:
+Reorganize for better flow. Most important information first.
+
+ITERATION 2 - CLARITY:
+Simplify language. Remove jargon. Make it scannable.
+
+ITERATION 3 - ENGAGEMENT:
+Strengthen the call-to-action. Make it more compelling.
+
+ITERATION 4 - POLISH:
+Final edits for tone, concision, impact.
+
+Show the evolution and explain major changes.
+```
+
+### Example 4: Technical Explanation
+
+**Without CoD:**
+```
+Explain how this algorithm works.
+```
+
+**With CoD:**
+```
+Explain this algorithm through progressive refinement:
+
+PASS 1 - COMPREHENSIVE:
+Explain thoroughly, assuming no prior knowledge. Include:
+- What it does
+- How it works
+- Why it's designed this way
+- Example walkthrough
+
+PASS 2 - REFINED:
+Review Pass 1. What's unclear? What's redundant? Rewrite addressing these.
+
+PASS 3 - OPTIMIZED:
+Make it maximally clear and concise. Every paragraph must earn its place.
+
+PASS 4 - POLISHED:
+Final pass. Perfect clarity, zero fluff, optimal examples.
+
+Show all passes and note significant improvements.
+```
+
+## Combining CoD with Other Frameworks
+
+### CoD + CO-STAR
+```
+CONTEXT: [Background]
+OBJECTIVE: [Goal]
+STYLE: [Writing style]
+TONE: [Tone]
+AUDIENCE: [Readers]
+
+RESPONSE PROCESS (Chain of Density):
+Draft 1: [Comprehensive version]
+Draft 2: [Refined for clarity]
+Draft 3: [Optimized for audience]
+Draft 4: [Final polished version]
+```
+
+### CoD + RISEN
+```
+ROLE: [Expertise]
+INSTRUCTIONS: Use iterative refinement
+STEPS:
+1. Create initial version
+2. Review and identify weaknesses
+3. Refine addressing weaknesses
+4. Repeat until optimal
+END GOAL: [Final quality criteria]
+NARROWING: [Constraints on iterations]
+```
+
+### CoD + Chain of Thought
+```
+For each iteration of Chain of Density, use Chain of Thought:
+
+ITERATION 1:
+Think through: What should this initial version include?
+[Create version]
+
+ITERATION 2:
+Think through: What weaknesses exist? How to address them?
+[Refine version]
+
+ITERATION 3:
+Think through: What can be compressed or improved?
+[Further refine]
+```
+
+## Advanced Techniques
+
+### Aspect-Focused Iteration
+Each iteration improves a different dimension:
+
+```
+ITERATION 1 - ACCURACY: Get the facts right
+ITERATION 2 - CLARITY: Make it understandable
+ITERATION 3 - CONCISION: Remove waste
+ITERATION 4 - IMPACT: Make it compelling
+ITERATION 5 - STYLE: Polish the voice
+```
+
+### A/B Iteration Branches
+Create alternative versions and merge best parts:
+
+```
+DRAFT: [Initial version]
+
+BRANCH A - CONCISION:
+[Optimize for brevity]
+
+BRANCH B - COMPLETENESS:
+[Optimize for thoroughness]
+
+MERGE:
+Combine the best elements of both branches.
+```
+
+### Constrained Progressive Compression
+```
+VERSION 1: 1000 words - Complete explanation
+VERSION 2: 500 words - 50% compression
+VERSION 3: 250 words - 75% compression
+VERSION 4: 100 words - 90% compression
+VERSION 5: 25 words - 97.5% compression
+
+Each version must be self-contained and accurate.
+```
+
+### Quality Metric Iteration
+```
+ITERATION 1:
+[Create initial version]
+Self-assess (1-10): Clarity ___ Concision ___ Accuracy ___ Impact ___
+
+ITERATION 2:
+[Improve lowest scoring dimension]
+Self-assess: Clarity ___ Concision ___ Accuracy ___ Impact ___
+
+ITERATION 3:
+[Improve next lowest dimension]
+Self-assess: Clarity ___ Concision ___ Accuracy ___ Impact ___
+
+Continue until all metrics > 8
+```
+
+## Refinement Strategies
+
+### What to Remove
+- Redundant information
+- Obvious statements
+- Unnecessary qualifiers ("very", "really")
+- Passive voice (often)
+- Filler words
+- Overly general statements
+
+### What to Add
+- Specific examples
+- Precise numbers
+- Concrete details
+- Missing context (if essential)
+- Clarifying examples
+
+### What to Improve
+- Vague language → specific language
+- Long sentences → shorter, punchier
+- Complex words → simpler alternatives (if clearer)
+- Weak verbs → strong verbs
+- Passive voice → active voice
+
+## Quality Indicators
+
+**Good CoD iterations show:**
+- ✅ Measurable improvement each pass
+- ✅ Increased information density
+- ✅ Reduced redundancy
+- ✅ Maintained accuracy
+- ✅ Enhanced clarity
+- ✅ Clear evolution path
+
+**Poor CoD iterations show:**
+- ❌ No meaningful change
+- ❌ Loss of important information
+- ❌ Decreased clarity
+- ❌ Introduced errors
+- ❌ Just made it shorter without improvement
+
+## Use Cases
+
+### 1. Content Summarization
+Taking long documents and progressively distilling essence
+
+### 2. Message Refinement
+Iteratively improving emails, announcements, communications
+
+### 3. Documentation Optimization
+Making docs clearer and more concise through iteration
+
+### 4. Explanation Enhancement
+Progressively improving how concepts are explained
+
+### 5. Writing Polish
+Iterative editing of creative or professional writing
+
+### 6. Presentation Optimization
+Refining slides/talks through multiple passes
+
+## Assessment Checklist
+
+When using Chain of Density:
+- [ ] Task benefits from iteration
+- [ ] Number of iterations specified
+- [ ] Optimization goals are clear
+- [ ] Each iteration has purpose
+- [ ] Constraints defined for each pass
+- [ ] Evolution is tracked/shown
+- [ ] Quality criteria established
+- [ ] Stopping condition exists
+- [ ] Final version is actually better
+- [ ] Process improved understanding
+
+## Tips for Success
+
+1. **Start Verbose**: First iteration should be complete, even if wordy
+2. **One Focus Per Iteration**: Don't try to improve everything at once
+3. **Show Your Work**: Display each iteration to see progress
+4. **Set Constraints**: Give specific targets (word counts, focus areas)
+5. **Verify Improvement**: Check that each iteration actually improves quality
+6. **Don't Over-Iterate**: 3-5 iterations usually sufficient
+7. **Preserve Accuracy**: Never sacrifice correctness for brevity
+8. **Explain Changes**: Note what improved and why