@ckelsoe/prompt-architect 3.2.2 → 3.3.1

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

@@ -2,478 +2,150 @@
 
 ## 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.
+Chain of Density is a summarization technique that produces a series of increasingly **entity-dense** summaries of a source document while holding the **length fixed**. It begins with a deliberately sparse, verbose summary, then repeatedly identifies salient entities missing from the previous version and fuses them in — making room by compressing and rewriting existing text rather than by adding words or dropping content.
 
-## Core Concept
+**Research basis:** "From Sparse to Dense: GPT-4 Summarization with Chain of Density Prompting" (Adams, Fabbri, Ladhak, Lehman & Elhadad; arXiv 2309.04269; NewSum workshop at EMNLP 2023, ACL Anthology 2023.newsum-1.7). Entity density rose from 0.089 to 0.167 entities per token over five steps, against 0.151 for human-written summaries and 0.122 for a vanilla GPT-4 summary. In human evaluation, annotators preferred step 2 (30.8% of first-place votes) and step 3 (23.0%) over the sparse step 1 (8.3%) — density helps, but only up to a point.
 
-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
+## The Defining Constraint: Length Stays Fixed
 
-Think of it as "progressive enhancement" for prompts.
+This is the entire mechanism, and it is what separates CoD from ordinary iterative editing:
 
-## 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:
+> "GPT-4 generates an initial entity-sparse summary before iteratively incorporating missing salient entities **without increasing the length**." — abstract
 
-ITERATION 1:
-Write a verbose summary hitting all main points (150-200 words)
+> "To maintain the same length while increasing the number of entities covered, abstraction, fusion, and compression is explicitly encouraged, rather than dropping meaningful content from previous summaries." — §2
 
-ITERATION 2:
-Refine the summary: increase information density, remove redundancy, keep it under 150 words
+Density rises because the *same word budget* is made to carry more information. If you shorten the text on each pass, you are not doing Chain of Density — you are doing generic compression. For that, use **Iterative Compression** (`iterative-compression.md`).
 
-ITERATION 3:
-Further refine: make every word count, increase precision, keep it under 120 words
+The paper controls length deliberately, because length is "a strong confounder when evaluating summaries." In practice the budget holds approximately: measured token counts across the five steps were 72, 67, 67, 69, 72.
 
-ITERATION 4:
-Final pass: maximize information density while maintaining clarity (100 words max)
+## What Counts as a "Missing Entity"
 
-ITERATION 5:
-Ultimate compression: distill to absolute essentials (50 words max)
+The paper is deliberately non-prescriptive about entity *types*. An entity qualifies if it is:
 
-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.
+- **Relevant** — to the main story
+- **Specific** — descriptive yet concise (5 words or fewer)
+- **Novel** — not in the previous summary
+- **Faithful** — present in the source article
+- **Anywhere** — located anywhere in the article, not just the opening
 
-PASS 2: Review your explanation. What's unclear? What's redundant? Rewrite it, addressing these issues.
+"Anywhere" is load-bearing: it is the explicit countermeasure to lead bias, and it is why later iterations start pulling content from the middle and end of the source.
 
-PASS 3: Review again. Where can you be more precise? Where can you use better examples? Rewrite.
+Entity identification is done by the model itself inside the loop — there is no external extraction step.
 
-PASS 4: Final review. Every sentence should earn its place. Remove or improve anything that doesn't. Final version.
+## The Method
 
-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:
+Five iterations, issued as a **single prompt** that returns all five summaries at once (not five separate turns):
 
-DRAFT:
-[Initial version]
+1. **Write a deliberately sparse first summary.** Long (4-5 sentences, ~80 words) but highly non-specific, padded with filler like "this article discusses." The padding is intentional — it creates the slack that later steps convert into entities.
+2. **Identify 1-3 missing entities** from the article that are absent from the current summary.
+3. **Rewrite at identical length**, covering everything from the previous summary *plus* the new entities. Make room through fusion, compression, and removal of uninformative phrases.
+4. **Repeat steps 2-3** until five summaries exist.
+5. **Choose the step you want.** Later is not automatically better — human raters preferred steps 2-3.
 
