@ckelsoe/prompt-architect 3.2.2 → 3.3.1

package/skills/prompt-architect/references/frameworks/iterative-compression.md

@@ -0,0 +1,481 @@
+# Iterative Compression Framework
+
+## Overview
+
+Iterative Compression progressively tightens a piece of text through multiple passes. Each iteration cuts redundancy, sharpens phrasing, and raises information density — typically while reducing overall length toward a target. It rests on the observation that successive editing passes usually beat trying to get everything right in one shot.
+
+**Origin:** General practitioner technique with no single documented originator — the multi-pass editing loop long predates LLMs. This is a house pattern, not a published method, and it is not research-backed. **Not to be confused with Chain of Density** (Adams et al., arXiv 2309.04269), which holds length *fixed* while raising entity density. The two techniques are frequently conflated, including in earlier versions of this package. If your goal is a shorter text, use this framework; if your goal is more information in the *same* number of words, use `chain-of-density.md`.
+
+## Core Concept
+
+Instead of requesting the perfect output immediately, Iterative Compression:
+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 Iterative Compression
+
+**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 Iterative Compression:
+
+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 Iterative Compression:**
+```
+Summarize this research paper.
+```
+
+**With Iterative Compression:**
+```
+Summarize this research paper using Iterative Compression:
+
+[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 Iterative Compression:**
+```
+Document this function.
+```
+
+**With Iterative Compression:**
+```
+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 Iterative Compression:**
+```
+Write an email announcing this feature.
+```
+
+**With Iterative Compression:**
+```
+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 Iterative Compression:**
+```
+Explain how this algorithm works.
+```
+
+**With Iterative Compression:**
+```
+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 Iterative Compression with Other Frameworks
+
+### Iterative Compression + CO-STAR
+```
+CONTEXT: [Background]
+OBJECTIVE: [Goal]
+STYLE: [Writing style]
+TONE: [Tone]
+AUDIENCE: [Readers]
+
+RESPONSE PROCESS (Iterative Compression):
+Draft 1: [Comprehensive version]
+Draft 2: [Refined for clarity]
+Draft 3: [Optimized for audience]
+Draft 4: [Final polished version]
+```
+
+### Iterative Compression + 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]
+```
+
+### Iterative Compression + Chain of Thought
+```
+For each iteration of Iterative Compression, 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 Iterative Compression iterations show:**
+- ✅ Measurable improvement each pass
+- ✅ Increased information density
+- ✅ Reduced redundancy
+- ✅ Maintained accuracy
+- ✅ Enhanced clarity
+- ✅ Clear evolution path
+
+**Poor Iterative Compression 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 Iterative Compression:
+- [ ] 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

package/skills/prompt-architect/references/frameworks/pre-mortem.md

@@ -2,17 +2,17 @@
 
 ## Overview
 
-Pre-Mortem Prompting adapts Gary Klein's prospective hindsight technique to AI prompting. Instead of asking "what could go wrong?" (which triggers optimism bias and produces vague risks), it instructs the AI to *assume* the project or decision has already failed catastrophically — then work backwards to identify the specific reasons why. This committed-failure frame consistently produces more specific, actionable failure identification than forward risk analysis.
+Pre-Mortem Prompting adapts Gary Klein's prospective hindsight technique to AI prompting. Instead of asking "what could go wrong?" (which triggers optimism bias and produces vague risks), it instructs the AI to *assume* the project or decision has already failed catastrophically — then work backwards to identify the specific reasons why. In practice this committed-failure frame tends to yield more specific, actionable failure identification than an open-ended "what could go wrong?" question.
 
-**Research basis:** Gary Klein's prospective hindsight research (Cognitive Systems Engineering; Brookings Institution). Studies show ~30% improvement in correct identification of failure causes compared to standard forward risk analysis. Application to LLM prompting is practitioner-level (no dedicated AI paper), but the cognitive mechanism is well-established.
+**Research basis:** Mitchell, Russo & Pennington, "Back to the Future: Temporal Perspective in the Explanation of Events" (*Journal of Behavioral Decision Making*, 1989) found that prospective hindsight — imagining an event has *already occurred* — increases the ability to correctly identify **reasons for future outcomes** by ~30%, compared with imagining it *might* occur. Gary Klein popularized the technique as the "pre-mortem" (*Harvard Business Review*, September 2007), which is where the 30% figure is most often cited from. Note the measured comparison is already-happened vs. might-happen framing, not pre-mortem vs. forward risk analysis. Application to LLM prompting is practitioner-level (no dedicated AI paper), but the cognitive mechanism is well-established.
 
