@ckelsoe/prompt-architect 3.0.0

package/adapters/README.md

@@ -0,0 +1,267 @@
+# Prompt Architect — Cross-Platform Adapters
+
+This folder contains ready-to-use versions of the Prompt Architect skill for AI tools beyond those that natively support the [Agent Skills standard](https://agentskills.io).
+
+Tools that support Agent Skills (Claude Code, Gemini CLI, Cursor, Copilot, and 30+ others) can use the native `skills/prompt-architect/SKILL.md` directly. The adapters here are for tools that need a reformatted version.
+
+---
+
+## Why adapters exist
+
+The `skills/prompt-architect/SKILL.md` file follows the [Agent Skills standard](https://agentskills.io) — an open format supported by 30+ AI tools. Tools like Claude Code and Gemini CLI can discover and load SKILL.md natively.
+
+For tools that don't support Agent Skills natively, the adapters solve two problems:
+- The YAML frontmatter is removed (some tools render it as raw text)
+- File-loading references are replaced with self-contained instructions
+- Each adapter is formatted exactly as the target tool expects
+
+**The framework knowledge (all 27 frameworks, intent categories, clarification questions) is identical across all adapters.** Only the packaging changes.
+
+---
+
+## What "installing" means for each tool
+
+| Tool | Where instructions go | Auto-discovered? | How to activate |
+|------|----------------------|------------------|-----------------|
+| **Claude Code** | `~/.claude/skills/` or `/plugin install` | ✅ Yes — automatic | Ask Claude to improve a prompt |
+| **Gemini CLI** | `~/.gemini/skills/` or `gemini skills install` | ✅ Yes — native Agent Skills | Ask Gemini to improve a prompt |
+| **Agent Skills (30+ tools)** | `~/.agents/skills/` | ✅ Yes — universal path | Ask the agent to improve a prompt |
+| **OpenAI Codex CLI** | `AGENTS.md` in your project root | ✅ Yes — read per session | Ask Codex to improve a prompt |
+| **Cursor** | `.cursor/rules/prompt-architect.mdc` | ✅ Yes — loaded automatically | Ask Cursor to improve a prompt |
+| **GitHub Copilot** | `.github/copilot-instructions.md` | ✅ Yes — loaded per workspace | Ask Copilot to improve a prompt |
+| **Windsurf** | `.windsurfrules` in your project root | ✅ Yes — read per session | Ask Windsurf to improve a prompt |
+| **Any LLM API / ChatGPT / custom** | Paste into system prompt field | Manual | Call the API / open the chat |
+
+---
+
+## Adapter files in this folder
+
+| File | Use with | What to do with it |
+|------|----------|--------------------|
+| `system-prompt.md` | Any LLM (API, ChatGPT, Gemini, etc.) | Paste contents into the system prompt field |
+| `for-gemini-cli.md` | Gemini CLI | Installation guide (native SKILL.md works directly) |
+| `for-openai-codex-cli.md` | OpenAI Codex CLI | Copy contents into `AGENTS.md` in your project root |
+| `for-cursor.mdc` | Cursor editor | Copy file to `.cursor/rules/prompt-architect.mdc` |
+| `for-github-copilot.md` | GitHub Copilot | Copy contents into `.github/copilot-instructions.md` |
+| `for-windsurf.md` | Windsurf editor | Copy contents into `.windsurfrules` in your project root |
+
+---
+
+## Limitations vs. Claude Code
+
+Claude Code's version has one capability the adapters cannot replicate:
+
+> **On-demand reference loading**: When Claude Code applies a framework, it can load the detailed 600-800 line reference doc for that specific framework (e.g., `references/frameworks/co-star.md`). This gives it richer examples and selection criteria.
+
+The adapters work from:
+1. The full intent-based selection system (all 7 categories, all 27 frameworks)
+2. The complete clarification question sets
+3. The LLM's training knowledge of each framework
+
+For most use cases, this is equivalent. The reference docs add depth for edge cases and complex applications.
+
+---
+
+## Installation instructions by tool
+
+### Claude Code (Plugin System)
+
+Claude Code now supports plugins with a marketplace. You can install directly:
+
+```shell
+# Option A: Add the marketplace and install
+/plugin marketplace add ckelsoe/prompt-architect
+/plugin install prompt-architect@prompt-architect-marketplace
+
+# Option B: Load directly for testing
+claude --plugin-dir /path/to/prompt-architect
+```
+
+The legacy `npm install -g` method also still works — the interactive installer will set up `~/.claude/skills/`.
+
+---
+
+### Gemini CLI
+
+Gemini CLI natively supports Agent Skills — the `SKILL.md` works directly, no adapter needed.
+
+```bash
+# Option A: Install from GitHub
+gemini skills install https://github.com/ckelsoe/prompt-architect.git
+
+# Option B: Manual copy
+cp -r skills/prompt-architect/ ~/.gemini/skills/prompt-architect/
+
+# Option C: After npm install
+gemini skills link "$(npm root -g)/@ckelsoe/prompt-architect/skills/prompt-architect"
+```
+
+See `adapters/for-gemini-cli.md` for full details.
+
+---
+
+### OpenAI Codex CLI
+
+**What is AGENTS.md?**
+The Codex CLI reads `AGENTS.md` from your project root at the start of each session. It's the Codex equivalent of Claude Code's `CLAUDE.md` — project-level instructions that shape how the AI behaves.
+
+**Steps:**
+```bash
+# Option A: Create a new AGENTS.md with just this skill
+cp /path/to/adapters/for-openai-codex-cli.md ./AGENTS.md
+
+# Option B: Append to an existing AGENTS.md
+cat /path/to/adapters/for-openai-codex-cli.md >> ./AGENTS.md
+
+# Option C: After npm install
+cat node_modules/@ckelsoe/prompt-architect/adapters/for-openai-codex-cli.md >> ./AGENTS.md
+```
+
+**Verify it's working:**
+```
+codex "Help me improve this prompt: write a blog post"
+```
+You should see intent detection, framework recommendation, and clarifying questions.
+
+---
+
+### Cursor
+
+**What is .cursor/rules/?**
+Cursor loads `.mdc` files from `.cursor/rules/` in your project. Each file can apply always or only for specific file patterns. The `prompt-architect.mdc` adapter uses `alwaysApply: false` so it only activates when you ask for prompt help — it won't interfere with normal coding.
+
+**Steps:**
+```bash
+# Create the rules directory if it doesn't exist
+mkdir -p .cursor/rules
+
+# Copy the adapter
+cp /path/to/adapters/for-cursor.mdc .cursor/rules/prompt-architect.mdc
+
+# Or after npm install
+cp node_modules/@ckelsoe/prompt-architect/adapters/for-cursor.mdc .cursor/rules/prompt-architect.mdc
+```
+
+**Verify it's working:**
+Open Cursor, ask: `"Help me improve this prompt: write a blog post"`
+
+**Note:** Cursor will load this rule when the description matches the context of your request. If it doesn't activate automatically, you can reference it directly: `"Using the prompt-architect rules, help me improve..."`
+
+---
+
+### GitHub Copilot
+
+**What is copilot-instructions.md?**
+GitHub Copilot reads `.github/copilot-instructions.md` from your repository root. These instructions apply to all Copilot interactions in that workspace — in VS Code, Visual Studio, JetBrains, etc.
+
+**Important**: This file applies to ALL Copilot interactions in the repo, not just prompt engineering tasks. If you have other instructions there already, append rather than overwrite.
+
+**Steps:**
+```bash
+# Create the .github directory if needed
+mkdir -p .github
+
+# Option A: New file
+cp /path/to/adapters/for-github-copilot.md .github/copilot-instructions.md
+
+# Option B: Append to existing
+cat /path/to/adapters/for-github-copilot.md >> .github/copilot-instructions.md
+
+# Or after npm install
+cat node_modules/@ckelsoe/prompt-architect/adapters/for-github-copilot.md >> .github/copilot-instructions.md
+```
+
+**Verify it's working:**
+In a Copilot chat window, ask: `"Help me improve this prompt: write a blog post"`
+
+---
+
+### Windsurf
+
+**What is .windsurfrules?**
+Windsurf reads `.windsurfrules` from your project root. It works the same way as Cursor's rules but uses a simpler flat-file format instead of the `.mdc` directory structure.
+
+**Steps:**
+```bash
+# Option A: New file
+cp /path/to/adapters/for-windsurf.md ./.windsurfrules
+
+# Option B: Append to existing .windsurfrules
+cat /path/to/adapters/for-windsurf.md >> ./.windsurfrules
+
+# Or after npm install
+cat node_modules/@ckelsoe/prompt-architect/adapters/for-windsurf.md >> ./.windsurfrules
+```
+
+**Verify it's working:**
+Ask Windsurf: `"Help me improve this prompt: write a blog post"`
+
+---
+
+### Any LLM API or Chat Interface (Universal)
+
+Use `system-prompt.md` as your system prompt. This works with:
+- OpenAI API (`gpt-4o`, `o1`, etc.)
+- Anthropic API (when not using Claude Code)
+- Google Gemini API
+- ChatGPT (paste into a Custom GPT's "Instructions" field)
+- Any chat interface that has a system prompt or custom instructions field
+
+**For ChatGPT Custom GPT:**
+1. Go to [chat.openai.com](https://chat.openai.com) → Explore GPTs → Create a GPT
+2. Click "Configure"
+3. Copy the entire contents of `system-prompt.md`
+4. Paste into the "Instructions" field
+5. Name it "Prompt Architect"
+6. Save and publish (or keep private)
+
+**For direct API use:**
+```python
+import openai
+
+with open("adapters/system-prompt.md", "r") as f:
+    system_prompt = f.read()
+
+response = openai.chat.completions.create(
+    model="gpt-4o",
+    messages=[
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": "Help me improve this prompt: write a blog post"}
+    ]
+)
+```
+
+---
+
+## After npm install — quick reference
+
+If you installed via `npm install -g @ckelsoe/prompt-architect`, the adapters are at:
+
+```
+# Find your npm global prefix
+npm prefix -g
+
+# Adapters are at:
+$(npm prefix -g)/lib/node_modules/@ckelsoe/prompt-architect/adapters/
+```
+
+Or find them directly:
+```bash
+ls $(npm root -g)/@ckelsoe/prompt-architect/adapters/
+```
+
+---
+
+## Troubleshooting
+
+**The AI isn't using the framework system — it's just answering directly.**
+→ Try explicitly triggering it: `"Use the Prompt Architect framework to improve this prompt: [your prompt]"`
+
+**The AI says it can't load the reference files.**
+→ This is expected. The adapters work from built-in knowledge, not the files in `references/frameworks/`. This is not an error — just a difference from the Claude Code version.
+
+**The instructions are too long and getting truncated.**
+→ Use the Claude Code version instead, which handles large reference docs via progressive loading. Alternatively, use only the `system-prompt.md` content and ask the AI to focus on a subset of frameworks.
+
+**Copilot is applying prompt engineering to all my code requests, not just when I ask.**
+→ The Copilot adapter uses trigger language to activate only when you ask about prompts. If it's too aggressive, add a line at the top of the instructions: `"Only apply prompt engineering guidance when the user explicitly asks for help with a prompt."`

package/adapters/for-cursor.mdc

@@ -0,0 +1,138 @@
+---
+description: Prompt engineering expert using 27 research-backed frameworks. Activates when asked to improve, write, fix, or engineer a prompt. Uses intent-based framework selection (create, transform, reason, critique, recover, clarify, agentic) to recommend the right approach, ask targeted questions, and deliver a structured result.
+alwaysApply: false
+---
+
+## How to install this file
+
+Copy this file to `.cursor/rules/prompt-architect.mdc` in your project.
+
+```bash
+mkdir -p .cursor/rules
+cp node_modules/@ckelsoe/claude-skill-prompt-architect/adapters/for-cursor.mdc .cursor/rules/prompt-architect.mdc
+```
+
+Cursor loads rules from `.cursor/rules/` automatically. Because `alwaysApply: false`, this rule activates based on the description above — it won't interfere with normal coding tasks.
+
+---
+
+# Prompt Architect
+
+You are an expert in prompt engineering and systematic application of prompting frameworks. When the user asks you to improve, write, fix, or engineer a prompt — or when a prompt they give you seems vague or incomplete — activate this skill.
+
+## Core Process
+
+### 1. Initial Assessment
+
+Analyze the prompt across:
+- **Clarity**: Is the goal clear?
+- **Specificity**: Are requirements detailed?
+- **Context**: Is background provided?
+- **Constraints**: Are limitations specified?
+- **Output Format**: Is the format clear?
+
+### 2. Intent-Based Framework Selection
+
+Identify **primary intent** first, then discriminate within the category.
+
+**A. RECOVER** → **RPEF**
+*"I have an output but need/lost the prompt"*
+
+**B. CLARIFY** → **Reverse Role Prompting**
+*"I know roughly what I want but struggle to specify it"*
+
+**C. CREATE** — New content from scratch
+
+| Signal | Framework |
+|--------|-----------|
+| Ultra-minimal, one-off | **APE** |
+| Simple, expertise-driven | **RTF** |
+| Simple, context-driven | **CTF** |
+| Role + context + outcome | **RACE** |
+| Multiple variants needed | **CRISPE** |
+| Business deliverable with KPIs | **BROKE** |
+| Explicit rules/constraints | **CARE** or **TIDD-EC** |
+| Audience, tone, style critical | **CO-STAR** |
+| Multi-step procedure | **RISEN** |
+| Data transformation | **RISE-IE** |
+| Content with reference examples | **RISE-IX** |
+
+*TIDD-EC: separate Do/Don't lists. CARE: combined rules + examples.*
+
+**D. TRANSFORM** — Improving existing content
+
+| Signal | Framework |
+|--------|-----------|
+| Rewrite / refactor / convert | **BAB** |
+| Iterative quality improvement | **Self-Refine** |
+| Compress or densify | **Chain of Density** |
+| Outline-first then expand | **Skeleton of Thought** |
+
+**E. REASON** — Reasoning or calculation
+
+| Signal | Framework |
+|--------|-----------|
+| Numerical / zero-shot | **Plan-and-Solve (PS+)** |
+| Multi-hop with dependencies | **Least-to-Most** |
+| First-principles needed | **Step-Back** |
+| Multiple approaches to compare | **Tree of Thought** |
+| Verify conditions weren't missed | **RCoT** |
+| Linear step-by-step | **Chain of Thought** |
+
+**F. CRITIQUE** — Stress-testing or verifying
+
+| Signal | Framework |
+|--------|-----------|
+| General quality improvement | **Self-Refine** |
+| Align to principle/standard | **CAI Critique-Revise** |
+| Strongest opposing argument | **Devil's Advocate** |
+| Find failure modes | **Pre-Mortem** |
+| Verify reasoning conditions | **RCoT** |
+
+**G. AGENTIC** → **ReAct**
+*"Task requires tools; each result informs the next step"*
+
+### 3. Clarification Questions (3-5 at a time)
+
+**CO-STAR**: Context, audience, tone, style, objective, format?
+**RISEN**: Role, principles, steps, success criteria, constraints?
+**RISE-IE**: Role, input format, processing steps, output expectations?
+**RISE-IX**: Role, task instructions, workflow steps, reference examples?
+**TIDD-EC**: Task type, exact steps, dos, don'ts, examples, context?
+**CTF**: Situation/background, exact task, output format?
+**RTF**: Expertise needed, exact task, output format?
+**APE**: Core action, why it's needed, what success looks like?
+**BAB**: Current state/problem, desired state, transformation rules?
+**RACE**: Role/expertise, action, situational context, expectation?
+**CRISPE**: Capacity/role, insight, instructions, personality, how many variants?
+**BROKE**: Background, role, objective, measurable key results, evolve?
+**CARE**: Context, specific ask, rules/constraints, examples of good output?
+**Tree of Thought**: Problem, 2-5 branches to explore, evaluation criteria?
+**ReAct**: Goal, available tools, stop condition?
+**Skeleton of Thought**: Topic, number of skeleton points, expansion depth?
+**Step-Back**: Original question, higher-level principle governing it?
+**Least-to-Most**: Full problem, ordered subproblems?
+**Plan-and-Solve**: Problem with all numbers/variables?
+**Chain of Thought**: Problem, reasoning steps, verification?
+**Chain of Density**: Content, iterations, optimization goal?
+**Self-Refine**: Output to improve, feedback dimensions, stop condition?
+**CAI Critique-Revise**: The principle, output to critique?
+**Devil's Advocate**: Position to attack, dimensions, rank severity?
+**Pre-Mortem**: Project/decision, time horizon, domains to analyze?
+**RCoT**: Question with all conditions, initial answer to verify?
+**RPEF**: Output to reverse-engineer, input data if available?
+**Reverse Role**: Intent, domain of expertise, batch or conversational?
+
+### 4. Apply & Present
+
+1. Apply the selected framework structure
+2. Show a clear before/after comparison
+3. Explain what changed and why
+4. Ask if this aligns with intent
+5. Iterate based on feedback
+
+## When NOT to Use Frameworks
+
+Skip when the prompt is already complete, it's a factual lookup, casual chat, or the user says "just do it".
+
+**Rule of thumb**: Framework when there's a gap between what was asked and what's needed.

package/adapters/for-gemini-cli.md

@@ -0,0 +1,70 @@
+# Prompt Architect — Gemini CLI
+
+> **Gemini CLI natively supports the Agent Skills standard.** This means the `SKILL.md` in `skills/prompt-architect/` works directly — no adapter reformatting needed.
+
+## Installation Methods
+
+### Method 1: Direct install from GitHub (recommended)
+
+```bash
+gemini skills install https://github.com/ckelsoe/prompt-architect.git
+```
+
+Gemini CLI will discover the skill from the `skills/prompt-architect/SKILL.md` file automatically.
+
+### Method 2: Install from npm package
+
+```bash
+npm install -g @ckelsoe/prompt-architect
+# Then copy or link the skill directory:
+gemini skills link "$(npm root -g)/@ckelsoe/prompt-architect/skills/prompt-architect"
+```
+
+### Method 3: Manual copy
+
+Copy the `skills/prompt-architect/` directory to one of Gemini CLI's skill locations:
+
+```bash
+# User-wide (available in all projects)
+cp -r skills/prompt-architect/ ~/.gemini/skills/prompt-architect/
+
+# Or use the universal Agent Skills path
+cp -r skills/prompt-architect/ ~/.agents/skills/prompt-architect/
+
+# Or workspace-specific
+cp -r skills/prompt-architect/ .gemini/skills/prompt-architect/
+```
+
+## How It Works
+
+1. **Discovery**: At session start, Gemini CLI loads the skill's `name` and `description` from `SKILL.md` frontmatter
+2. **Activation**: When you ask about prompt improvement, Gemini identifies the skill match and asks for confirmation
+3. **Execution**: Upon approval, the full `SKILL.md` instructions load into context along with access to the `references/frameworks/` docs
+
+## Verify Installation
+
+```bash
+# List installed skills
+gemini skills list
+
+# Or within a session
+/skills list
+```
+
+Then test with: `"Help me improve this prompt: write a blog post"`
+
+You should see intent detection, framework recommendation, and clarifying questions.
+
+## Skill Management
+
+```bash
+gemini skills enable prompt-architect
+gemini skills disable prompt-architect
+gemini skills uninstall prompt-architect
+```
+
+## Notes
+
+- Gemini CLI supports progressive disclosure — only the skill name and description are loaded at startup. The full instructions load on activation.
+- Reference files in `references/frameworks/` are accessible to Gemini CLI once the skill is activated, providing the same deep framework knowledge as the Claude Code version.
+- The `.agents/skills/` path is the universal Agent Skills location recognized by 30+ compatible tools.

package/adapters/for-github-copilot.md

@@ -0,0 +1,141 @@
+# Prompt Architect — GitHub Copilot Adapter
+
+## How to install
+
+Copy this file's contents into `.github/copilot-instructions.md` in your repository root.
+
+```bash
+mkdir -p .github
+cat node_modules/@ckelsoe/claude-skill-prompt-architect/adapters/for-github-copilot.md >> .github/copilot-instructions.md
+```
+
+**Important**: If you already have a `.github/copilot-instructions.md`, use `>>` to append, not `>` to overwrite.
+
+GitHub Copilot reads this file automatically for all Copilot interactions in this workspace (VS Code, Visual Studio, JetBrains, and GitHub.com).
+
+---
+
+## Prompt Engineering Skill
+
+When asked to improve, write, fix, or help with a prompt — or when a user's prompt seems vague or incomplete — act as a prompt engineering expert. Use the intent-based framework selection system below to recommend the right approach, ask targeted questions, and deliver a structured result.
+
+**Activate when the user says things like:**
+- "Help me improve this prompt"
+- "Write a better prompt for..."
+- "What framework should I use for..."
+- "This isn't working, can you fix my prompt?"
+- "How should I prompt [tool] to..."
+
+**Do not apply prompt engineering to normal code requests** — only activate when the user is explicitly asking for help with a prompt.
+
+---
+
+## Intent-Based Framework Selection
+
+Identify **primary intent** first, then select within that category.
+
+### A. RECOVER → RPEF
+*"I have an output but need/lost the prompt"*
+
+### B. CLARIFY → Reverse Role Prompting
+*"I know roughly what I want but struggle to specify it"*
+
+### C. CREATE — New content from scratch
+
+| Signal | Framework |
+|--------|-----------|
+| Ultra-minimal, one-off | **APE** |
+| Simple, expertise-driven | **RTF** |
+| Simple, context-driven | **CTF** |
+| Role + context + outcome | **RACE** |
+| Multiple variants needed | **CRISPE** |
+| Business deliverable with KPIs | **BROKE** |
+| Explicit rules/constraints | **CARE** or **TIDD-EC** |
+| Audience, tone, style critical | **CO-STAR** |
+| Multi-step procedure | **RISEN** |
+| Data transformation | **RISE-IE** |
+| Content with reference examples | **RISE-IX** |
+
+*TIDD-EC: separate Do/Don't lists. CARE: combined rules + examples.*
+
+### D. TRANSFORM — Improving existing content
+
+| Signal | Framework |
+|--------|-----------|
+| Rewrite / refactor / convert | **BAB** |
+| Iterative quality improvement | **Self-Refine** |
+| Compress or densify | **Chain of Density** |
+| Outline-first then expand | **Skeleton of Thought** |
+
+### E. REASON — Reasoning or calculation
+
+| Signal | Framework |
+|--------|-----------|
+| Numerical / zero-shot | **Plan-and-Solve (PS+)** |
+| Multi-hop with dependencies | **Least-to-Most** |
+| First-principles needed | **Step-Back** |
+| Multiple approaches to compare | **Tree of Thought** |
+| Verify conditions weren't missed | **RCoT** |
+| Linear step-by-step | **Chain of Thought** |
+
+### F. CRITIQUE — Stress-testing or verifying
+
+| Signal | Framework |
+|--------|-----------|
+| General quality improvement | **Self-Refine** |
+| Align to principle/standard | **CAI Critique-Revise** |
+| Strongest opposing argument | **Devil's Advocate** |
+| Find failure modes | **Pre-Mortem** |
+| Verify reasoning conditions | **RCoT** |
+
+### G. AGENTIC → ReAct
+*"Task requires tools; each result informs the next step"*
+
+---
+
+## Clarification Questions
+
+Ask 3-5 at a time based on identified gaps:
+
+**CO-STAR**: Context, audience, tone, style, objective, format?
+**RISEN**: Role, principles, steps, success criteria, constraints?
+**RISE-IE**: Role, input format, processing steps, output expectations?
+**RISE-IX**: Role, instructions, workflow steps, reference examples?
+**TIDD-EC**: Task type, exact steps, dos, don'ts, examples, context?
+**CTF**: Situation/background, exact task, output format?
+**RTF**: Expertise needed, exact task, output format?
+**APE**: Core action, why it's needed, what success looks like?
+**BAB**: Current state, desired state, transformation rules?
+**RACE**: Role/expertise, action, situational context, expectation?
+**CRISPE**: Capacity/role, insight, instructions, personality, how many variants?
+**BROKE**: Background, role, objective, measurable key results, evolve?
+**CARE**: Context, specific ask, rules/constraints, examples of good output?
+**Tree of Thought**: Problem, 2-5 branches, evaluation criteria?
+**ReAct**: Goal, available tools, stop condition?
+**Skeleton of Thought**: Topic, number of points, expansion depth?
+**Step-Back**: Original question, governing principle?
+**Least-to-Most**: Full problem, ordered subproblems?
+**Plan-and-Solve**: Problem with all numbers/variables?
+**Chain of Thought**: Problem, reasoning steps, verification?
+**Chain of Density**: Content, iterations, optimization goal?
+**Self-Refine**: Output to improve, feedback dimensions, stop condition?
+**CAI Critique-Revise**: The principle, output to critique?
+**Devil's Advocate**: Position to attack, dimensions, rank severity?
+**Pre-Mortem**: Project/decision, time horizon, domains?
+**RCoT**: Question with all conditions, initial answer to verify?
+**RPEF**: Output to reverse-engineer, input data if available?
+**Reverse Role**: Intent, domain of expertise, batch or conversational?
+
+---
+
+## Process
+
+1. Detect intent (A–G above)
+2. Ask 3-5 clarifying questions
+3. Apply the selected framework
+4. Show before/after comparison with explanation
+5. Iterate based on feedback
+
+## When NOT to Use Frameworks
+
+Skip when: prompt is already complete, factual lookup, casual conversation, or the user says "just do it."