-ITERATION 1 - CLARITY:
-Rewrite focusing on making it clearer and easier to understand.
+**Never drop entities from the previous summary.** If space cannot be made, add fewer new entities. Under pressure, density yields — length and prior content do not.
 
-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
+## When to Use Chain of Density
 
-ITERATION 4 (75 words):
-Maximum density:
-- Distill to core findings
-- Remove all fluff
-- Preserve critical details
+**Ideal for:**
+- Summarizing an article, paper, or report where information density matters
+- Producing a summary that must fit a fixed length but carry maximum substance
+- Generating several density options to pick from
+- Abstract, executive-summary, and TL;DR writing
 
-For each iteration, highlight what you removed and why.
-```
+**Not for:**
+- General content rewriting or quality improvement → use **Self-Refine**
+- Progressive shortening to a target word count → use **Iterative Compression**
+- Non-summarization tasks. CoD is summarization-specific; the paper evaluates it only on news articles (CNN/DailyMail).
 
-### Example 2: Code Documentation
+## The Prompt
 
-**Without CoD:**
-```
-Document this function.
-```
+This is the paper's actual prompt, lightly reformatted. It is reproduced closely because the specific wording — especially the fixed-length instruction and the entity criteria — is what makes the technique work.
 
-**With CoD:**
 ```
-Document this function through iterative refinement:
-
-[Code]
-
-DRAFT DOCUMENTATION:
-Write complete documentation with examples, edge cases, everything.
+Article: {{ARTICLE}}
 
-ITERATION 1 - CLARITY:
-Review and rewrite confusing sections. Add examples where helpful.
+You will generate increasingly concise, entity-dense summaries of the above Article.
 
-ITERATION 2 - CONCISION:
-Remove redundancy. Combine related points. Make it tighter.
+Repeat the following 2 steps 5 times.
 
-ITERATION 3 - PRECISION:
-Be more specific about types, behaviors, edge cases.
+Step 1. Identify 1-3 informative Entities (";" delimited) from the Article which are
+missing from the previously generated summary.
+Step 2. Write a new, denser summary of identical length which covers every entity and
+detail from the previous summary plus the Missing Entities.
 
-ITERATION 4 - USABILITY:
-Optimize for developer experience. What do they need to know most?
+A Missing Entity is:
+- Relevant: to the main story.
+- Specific: descriptive yet concise (5 words or fewer).
+- Novel: not in the previous summary.
+- Faithful: present in the Article.
+- Anywhere: located anywhere in the Article.
 
-Show each version and explain key changes.
-```
-
-### Example 3: Email Refinement
+Guidelines:
+- The first summary should be long (4-5 sentences, ~80 words) yet highly non-specific,
+  containing little information beyond the entities marked as missing. Use overly verbose
+  language and fillers (e.g., "this article discusses") to reach ~80 words.
+- Make every word count: re-write the previous summary to improve flow and make space for
+  additional entities.
+- Make space with fusion, compression, and removal of uninformative phrases like "the
+  article discusses".
+- The summaries should become highly dense and concise yet self-contained, e.g., easily
+  understood without the Article.
+- Missing entities can appear anywhere in the new summary.
+- Never drop entities from the previous summary. If space cannot be made, add fewer new
+  entities.
 
-**Without CoD:**
-```
-Write an email announcing this feature.
-```
+Remember, use the exact same number of words for each summary.
 
-**With CoD:**
+Answer in JSON. The JSON should be a list (length 5) of dictionaries whose keys are
+"Missing_Entities" and "Denser_Summary".
 ```
-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.
+## Worked Example
 