-## Why Assumed Failure Outperforms Forward Risk Analysis
+## Why the Assumed-Failure Frame Helps
 
-Forward risk: *"What could go wrong?"* → Produces vague, hedged answers ("there might be delays", "adoption could be low")
+Forward risk: *"What could go wrong?"* → Tends to produce vague, hedged answers ("there might be delays", "adoption could be low")
 
-Pre-mortem: *"This has already failed — why did it fail?"* → Produces specific, committed answers ("the integration with Salesforce took 3x longer than estimated because we didn't account for their API rate limits")
+Pre-mortem: *"This has already failed — why did it fail?"* → Tends to produce specific, committed answers ("the integration with Salesforce took 3x longer than estimated because we didn't account for their API rate limits")
 
-The difference: by committing to the failure frame, the model bypasses optimism bias and generates specific causal narratives rather than probabilistic hedges.
+The mechanism: committing to the failure frame bypasses optimism bias and elicits specific causal narratives rather than probabilistic hedges. This is the practitioner rationale for the technique — the 1989 study measured the certainty framing itself, not a head-to-head against forward risk analysis, so treat the comparison above as an observed pattern rather than a measured result.
 
 ## Components
 

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

@@ -4,6 +4,8 @@
 
 RACE (Role, Action, Context, Expectation) is a medium-complexity framework that sits between RTF's simplicity and CO-STAR's richness. It adds two critical improvements over RTF: situational context (missing from RTF) and an explicit expectation of success (missing from both RTF and CTF). RACE is ideal when you need all four pillars — expertise framing, task clarity, background, and a defined success bar — without the full overhead of CO-STAR or RISEN.
 
+**Origin:** No single documented originator. RACE is a community prompt-engineering convention documented in practitioner guides (e.g. fvivas.com, 20 April 2025) with no attributed creator, and does not appear in any peer-reviewed prompting survey. **Not to be confused with** the RACE digital-marketing planning model (Reach, Act, Convert, Engage), created by Dave Chaffey of Smart Insights in 2010 — an unrelated marketing framework that shares only the acronym.
+
 ## Components
 
 ### R - Role

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

@@ -6,7 +6,7 @@ ReAct (Reasoning + Acting) is an agentic prompting framework that interleaves re
 
 ReAct is the framework of choice when the task requires using tools, querying external sources, writing and executing code, or navigating a multi-step process where each step's result informs the next.
 
-**Research basis:** Introduced in "ReAct: Synergizing Reasoning and Acting in Language Models" (Yao et al., 2022).
+**Research basis:** Introduced in "ReAct: Synergizing Reasoning and Acting in Language Models" (Yao et al., arXiv 2210.03629, 2022; ICLR 2023).
 
 ## Components
 

package/skills/prompt-architect/references/frameworks/reverse-role.md

@@ -4,7 +4,7 @@
 
 Reverse Role Prompting flips the traditional prompting dynamic: instead of you constructing a detailed prompt, you provide a minimal intent statement and the AI interviews you — asking targeted clarifying questions — until it has enough information to execute the task well. This is the framework for when you know what you want but struggle to articulate all the details needed for a good prompt.
 
-**Research basis:** Widely circulated as "reverse prompting" in practitioner communities (2023–2024). Formalized academically as **FATA** (First Ask Then Answer), arXiv 2508.08308, August 2025 — showing ~40% improvement over standard prompting. Related to **Socratic Prompting** (Chang et al., arXiv 2303.08769, EMNLP 2023/NAACL 2024).
+**Research basis:** Widely circulated as "reverse prompting" in practitioner communities (2023–2024). Formalized academically as **FATA** (First Ask Then Answer), arXiv 2508.08308, August 2025 — showing ~40% improvement over standard prompting. Related to **Socratic Prompting** (Chang, arXiv 2303.08769, IEEE CCWC 2023).
 
 ## When to Use
 

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

