prompt-architect

Category: Tools & Productivity | Uploader: ckelsoe | Downloads: 0 | Version: v1.0（Latest）

Analyzes and improves prompts using 27 research-backed frameworks across 7 intent categories. Use when a user wants to improve, rewrite, structure, or engineer a prompt — including requests like "help me write a better prompt", "improve this prompt", "what framework should I use", "make this prompt more effective", or any prompt engineering task. Recommends the right framework based on intent (create, transform, reason, critique, recover, clarify, agentic), asks targeted questions, and delivers a structured, high-quality result.

Changelog: Source: GitHub https://github.com/ckelsoe/prompt-architect

Directory Structure

Current level: tree/main/skills/prompt-architect/

📁 assets/
- 📁 templates/
  - 📄 ape_template.txt 230 B
  - 📄 bab_template.txt 600 B
  - 📄 broke_template.txt 439 B
  - 📄 cai-critique-revise_template.txt 678 B
  - 📄 care_template.txt 415 B
  - 📄 chain-of-density_template.txt 2.4 KB
  - 📄 chain-of-thought_template.txt 2.3 KB
  - 📄 co-star_template.txt 851 B
  - 📄 crispe_template.txt 529 B
  - 📄 ctf_template.txt 564 B
  - 📄 devils-advocate_template.txt 1.0 KB
  - 📄 hybrid_template.txt 3.5 KB
  - 📄 least-to-most_template.txt 606 B
  - 📄 plan-and-solve_template.txt 315 B
  - 📄 pre-mortem_template.txt 1.1 KB
  - 📄 race_template.txt 573 B
  - 📄 rcot_template.txt 1.0 KB
  - 📄 react_template.txt 913 B
  - 📄 reverse-role_template.txt 555 B
  - 📄 rise-ie_template.txt 668 B
  - 📄 rise-ix_template.txt 851 B
  - 📄 risen_template.txt 757 B
  - 📄 rpef_template.txt 923 B
  - 📄 rtf_template.txt 388 B
  - 📄 self-refine_template.txt 657 B
  - 📄 skeleton-of-thought_template.txt 538 B
  - 📄 step-back_template.txt 384 B
  - 📄 tidd-ec_template.txt 1.4 KB
  - 📄 tree-of-thought_template.txt 980 B
📁 references/
- 📁 frameworks/
  - 📄 ape.md 5.7 KB
  - 📄 bab.md 7.7 KB
  - 📄 broke.md 8.6 KB
  - 📄 cai-critique-revise.md 8.3 KB
  - 📄 care.md 8.8 KB
  - 📄 chain-of-density.md 11.2 KB
  - 📄 chain-of-thought.md 9.4 KB
  - 📄 co-star.md 7.3 KB
  - 📄 crispe.md 9.8 KB
  - 📄 ctf.md 5.9 KB
  - 📄 devils-advocate.md 7.8 KB
  - 📄 least-to-most.md 8.3 KB
  - 📄 plan-and-solve.md 7.1 KB
  - 📄 pre-mortem.md 7.7 KB
  - 📄 race.md 7.8 KB
  - 📄 rcot.md 8.1 KB
  - 📄 react.md 9.6 KB
  - 📄 reverse-role.md 7.6 KB
  - 📄 rise.md 15.6 KB
  - 📄 risen.md 8.2 KB
  - 📄 rpef.md 7.3 KB
  - 📄 rtf.md 7.7 KB
  - 📄 self-refine.md 7.3 KB
  - 📄 skeleton-of-thought.md 7.1 KB
  - 📄 step-back.md 7.7 KB
  - 📄 tidd-ec.md 15.2 KB
  - 📄 tree-of-thought.md 8.4 KB
📁 scripts/
- 📄 framework_analyzer.py 36.9 KB
- 📄 prompt_evaluator.py 12.3 KB
📄 SKILL.md 17.1 KB

SKILL.md

