DOCSEARCHbyAlgolia
Submit Docs

Prompt Architect

repository·main·Indexed 42 days ago

https://github.com/ckelsoe/prompt-architect

An Agent Skill for analyzing and improving prompts using 31 specialized frameworks across 7 intent categories. It transforms vague prompts into structured, expert-level instructions through intelligent analysis of clarity, specificity, context, completeness, and structure. Compatible with Claude Code, Gemini CLI, Cursor, GitHub Copilot, and other Agent Skills standard tools (v3.5.1).

Tokens
74.9K
Snippets
88
Records
226
Agent score
52%

What's inside Prompt Architect

  1. Overview of Prompt Architect features

    main

    Prompt Architect is an Agent Skills compatible tool designed to transform vague prompts into structured, expert-level prompts. It uses a systematic process involving:

    • Intelligent Analysis: Evaluates prompts across five dimensions: Clarity, Specificity, Context, Completeness, and Structure.
    • Framework Recommendation: Suggests specific frameworks based on your use case.
    • Guided Dialogue: Uses progressive disclosure by asking 3-5 targeted clarifying questions to gather missing information.
    • Systematic Application: Applies the chosen framework to transform the prompt.
    • Iterative Refinement: Provides before/after comparisons and refines the prompt based on your feedback.

  2. What is the RACE framework?

    main

    RACE (Role, Action, Context, Expectation) is a medium-complexity prompting framework designed to balance simplicity and richness. It is an improvement over the RTF (Role, Task, Format) framework by adding situational context and an explicit expectation of success.

    It is ideal when you need to provide expertise framing, task clarity, and background information without the full overhead of more complex frameworks like CO-STAR.

    Note: RACE is a community convention and should not be confused with the RACE digital-marketing planning model.

  3. What is the Tree of Thought (ToT) Framework?

    main

    The Tree of Thought (ToT) framework is a prompting strategy that extends Chain of Thought by enabling branching exploration. Instead of following a single linear reasoning path, ToT explicitly explores multiple solution branches, evaluates them against specific criteria, and selects the best path forward.

    Note on Implementation: Unlike the academic research version of ToT which uses multi-call search algorithms (BFS/DFS, state evaluators, etc.), this framework is a single-call structured comparison. It uses a closed set of pre-supplied alternatives (branches) provided by the user, which the model then analyzes and compares. It is best used for problems where the correct approach is unknown and multiple strategies must be considered simultaneously.

  4. What is the Chain of Thought (CoT) Framework?

    main
    Chain of Thought (CoT) is a prompting technique that encourages step-by-step reasoning to make the thinking process explicit. Instead of jumping directly to an answer, CoT guides the model to break down complex problems, show intermediate steps, and verify logic progressively. This technique is particularly effective for mathematical problem-solving, logical reasoning, debugging, and complex multi-step analysis.

  5. What is the TIDD-EC Framework?

    main
    TIDD-EC is a precision-focused prompt engineering framework designed to provide clear boundaries and actionable guidance through explicit "Dos and Don'ts." It is particularly effective for tasks requiring high specificity, detailed instructions, and strict constraints. The framework's primary strength is using explicit positive (Do) and negative (Don't) guidance to prevent common LLM errors and misinterpretations.

  6. What is the CARE Framework?

    main

    The CARE framework (Context, Ask, Rules, Examples) is a prompting method designed by the Nielsen Norman Group. It is specifically optimized for tasks where constraints, guardrails, or quality standards must be strictly enforced.

    Unlike simpler patterns, CARE introduces an explicit Rules component to address what the AI should and should not do, which reduces the need for post-hoc corrections.

    Key characteristic: Section headers (CONTEXT, ASK, RULES, EXAMPLES) are stripped during emission. Therefore, the meaning of each section must be carried by the prose within it. For example, rules must be complete clauses, and examples must be labeled in prose (e.g., "Good:" or "Bad:") so they remain understandable as a flat block of text.

  7. What is the BROKE Framework?

    main

    The BROKE framework (Background, Role, Objective, Key Results, Evolve) is a business-oriented prompting strategy designed to combine measurable business outcomes (OKR-style) with a built-in self-improvement loop.

    Its core strength is the Evolve step, which instructs the AI to critique its own output and suggest three ways to improve it, enabling a structured iteration cycle without manual re-prompting.

    In this specific implementation of the framework, the concept of 'Key Results' is split into two distinct parts to ensure both business impact and response structure are clearly defined:

    1. Output Format: Specifies the shape, length, and depth of the response.
    2. Key Results: Specifies the measurable business metrics the output is intended to influence.

  8. What is Reverse Role Prompting (AI-Led Interview)?

    main

    Reverse Role Prompting flips the traditional prompting dynamic. Instead of you providing a detailed prompt, you provide a minimal Intent Statement and instruct the AI to interview you. The AI asks targeted clarifying questions until it has sufficient information to execute the task.

    This framework is based on the FATA (First Ask Then Answer) research, which can show significant improvements over standard prompting by allowing the AI to surface considerations you may have missed.

    When to use it:

    • When requirements are fuzzy or complex.
    • When you are a non-expert in the domain.
    • When you want the AI to generate a high-quality, structured prompt for you based on the interview results.

  9. What is Chain-of-Verification (CoVe)?

    main

    Chain-of-Verification (CoVe) is a verification framework designed to reduce hallucinations in Large Language Models (LLMs). It works by forcing the model to decompose a draft response into discrete factual claims, generate independent verification questions for those claims, answer those questions without looking at the original draft, and finally regenerate a corrected response based on those independent answers.

    Key Mechanism: The core of CoVe is the independence of the verification step. By answering questions 'cold' (without conditioning on the baseline draft), the model avoids the tendency to simply reaffirm its own previous errors.

    When to use CoVe:

    • Fact-Dense Generation: Biographies, company profiles, or historical summaries where names, dates, or quantities are high-risk.
    • List and Entity Questions: Questions like "Name all X that Y," where each item can be verified individually.
    • Cited or Sourced Summaries: When a summary must strictly match figures and names from a provided source document.
    • Draft Verification: As a secondary layer to check a first-pass factual draft before final output.

  10. What is Least-to-Most (LtM) Prompting?

    main

    Least-to-Most (LtM) prompting is a decomposition-first framework designed for complex, compositional reasoning. It works by breaking a complex problem into an ordered sequence of simpler subproblems, solving them sequentially, and using each prior answer as context for the next.

    Key Differences from Chain of Thought (CoT)

    • Structure: CoT uses single-pass linear reasoning; LtM uses an explicit decompose → solve sequence.
    • Decomposition: CoT decomposition is implicit; LtM decomposition is an explicit first step.
    • Ordering: CoT does not explicitly structure subproblems; LtM sequences them from simplest to most complex.
    • Answer Reuse: CoT may or may not reference prior steps; LtM explicitly feeds each answer into the next.

    When to use LtM

    • Compositional Reasoning: Multi-hop questions where the answer depends on intermediate results.
    • Complex Technical Problems: Architecture decisions or implementation planning with dependencies.
    • Multi-Domain Questions: Problems spanning multiple fields (e.g., legal + technical).
    • Long Calculation Chains: Financial or physics problems where intermediate errors cascade.
    • When CoT Fails: If standard Chain of Thought provides shallow or incorrect answers, LtM's explicit decomposition can reduce error propagation.

  11. What is the Skeleton of Thought (SoT) framework?

    main

    Skeleton of Thought (SoT) is a two-phase prompting framework designed to improve output quality and reduce latency. It works by first generating a concise structural outline (the "skeleton") and then expanding each point into full content.

    Key Benefits:

    • Improved Structure: Forces the LLM to commit to an upfront organization.
    • Parallelization: Because each skeleton point is independent, they can be expanded using parallel API calls to significantly reduce total latency.

    When to use SoT:

    • Use it for structured explanations (technical docs, tutorials), long-form reports, or when you need to validate the structure before generating the full response.
    • Avoid SoT for tasks requiring continuous linear reasoning (use Chain of Thought), mathematical proofs, or narrative stories where sections depend on one another.

  12. What is the ReAct Framework?

    main

    ReAct (Reasoning + Acting) is an agentic prompting framework that interleaves reasoning steps with concrete actions. Instead of a single reasoning pass, the model alternates between three states in a loop:

    1. Thought: Reasoning about the current state and determining the next step.
    2. Action: Executing a specific, concrete action using an available tool.
    3. Observation: The actual result returned by the tool (provided by the environment, not the model).

    When to use ReAct: Use this framework when a task requires tool usage, querying external sources, executing code, or navigating multi-step processes where each step's result informs the next.

    Critical Requirement: ReAct is a protocol specification, not an implementation. For ReAct to function, the environment where the prompt is used must provide a live tool backend (to execute Actions) and a controller to feed the Observation back into the loop. Without live tools, the cycle degrades to mere formatted reasoning.