@@ -2,9 +2,28 @@
 
 ## Overview
 
-RISE is a streamlined 4-component framework that exists in **two legitimate variants**, each serving different use cases. Both versions are well-documented in authoritative sources and provide effective prompt structuring.
+RISE is a streamlined 4-component framework for structuring prompts around a role, the material to work from, a process, and a target output. This skill supports two variants, described below.
 
-**Important**: This skill supports BOTH variants. Selection guidance is provided below to help choose the right version for your task.
+**Origin:** Community convention with no identifiable originator and no academic basis. The dominant documented expansion is **Role, Input, Steps, Expectation** — Fabio Vivas (fvivas.com); Juuzt.ai; Damien Griffin, "AI Quick Tips 111: Prompt Framework — R.I.S.E." (Thoughts Brewing, 17 December 2024). RISE's first appearance and original author could not be established. Not research-backed. Distinct from **RISEN** (Role, Instructions, Steps, End goal, Narrowing), which is a separate framework.
+
+---
+
+## Naming note — read before using this file
+
+**"RISE-IE" and "RISE-IX" are this skill's internal shorthand.** They are not established terminology, and no external source uses either term. Do not present them to users as standard vocabulary — say "the Input-Expectation form of RISE" instead.
+
+Verified published expansions of RISE:
+
+| Expansion | Sources | Status |
+|---|---|---|
+| Role, **Input**, Steps, **Expectation** | fvivas.com; juuzt.ai; thoughtsbrewing.com; promptfoundry.me | **Dominant form** — 4+ independent sources |
+| Role, **Instructions**, Steps, **Expectations** | promptwizz.com | Minority variant |
+| Role, **Instruction**, **Specifics**, **Examples** | aipromptsx.com | Minority variant — note S = Specifics, not Steps |
+| Role, Instructions, Steps, **Examples** | *none found* | **Unverified** — the pattern this file calls "RISE-IX" |
+
+**RISE-IX is this skill's own composition, not a documented variant.** It remains a sound prompt pattern — role + directive + method + worked examples is good practice — but it is presented here as our construction, not as an established framework.
+
+*Correction:* an earlier version of this file described both variants as "well-documented in authoritative sources." That was incorrect for RISE-IX. Of its three previously-cited sources: AiPromptsX defines S as "Specifics" rather than "Steps"; The Prompt Warrior documents RISEN and contains no RISE framework at all; and Thoughts Brewing documents the Input-Expectation form, making it a RISE-IE source. None supports Role/Instructions/Steps/Examples.
 
 ---
 
@@ -15,14 +34,14 @@ RISE is a streamlined 4-component framework that exists in **two legitimate vari
 
 **Best for**: Data analysis, transformations, processing tasks
 
-**Sources**: Fabio Vivas, Juuzt.ai
+**Provenance**: The documented community form. Sources: Fabio Vivas (fvivas.com); Juuzt.ai; Damien Griffin / Thoughts Brewing (17 December 2024).
 
 ### RISE-IX: Instructions-Examples (Instruction-Focused)
 **Components**: Role, **Instructions**, Steps, **Examples**
 
 **Best for**: Content creation, learning tasks, example-based work
 
-**Sources**: AiPromptsX, The Prompt Warrior, Thoughts Brewing
+**Provenance**: This skill's own composition — no external source documents this exact expansion. The nearest published forms are Role/Instructions/Steps/**Expectations** (promptwizz.com) and Role/Instruction/**Specifics**/Examples (aipromptsx.com). Use as a house pattern; do not cite it as an established framework.
 
 ---
 
@@ -542,13 +561,13 @@ every wear while treading lightly on the planet..."
 
 ## Summary
 
-RISE framework exists in two well-documented variants:
+This file documents two RISE patterns:
 
-**RISE-IE (Input-Expectation)**: Best for data processing, analysis, and transformation tasks where you have specific input to work with.
+**RISE-IE (Input-Expectation)**: The documented community form of RISE. Best for data processing, analysis, and transformation tasks where you have specific input to work with.
 
