A build-time meta-prompting framework for tool-calling LLM agents. You bring a task; it compiles a prompt — in the right structural shape, its sections ordered as deliberate operators, audited against a checklist, scored honestly, and shipped with a verifier that tells you whether it works.
You are not finding the right keywords. You are designing operators that transform a model's semantic state into the answer you need.
That single reframing is the framework's center of gravity — everything in the procedure follows from it. Prompt Architect is a compiler for prompts, not a runtime orchestrator: it builds the artifact, you run it. It works with any tool-calling runtime (Claude Code, Gemini CLI, the Anthropic and OpenAI APIs, others).
This framework is published honestly. Here is exactly where it stands, by its own evaluation.
| ✓ What's validated | ◻ What's not yet proven in the wild |
|---|---|
| The from-scratch path for one-shot, system-persona, and LLM-as-judge prompts — stress-tested (eleven findings, all patched and confirmed) and exercised on a real external task. | Roughly half the surface — the agent-team shape end-to-end, refactor mode, the verifier infrastructure, and the clarification self-check — sound by design, but not yet run against enough real tasks to call it battle-tested. |
| The architecture is internally consistent: every cross-reference resolves, the shapes compose rather than duplicate, and the framework refuses to ship artifacts that fail its own audit. | Its strongest guarantees are prompt-enforced, not mechanism-enforced — they depend on the executing agent honoring the procedure. |
In short: a good design with real evidence behind its core, and an explicit account of the parts that still need field use. Issues and field reports are genuinely wanted — that's the fastest way the unproven half becomes proven.
The repository is the skill. No dependencies, no build step — it's Markdown the agent reads.
git clone https://github.com/delta4sera/prompt-architect
# Point your agent at the folder, or drop it into your skills directory
# (e.g. ~/.claude/skills/prompt-architect for Claude Code).Then invoke it:
"Help me design a prompt for [task] — use the prompt-architect skill."
| Method | How |
|---|---|
| Skill folder | Point your agentic CLI at this directory. Tools that load skills by folder treat SKILL.md as the entry. |
| Slash command | Register SKILL.md as a custom command (e.g. /prompt-architect). Invoking starts the procedure. |
| Manual | Paste SKILL.md as the opening message of a fresh session. The agent follows the procedure from shape inference onward. |
From-scratch mode (default). You describe a task; the framework returns:
- The prompt itself, in the right shape.
- Paired artifacts when the shape requires them — a memory file for agentic loops, per-stage prompts for workflows, calibration examples for graders, per-role prompts for agent teams.
- A usage instruction tailored to your tool / runtime.
- An honest evaluation scoring token economy, task fit, and operator coherence.
- A verifier specification plus a runnable static-mode verifier; dynamic- and cross-run verifiers when stakes warrant.
Refactor mode. You paste an existing prompt; the framework auto-detects the request and runs one of three sub-modes:
- Audit-only — a diagnostic report with findings, severity, and suggested fixes. No edits.
- Targeted refactor — small, surgical edits for a specific symptom you've named (hallucinations, inconsistent output, format violations).
- Wholesale rewrite — a full redraft with explicit diff and tradeoff analysis. The original is preserved alongside.
The framework infers shape from your request rather than asking, so the interview stays short.
| Shape | For |
|---|---|
| Agentic loop | Long-horizon, multi-checkpoint projects with a memory file and human-in-the-loop coordination. |
| One-shot | Single-call complex tasks — classification, extraction, transformation, generation. |
| Workflow / chain | Multiple coordinated LLM calls with gates between stages. |
| Sub-agent / tool | Prompts consumed by another agent rather than a user. |
| System persona | Ongoing conversational use; persona stability across unknowable inputs. |
| LLM-as-judge | Graders, scorers, evaluation rubrics. |
| Agent team | Multi-agent systems with coordination patterns (orchestrator–workers, parallelization, evaluator–optimizer). |
Domain is orthogonal to shape. Engineering / research / writing / ops / generic modify section content, not which sections appear — shape × domain yields 30 combinations the framework handles uniformly.
The quantum-semantic principles are not metaphor here — they shape concrete design practice, and are adopted only because the source paper's claims carry measurable consequences.
| Principle | In practice |
|---|---|
| Prompts are operators, not key-finding (§5.3) | Design transformations, not keyword searches. |
| Ordering is structural (§5.1, §2.3) | Operators don't commute — Â B̂ ≠ B̂ Â. Strongest framing first. |
| Combination is non-additive (§5.4) | Adjacent sections interfere; check for emergent behavior. |
| Each step is irreversible (§5.6) | Every instruction destroys information — load critical context early. |
| Ambiguity is superposition (§5.2, §1.1) | User-intent ambiguity is a feature to preserve, not a defect to flush. |
| Temperature is a measurement parameter (§5.5) | Design for sampling, not just mode collapse. |
| Meaning is observer-dependent (§1.2) | Same prompt, different model = different result. |
See references/quantum-principles.md for the operational mapping,
and operators/section-operators.md for the section-as-operator
catalog.
Every technique traces to published work — nothing is uncredited.
- Classical context engineering (Anthropic, 2024–2025) — right altitude, smallest viable token set, examples over rules, long-horizon support.
- Quantum semantic framework — Agostino et al., arXiv:2506.10077, applied here as design principles.
The complete source list, with how each was used, is in CITATIONS.md.
prompt-architect/
├── SKILL.md # Main entry point — the procedure
├── README.md # This file
├── CITATIONS.md # Every source, and how each was used
├── DEPLOY.md # Publishing docs/ as a GitHub Pages site
├── templates/
│ ├── shape-catalog.md # Seven shapes with their spines
│ ├── interview-branches.md # Adaptive interview per shape
│ └── minimum-viable-prompt.yaml # Fallback scaffold for small tasks
├── operators/
│ └── section-operators.md # Each section as an operator
├── references/
│ ├── quantum-principles.md # Operational mapping of quantum semantics
│ ├── reasoning-patterns.md # Cognitive-tools and other reasoning sub-patterns
│ ├── agent-consumability.md # Output design for agent-consumed prompts
│ ├── agent-team-topologies.md # Four canonical multi-agent coordination patterns
│ ├── verifier-specification.md # Per-shape verification criteria (3 layers)
│ ├── verifier-agent-patterns.md # Building runnable verifier-agents as Shape 6 prompts
│ ├── refactor-mode.md # Audit / refactor / rewrite procedure
│ ├── audit-checklist.md # Structural + quantum-semantic audit
│ └── evaluation-rubric.md # Honest 3-axis scoring
└── docs/
└── index.html # Guided tour (deployable via GitHub Pages — see DEPLOY.md)
A guided visual tour lives in docs/index.html — deployable as a GitHub Pages
site (see DEPLOY.md).
- Quick one-line questions or simple Q&A.
- Tasks where you want the answer, not a prompt to get the answer later.
- Throwaway exploratory prompts where rigor isn't worth the overhead.
You are not finding the right keywords. You are designing operators that transform a model's semantic state into the answer you need. Section ordering matters. Section combination produces interference. Each instruction destroys information. Ambiguity is a feature. Treat prompt design as the empirical engineering discipline it is, and measure where measurement helps.
