@ckelsoe/prompt-architect 3.0.0 → 3.1.1

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

@@ -1,479 +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
+# 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