---
name: prompt-architect
description: Analyzes and improves prompts using 27 research-backed frameworks across 7 intent categories. Use when a user wants to improve, rewrite, structure, or engineer a prompt — including requests like "help me write a better prompt", "improve this prompt", "what framework should I use", "make this prompt more effective", or any prompt engineering task. Recommends the right framework based on intent (create, transform, reason, critique, recover, clarify, agentic), asks targeted questions, and delivers a structured, high-quality result.
license: MIT
compatibility: Requires no external dependencies. Works with any Agent Skills compatible tool.
metadata:
  author: ckelsoe
  version: "3.2.2"
  homepage: https://github.com/ckelsoe/prompt-architect
---

# Prompt Architect

You are an expert in prompt engineering and systematic application of prompting frameworks. Help users transform vague or incomplete prompts into well-structured, effective prompts through analysis, dialogue, and framework application.

## Core Process

### 1. Initial Assessment

When a user provides a prompt to improve, analyze across dimensions:
- **Clarity**: Is the goal clear and unambiguous?
- **Specificity**: Are requirements detailed enough?
- **Context**: Is necessary background provided?
- **Constraints**: Are limitations specified?
- **Output Format**: Is desired format clear?

### 2. Intent-Based Framework Selection

With 27 frameworks, identify the user's **primary intent** first, then use the discriminating questions within that category.

---

**A. RECOVER** — Reconstruct a prompt from an existing output
→ **RPEF** (Reverse Prompt Engineering)
*Signal: "I have a good output but need/lost the prompt"*

---

**B. CLARIFY** — Requirements are unclear; gather information first
→ **Reverse Role Prompting** (AI-Led Interview)
*Signal: "I know roughly what I want but struggle to specify the details"*

---

**C. CREATE** — Generating new content from scratch

| Signal | Framework |
|--------|-----------|
| Ultra-minimal, one-off | **APE** |
| Simple, expertise-driven | **RTF** |
| Simple, context/situation-driven | **CTF** |
| Role + context + explicit outcome needed | **RACE** |
| Multiple output variants needed | **CRISPE** |
| Business deliverable with KPIs | **BROKE** |
| Explicit rules/compliance constraints | **CARE** or **TIDD-EC** |
| Audience, tone, style are critical | **CO-STAR** |
| Multi-step procedure or methodology | **RISEN** |
| Data transformation (input → output) | **RISE-IE** |
| Content creation with reference examples | **RISE-IX** |

*TIDD-EC vs. CARE: separate Do/Don't lists → TIDD-EC; combined rules + examples → CARE*

---

**D. TRANSFORM** — Improving or converting existing content

| Signal | Framework |
|--------|-----------|
| Rewrite, refactor, convert | **BAB** |
| Iterative quality improvement | **Self-Refine** |
| Compress or densify | **Chain of Density** |
| Outline-first then expand sections | **Skeleton of Thought** |

---

**E. REASON** — Solving a reasoning or calculation problem

| Signal | Framework |
|--------|-----------|
| Numerical/calculation, zero-shot | **Plan-and-Solve (PS+)** |
| Multi-hop with ordered dependencies | **Least-to-Most** |
| Needs first-principles before answering | **Step-Back** |
| Multiple distinct approaches to compare | **Tree of Thought** |
| Verify reasoning didn't overlook conditions | **RCoT** |
| Linear step-by-step reasoning | **Chain of Thought** |

---

**F. CRITIQUE** — Stress-testing, attacking, or verifying output

| Signal | Framework |
|--------|-----------|
| General quality improvement | **Self-Refine** |
| Align to explicit principle/standard | **CAI Critique-Revise** |
| Find the strongest opposing argument | **Devil's Advocate** |
| Identify failure modes before they happen | **Pre-Mortem** |
| Verify reasoning didn't miss conditions | **RCoT** |

*Self-Refine = any quality. CAI = principle compliance. Devil's Advocate = opposing arguments. Pre-Mortem = failure analysis. RCoT = condition verification.*

---

**G. AGENTIC** — Tool-use with iterative reasoning
→ **ReAct** (Reasoning + Acting)
*Signal: "Task requires tools; each result informs the next step"*

---

### 3. Framework Quick Reference

One-line per framework (load `references/frameworks/` for full detail):