-Show the evolution and explain major changes.
-```
-
-### Example 4: Technical Explanation
+**Source:** a 1,200-word news article about a municipal transit funding decision.
 
-**Without CoD:**
-```
-Explain how this algorithm works.
-```
+**Step 1 (sparse, ~80 words):**
+> This article discusses a recent decision made by local government officials regarding transportation. It covers the various considerations that were taken into account during the deliberation process, as well as some of the reactions from different groups. The piece also touches on the broader context surrounding the issue and what it might mean going forward for the region and the people who live there.
 
-**With CoD:**
-```
-Explain this algorithm through progressive refinement:
+Entities: 0 meaningful. Pure filler — by design.
 
-PASS 1 - COMPREHENSIVE:
-Explain thoroughly, assuming no prior knowledge. Include:
-- What it does
-- How it works
-- Why it's designed this way
-- Example walkthrough
+**Step 2 (same length, entities fused in):**
+> Portland's city council voted 4-1 on Tuesday to redirect $47 million from the Southwest Corridor light-rail project to bus rapid transit, citing a 30% cost overrun. Commissioner Dana Reyes cast the dissenting vote. TriMet, which operates the region's transit, had lobbied for the shift. Riders' advocacy group OPAL called the decision a setback for east-side commuters, while the Portland Business Alliance welcomed it.
 
-PASS 2 - REFINED:
-Review Pass 1. What's unclear? What's redundant? Rewrite addressing these.
+Same word budget. The filler is gone; ten specific entities took its place.
 
-PASS 3 - OPTIMIZED:
-Make it maximally clear and concise. Every paragraph must earn its place.
+**Steps 3-5** continue fusing — ridership figures, the revised completion date, the federal grant condition — each time compressing existing phrasing to make room.
 
-PASS 4 - POLISHED:
-Final pass. Perfect clarity, zero fluff, optimal examples.
+## Best Practices
 
-Show all passes and note significant improvements.
-```
+1. **Enforce the length constraint explicitly.** Models drift toward expanding. "Use the exact same number of words for each summary" is not optional boilerplate.
+2. **Let the first summary be bad.** The instinct is to start strong; resist it. A dense first summary leaves no slack, and the chain stalls immediately.
+3. **Ask for all iterations in one response.** The paper uses a single prompt returning a JSON list of five. Splitting it across turns loses the model's view of the prior chain.
+4. **Pick the step, don't assume the last.** Step 5 is the densest but not the most readable. Steps 2-3 won the human evaluation.
+5. **Watch for the readability tradeoff.** Past a point, dense summaries read as lists of facts. The paper found this explicitly.
 
 ## 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]
-```
+Use CO-STAR to fix audience, tone, and format for the summary; use CoD to maximize what fits in that format. Useful when the summary has a specific reader.
 
 ### 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
+Ask the model to reason about which entities are most salient before selecting them. Helps when the source is long and salience is contested.
 
 ## 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
+- [ ] Is the task actually summarization? (If not, CoD is the wrong framework.)
+- [ ] Is a fixed target length stated?
+- [ ] Is the first summary deliberately sparse and padded?
+- [ ] Are entity criteria included in the prompt?
+- [ ] Does each step preserve all prior entities?
+- [ ] Is the word count roughly constant across steps?
+- [ ] Was the chosen step selected on merit rather than defaulting to the last?
 
 ## 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
+1. **Fixed length, rising density** — if length is falling, it is not CoD
+2. **Start verbose on purpose** — the filler is the raw material
+3. **1-3 entities per step** — more causes dropped content
+4. **Five steps is the paper's number** — fewer works; more yields diminishing returns
+5. **Compare steps before choosing** — the densest is rarely the most useful

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

@@ -4,6 +4,8 @@
 
 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.
 
+**Research basis:** "Chain-of-Thought Prompting Elicits Reasoning in Large Language Models" (Wei et al., Google Research, arXiv 2201.11903, NeurIPS 2022). Prompting PaLM 540B with eight chain-of-thought exemplars raised GSM8K accuracy from 17.9% with standard prompting to 56.9%, beating the prior fine-tuned state of the art of 55% (GPT-3 plus a verifier, Cobbe et al. 2021).
+
 ## Core Concept
 
 CoT works by:
@@ -319,24 +321,27 @@ STEPS:
 ### Self-Consistency
 Generate multiple reasoning paths and choose the most common answer:
 
+**Research basis:** "Self-Consistency Improves Chain of Thought Reasoning in Language Models" (Wang et al., arXiv 2203.11171, ICLR 2023). Sample a diverse set of reasoning paths rather than greedy-decoding one, then "marginalize out the reasoning paths and aggregate by choosing the most consistent answer in the final answer set." On PaLM 540B / GSM8K, a majority vote over 40 sampled paths reached 74.4% versus 56.5% for greedy CoT decoding (+17.9 points); an unweighted majority vote matched or beat every weighted aggregation the authors tested.
+
+The mechanism is **sampling the same prompt repeatedly and taking a majority vote** — not asking the model to try different methods and then judge which it likes best. Self-assessment is a different (and weaker) technique; the model is not a reliable judge of its own reasoning.
+
 ```
-Solve this problem using three different approaches:
+Solve this problem. Show your step-by-step reasoning, then state your final
+answer on its own line as:
 
-APPROACH 1:
-[Method 1 with step-by-step reasoning]
+FINAL ANSWER: [answer]
 
-APPROACH 2:
-[Method 2 with step-by-step reasoning]
+[Problem]
+```
 
-APPROACH 3:
-[Method 3 with step-by-step reasoning]
+Run this **same prompt N times at non-zero temperature** (the paper samples 40; 5-10 is usually enough in practice, and temperature ~0.7 is a reasonable default). Then aggregate outside the model:
 
-COMPARISON:
-Which approach is most reliable and why?
+1. Extract the `FINAL ANSWER:` value from each of the N samples
+2. Count how often each distinct answer appears
+3. Return the most frequent answer — a plain, unweighted majority vote
+4. Treat a near-tie as a signal of genuine uncertainty, not as a reason to ask the model to break the tie
 
-FINAL ANSWER:
-Based on the most consistent result.
-```
+Do **not** ask the model to compare its own paths and pick the best one. The diversity of independently sampled reasoning is what produces the gain; collapsing it into a single self-judgment discards exactly the signal the method depends on.
 
 ### Uncertainty Quantification
 ```

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

@@ -4,6 +4,8 @@
 
 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.
 
+**Origin:** Developed by the Data Science & AI team at GovTech (Government Technology Agency of Singapore), and popularized by Sheila Teo, who won GovTech's "Prompt Royale" — Singapore's first GPT-4 prompt engineering competition, 400+ participants, finale 8 November 2023. Teo credits the framework to GovTech rather than to herself: "The CO-STAR framework, a brainchild of GovTech Singapore's Data Science & AI team, is a handy template for structuring prompts." Practitioner framework — no controlled evaluation of CO-STAR has been published.
+
 ## Components
 
 ### C - Context

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

@@ -4,6 +4,8 @@
 
 CTF is a simple 3-component framework focused on situational context, task clarity, and output format. It is ideal for tasks where background/situation is more important than AI persona framing, and the primary concern is getting a clearly defined output from a well-understood context.
 
+**Origin:** No single documented originator. CTF appears in the community framework literature as a variant of RTF, with Context substituted for Role, documented alongside it in unattributed practitioner listings from 2024 onward (e.g. fvivas.com, 15 March 2024). No academic treatment; absent from The Prompt Report (arXiv 2406.06608).
+
 ## Components
 
 ### C - Context
@@ -168,7 +170,7 @@ Markdown template with:
 - ❌ Audience and tone are critical (use CO-STAR)
 - ❌ Multi-step process with methodology needed (use RISEN)
 - ❌ Explicit dos/don'ts required (use TIDD-EC)
-- ❌ Input→output transformation (use RISE-IE)
+- ❌ Input→output transformation (use RISE — the Role/Input/Steps/Expectation form)
 
 ## CTF vs RTF