-**RISE-IX (Instructions-Examples)**: Best for content creation, writing, and tasks where examples help clarify desired output style.
+**RISE-IX (Instructions-Examples)**: This skill's own variant, not an externally documented form. Best for content creation, writing, and tasks where examples help clarify desired output style.
 
-Both variants are legitimate and effective. Choose based on whether your task is more analytical/data-focused (IE) or creative/instruction-focused (IX).
+Both are practically effective. Only RISE-IE has external documentation — say so if a user asks where these come from. Choose based on whether your task is more analytical/data-focused (IE) or creative/instruction-focused (IX).
 
 When in doubt, ask: **"Am I processing data or creating content?"**
 - Processing data → **RISE-IE**

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

@@ -4,6 +4,8 @@
 
 RISEN is a methodology-focused framework that emphasizes process, steps, and boundaries. It's ideal for complex multi-step tasks where following a specific procedure matters, and where defining what NOT to do is as important as what to do.
 
+**Origin:** Community framework, attributed to Kyle Balmer (AI educator, @iamkylebalmer). The earliest dated appearance is Moritz Kremb, "5 prompt frameworks to level up your prompts" (The Prompt Warrior, 13 October 2023), which credits Balmer with creating and sharing it; Balmer himself writes only "I call the RISEN framework" and makes no claim of invention. No academic source documents RISEN.
+
 ## Components
 
 ### R - Role

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

@@ -4,6 +4,8 @@
 
 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.
 
+**Origin:** No single documented originator. RTF circulated as an unattributed community convention by late 2023 — the earliest dated listing found (Moritz Kremb, The Prompt Warrior, 13 October 2023) presents it without credit while explicitly crediting named authors for other frameworks in the same article. It does not appear in any peer-reviewed prompting survey, including The Prompt Report (arXiv 2406.06608).
+
 ## Components
 
 ### R - Role

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

@@ -4,7 +4,7 @@
 
 Skeleton of Thought (SoT) is a two-phase framework that first generates a concise structural outline ("skeleton") of the answer, then expands each skeleton point — either sequentially or in parallel — into full content. It improves both output quality (by forcing upfront structure) and can dramatically reduce latency when expansion is done in parallel API calls.
 
-**Research basis:** "Skeleton-of-Thought: Prompting LLMs for Efficient Parallel Generation" (Ning et al., Microsoft Research, arXiv:2307.15337, ICLR 2024). Demonstrated 2x+ speedup on 8 of 12 tested models with maintained or improved quality.
+**Research basis:** "Skeleton-of-Thought: Prompting LLMs for Efficient Parallel Generation" (Ning et al., Microsoft Research, arXiv:2307.15337, ICLR 2024). Demonstrated 2x+ speedup (up to 2.39x) on 8 of 12 tested models, with quality parity in roughly 60% of cases; quality degrades on writing, math, and coding tasks.
 
 ## Components
 

package/skills/prompt-architect/references/frameworks/step-back.md

@@ -4,7 +4,7 @@
 
 Step-Back Prompting is a two-step reasoning technique where the model first answers a higher-level "step-back" question that retrieves the underlying principles, concepts, or facts relevant to the original problem — then uses those retrieved principles as context to answer the original question. By abstracting first, the model grounds its reasoning in first principles rather than diving directly into a potentially error-prone specific answer.
 
-**Research basis:** "Take a Step Back: Evoking Reasoning via Abstraction in Large Language Models" (Zheng et al., Google DeepMind, arXiv:2310.06117, ICLR 2024). Demonstrated +7-27% accuracy on MMLU Physics and Chemistry, +27% on TimeQA, +25% on MuSiQue vs. direct prompting.
+**Research basis:** "Take a Step Back: Evoking Reasoning via Abstraction in Large Language Models" (Zheng et al., Google DeepMind, arXiv:2310.06117, ICLR 2024). Demonstrated +7% on MMLU Physics, +11% on Chemistry, +27% on TimeQA, and +7% on MuSiQue vs. direct prompting (PaLM-2L).
 
 ## Components