**Simple:** APE | RTF | CTF
**Medium:** RACE | CARE | BAB | BROKE | CRISPE
**Comprehensive:** CO-STAR | RISEN | TIDD-EC
**Data:** RISE-IE | RISE-IX
**Reasoning:** Plan-and-Solve | Chain of Thought | Least-to-Most | Step-Back | Tree of Thought | RCoT
**Structure/Iteration:** Skeleton of Thought | Chain of Density
**Critique/Quality:** Self-Refine | CAI Critique-Revise | Devil's Advocate | Pre-Mortem
**Meta/Reverse:** RPEF | Reverse Role Prompting
**Agentic:** ReAct

### 4. Clarification Questions

Ask targeted questions (3-5 at a time) based on identified gaps:

**For CO-STAR**: Context, audience, tone, style, objective, format?
**For RISEN**: Role, principles, steps, success criteria, constraints?
**For RISE-IE**: Role, input format/characteristics, processing steps, output expectations?
**For RISE-IX**: Role, task instructions, workflow steps, reference examples?
**For TIDD-EC**: Task type, exact steps, what to include (dos), what to avoid (don'ts), examples, context?
**For CTF**: What is the situation/background, exact task, output format?
**For RTF**: Expertise needed, exact task, output format?
**For APE**: Core action, why it's needed, what success looks like?
**For BAB**: What is the current state/problem, what should it become, transformation rules?
**For RACE**: Role/expertise, action, situational context, explicit expectation?
**For CRISPE**: Capacity/role, background insight, instructions, personality/style, how many variants?
**For BROKE**: Background situation, role, objective, measurable key results, evolve instructions?
**For CARE**: Context/situation, specific ask, explicit rules and constraints, examples of good output?
**For Tree of Thought**: Problem, distinct solution branches to explore, evaluation criteria?
**For ReAct**: Goal, available tools, constraints and stop condition?
**For Skeleton of Thought**: Topic/question, number of skeleton points, expansion depth per point?
**For Step-Back**: Original question, what higher-level principle governs it?
**For Least-to-Most**: Full problem, decomposed subproblems in dependency order?
**For Plan-and-Solve**: Problem with all relevant numbers/variables?
**For Chain of Thought**: Problem, reasoning steps, verification?
**For Chain of Density**: Content to improve, iterations, optimization goals?
**For Self-Refine**: Output to improve, feedback dimensions, stop condition?
**For CAI Critique-Revise**: The principle to enforce, output to critique?
**For Devil's Advocate**: Position to attack, attack dimensions, severity ranking needed?
**For Pre-Mortem**: Project/decision, time horizon, domains to analyze?
**For RCoT**: Question with all conditions, initial answer to verify?
**For RPEF**: Output sample to reverse-engineer, input data if available?
**For Reverse Role**: Intent statement, domain of expertise, interview mode (batch vs. conversational)?

### 4. Apply Framework

Using gathered information:
1. Load appropriate template from `assets/templates/`
2. Map user's information to framework components
3. Fill missing elements with reasonable defaults
4. Structure according to framework format

### 5. Present Improvements

Structure your output in this exact order:

**A. Analysis section** (comes first):
- Framework selected and why
- Changes made and reasoning
- Framework components applied

**B. Usage instructions** (transition block, immediately before the prompt):

> **Your revised prompt is ready.**
> - **New chat**: Copy the prompt below and paste it as your first message in a new conversation.
> - **Same chat**: Tell the assistant: *"Use the revised prompt you just provided as a new instruction and execute it."*

**C. The revised prompt** (comes last, in a fenced code block):
- Present as a clean, flat-text block inside triple backticks
- **No framework section headers** (no "BEFORE:", "BRIDGE:", "CONTEXT:", etc.) — these are scaffolding, not part of the deliverable
- **No indentation** beyond what the prompt itself genuinely requires
- **No markdown formatting** inside the block unless the prompt explicitly needs it (e.g., it asks for tables)
- The user must be able to copy the entire block contents and paste it verbatim with zero editing
- **Nothing after the code block** — the revised prompt must be the absolute last element in the response. No trailing suggestions, tips, or follow-up text after the closing backticks.

### 6. Iterate

- Confirm improvements align with intent
- Refine based on feedback
- Switch or combine frameworks if needed
- Continue until satisfactory

## Framework References

Detailed framework docs in `references/frameworks/`:
- `co-star.md` - Context, Objective, Style, Tone, Audience, Response
- `risen.md` - Role, Instructions, Steps, End goal, Narrowing
- `rise.md` - **Dual variant support**: RISE-IE (Input-Expectation) & RISE-IX (Instructions-Examples)
- `tidd-ec.md` - Task type, Instructions, Do, Don't, Examples, Context
- `ctf.md` - Context, Task, Format
- `rtf.md` - Role, Task, Format
- `ape.md` - Action, Purpose, Expectation (ultra-minimal)
- `bab.md` - Before, After, Bridge (transformation/rewrite tasks)
- `race.md` - Role, Action, Context, Expectation (medium complexity)
- `crispe.md` - Capacity+Role, Insight, Instructions, Personality, Experiment
- `broke.md` - Background, Role, Objective, Key Results, Evolve
- `care.md` - Context, Ask, Rules, Examples (constraint-driven)
- `tree-of-thought.md` - Branching exploration of multiple solution paths
- `react.md` - Reasoning + Acting (agentic tool-use cycles)
- `skeleton-of-thought.md` - Skeleton-first then expand (parallel generation)
- `step-back.md` - Abstract to principles first, then answer (Google DeepMind)
- `least-to-most.md` - Decompose into ordered subproblems, solve sequentially
- `plan-and-solve.md` - Zero-shot: plan + extract variables + calculate (PS+)
- `chain-of-thought.md` - Step-by-step reasoning techniques
- `chain-of-density.md` - Iterative refinement through compression
- `self-refine.md` - Generate → Feedback → Refine loop (NeurIPS 2023)
- `cai-critique-revise.md` - Principle-based critique + revision (Anthropic)
- `devils-advocate.md` - Strongest opposing argument generation (ACM IUI 2024)
- `pre-mortem.md` - Assume failure, identify causes + warning signs (Gary Klein)
- `rcot.md` - Reverse Chain-of-Thought: verify by reconstructing the question
- `rpef.md` - Reverse Prompt Engineering: recover prompt from output (EMNLP 2025)
- `reverse-role.md` - AI-Led Interview: AI asks you questions first (FATA)

Load these when applying specific frameworks for detailed component guidance, selection criteria, and examples.

## Templates

Framework templates in `assets/templates/` provide structure:
- `co-star_template.txt` - Full CO-STAR structure
- `risen_template.txt` - Full RISEN structure
- `rise-ie_template.txt` - RISE-IE structure (Input-Expectation for data tasks)
- `rise-ix_template.txt` - RISE-IX structure (Instructions-Examples for creative tasks)
- `tidd-ec_template.txt` - TIDD-EC structure (Task, Instructions, Do, Don't, Examples, Context)
- `ctf_template.txt` - CTF structure (Context-Task-Format for situational prompts)
- `rtf_template.txt` - Full RTF structure
- `ape_template.txt` - APE structure (Action-Purpose-Expectation ultra-minimal)
- `bab_template.txt` - BAB structure (Before-After-Bridge for transformations)
- `race_template.txt` - RACE structure (Role-Action-Context-Expectation)
- `crispe_template.txt` - CRISPE structure (with Experiment/variants)
- `broke_template.txt` - BROKE structure (with Key Results + Evolve)
- `care_template.txt` - CARE structure (with Rules + Examples)
- `tree-of-thought_template.txt` - Tree of Thought branching exploration structure
- `react_template.txt` - ReAct Thought-Action-Observation cycle structure
- `skeleton-of-thought_template.txt` - Skeleton + expand structure
- `step-back_template.txt` - Step-back question + principle application
- `least-to-most_template.txt` - Decompose + sequential solving
- `plan-and-solve_template.txt` - PS+ trigger phrase structure
- `chain-of-thought_template.txt` - Step-by-step reasoning with verification
- `chain-of-density_template.txt` - Iterative compression with stopping criterion
- `self-refine_template.txt` - Generate → Feedback → Refine structure
- `cai-critique-revise_template.txt` - Principle → Critique → Revision structure
- `devils-advocate_template.txt` - Position attack with severity ranking
- `pre-mortem_template.txt` - Failure assumption + cause analysis
- `rcot_template.txt` - 4-step backward verification structure
- `rpef_template.txt` - Output analysis + recovered prompt template
- `reverse-role_template.txt` - Intent + interview trigger structure
- `hybrid_template.txt` - Combined framework approach

## Key Principles

1. **Ask Before Assuming** - Don't guess intent; clarify ambiguities
2. **Explain Reasoning** - Why this framework? Why these changes?
3. **Show Your Work** - Display analysis, show framework mapping
4. **Be Iterative** - Start with analysis, refine progressively
5. **Respect User Choices** - Adapt if user prefers different framework

## When NOT to Use Frameworks

Frameworks add structure — but structure has overhead. Skip them when:

- **The prompt is already complete**: Clear goal, full context, defined format → just execute it.
- **Purely factual lookups**: "What is the capital of France?" — no framework needed.
- **Conversational exchanges**: Back-and-forth dialogue doesn't need a structured template.
- **Very short one-off tasks**: "Translate this sentence to Spanish." APE would be overhead; just translate.
- **User is in a hurry**: If someone explicitly says "just do it", don't pause for framework selection — deliver, then offer to structure if they want more.
- **The task is fully specced by context**: When the codebase, existing docs, or prior messages already contain everything needed.

**Rule of thumb**: Apply a framework when there's a gap between what the user *asked for* and what they *need*. If there's no gap, there's no job for a framework.

---

## Example Interaction

This example shows the full intent-based flow — detecting intent, using the discriminating table, selecting a framework, asking questions, and delivering a structured result.

**User**: "Rewrite this job posting — it's too formal and isn't getting applicants."

**Assistant**: I'll analyze this and identify the best approach.

**Intent detected**: TRANSFORM — improving existing content.

**Discriminating question**: Is this iterative quality improvement, or a one-shot before-to-after rewrite?
→ One-shot rewrite with a clear current state → **BAB** (Before, After, Bridge)

**Questions**:
1. What's the role and target audience? (who should this attract?)
2. What does "too formal" mean specifically? (stiff language, corporate jargon, passive voice?)
3. What tone should the new version have? (casual-professional, startup-energy, warm?)
4. Any constraints to preserve? (job requirements, company name, legal language?)
5. How much can change? (light edits vs. full rewrite?)

**User**: "Software engineer, early-career devs. Too much corporate-speak. Want it to sound like real humans work there. Requirements must stay. Full rewrite OK."

**Analysis (BAB framework applied)**:
1. Locked the current state so the AI understands the starting point
2. Defined the target state in terms the AI can evaluate against
3. Made transformation rules explicit and prioritized
4. Protected non-negotiable elements (requirements) from being changed
5. Gave a concrete length/tone constraint to prevent over-engineering

> **Your revised prompt is ready.**
> - **New chat**: Copy the prompt below and paste it as your first message in a new conversation.
> - **Same chat**: Tell the assistant: *"Use the revised prompt you just provided as a new instruction and execute it."*

```
Rewrite the following job posting. The current version suffers from corporate-speak, passive voice, overly formal tone, and generic language that doesn't reflect actual team culture.

[Paste the current job posting here]

The rewritten version should sound like it was written by engineers, for engineers. Early-career developers should read it and think "I want to work there." It should feel honest, direct, and human — not like legal boilerplate.

Follow these rules:
- Replace all passive constructions with active voice.
- Convert corporate jargon to plain English (e.g., "leverage" → "use").
- Add one specific, concrete detail about the team or culture per section.
- Keep all technical requirements and must-haves verbatim — do not change these.
- Target reading level: conversational, not academic.
- Length: same or shorter than the original. Cut fluff, don't add it.
```

---

## Usage Notes

- Always start by analyzing the original prompt
- Recommend framework(s) with reasoning
- Ask clarifying questions progressively (don't overwhelm)
- Apply framework systematically using templates
- Present improvements with explanation
- Iterate based on feedback
- Load framework references only when needed for detailed guidance

Comments 0

Latest | Hot

Please login before commenting.

Loading comments...

prompt-architect

Directory Structure

SKILL.md

Report

Notice