Prompts
System prompts and single-call instructions, drafted as ordered operators and scored before delivery.
Meaning isn’t retrieved.
It’s constructed.
Prometheus is a prompt-engineering skill for coding agents — and more. Describe what you need and it designs a structured, audited prompt, workflow, or self-adaptive agent, shipped with a verifier that proves it works.
also on GitHub
Runs across the agentic ecosystem
What it is
A prompt is an operator, not a key
Most prompt-engineering advice arrives as a bag of tips: add keywords, give examples, be specific. Prometheus rejects that framing at the root.
So — in practice
The operator principle. Treat the prompt as an operator acting on the model’s distribution over interpretations. Each section is a transformation — it amplifies, suppresses, or mixes readings of the task — and because these operators do not commute, order is load-bearing. Compose them deliberately, audit the composition against known failure modes, and the output becomes measurable and reproducible instead of a lucky sample.
Watch each prompt section act as an operator on the task — amplifying some readings, filtering out others, mixing the rest — instead of just stacking strings of text. An operator has a profile — the readings it amplifies, the ones it suppresses, and the ones it mixes. Collapse is set apart: it is the measurement act, where the prompt commits to a single reading.
Operator profile
Amplify
Constructive interference. Amplifies a specific semantic interpretation while preserving superposition.
Learn More PROJECTS the state
Operator profile
Suppress
Destructive interference. Filters out noise and suppresses off-domain interpretations.
Learn MoreŜ FILTERS noise
Operator profile
Mix
Entangles logic. Combines multiple basis states into a novel, hybrid reading.
Learn MoreM̂ ENTANGLES logic
Measurement
Collapse
Measurement. Forces deterministic convergence onto a single, unambiguous interpretation.
Learn MoreB̂ COLLAPSES possibilities
What It Actually Does
Three capabilities, one substrate
The skill exposes three capabilities, one per mode. They share a substrate of reference knowledge but run different procedures.
From-scratch design
Given only a task description, the framework produces a prompt through six ordered phases: it infers which of seven structural skeletons fits, runs an adaptive interview to recover the constraints an operator needs, drafts the prompt as a sequence of named operators, audits that draft against a structural-and-quantum checklist, scores it honestly on three axes, and delivers it with a verifier. The ordering is load-bearing, because operators do not commute.
Refactor an existing prompt
Given a prompt you already have, the framework recovers its intent and then takes one of three sub-modes by risk. Mode A audits only, returning a report with zero edits and near-zero risk. Mode B localizes a named symptom to its operator-level cause and proposes a surgical diff. Mode C rewrites wholesale using the from-scratch drafting machinery, preserving the original and presenting both with an explicit trade-off analysis.
A · audit
B · surgical diff
C · rewrite
Manage an agent over its lifetime
Given a managed-agent package — a directory that is the agent's identity — the framework runs a MAPE-K loop over it. Monitor reconstructs the distribution the current prompt induces from recent runs; Analyze keeps candidate adaptations in weighted superposition and prunes the ones the ledger says already regressed; Plan collapses to a single edit; and Execute applies it at a controlled lifecycle seam, write-ahead-logged and reversible by snapshot. It is a build-time manager that reads run evidence and rewrites prompts.
Monitor
Analyze
Plan
Execute
From-scratch delivery is not a fixed bundle. The pipeline can emit up to eight distinct artifacts, though most runs emit far fewer, and what ships is reported to the author as a scaffold-to-trigger list — the framework is built to justify its own additions rather than pad the delivery.
Create → Manage
An agent, forged and kept alive
As the Titan Prometheus shaped humankind and gave it fire to stay alive, Prometheus forges agents — and hands them the structure that keeps them alive.
Prometheus builds the agent from ordered operators, then stays on as its manager — watching each run and re-forging the agent so it keeps growing.
Born — from ordered operators
Grows — it runs in the world
Learns — from its own runs
An agent’s nature is its text
The idea draws inspiration from homoiconicity — where a program and its data share one form. Not literally so here, but close in spirit: in an agentic runtime, an agent is largely the text that defines it — its system prompt, its task specs, its memory. Prometheus runs the agent, reads what actually happened, and rewrites that text between runs. Every generation is selected for higher fitness — evolution, applied to the agent’s own source.
the agent runs↔Prometheus manages — at the same time
fitness0.62
Prometheus · managingv1
system.md
role: docs-sync agent
tone: concise, factual
task.md
goal: keep API docs in sync
stop: when the PR is opened
memory/state.json
known_quirks: []
runs: 0
Prometheus rewrites ↑
Nothing is retrained. The agent evolves because the artifacts that define it are rewritten — the same text the runtime executes is the text Prometheus edits.
Run
the agent acts on a real task, leaving a trace of how it behaved
Read
between runs it reads that evidence — never judging by a single run
Diagnose
pinpoints the drift and weighs candidate fixes
Re-forge
rewrites the control plane — prompt, tools, knowledge
Always between runs, never driving the agent live: Prometheus owns the control plane; the agent keeps its own persistent memory.
The pipeline
The Fabrication Cycle
From-scratch design compiles a raw task into a delivered prompt, workflow, or agent across six ordered phases. Each phase hands its output to the next; only one edge ever runs backward.
A task enters at Shape, where it is sorted into a structural shape and a strength tier. Those facts flow into the Interview, which recovers the runtime and the definition of done. Draft lays the prompt out as ordered operators, Audit checks that draft, Score rates it honestly, and Deliver ships it with a verifier. The order cannot be shuffled: a later operator’s meaning depends on the reading an earlier one already selected.
01
Shape
infer shape + tier
Samples the raw request to classify it into one of the structural shapes and a strength tier — no routing questions asked. When the reading is clear enough, the framework commits and moves on.
02
Interview
runtime + done-def
A short, capped interview recovers what an operator needs — the runtime it will run on and the definition of done — and closes with a summary the author can correct.
03
Draft
ordered operators
Drafts the prompt as an ordered sequence of operators from the catalog — sections that amplify, suppress, or mix readings. The order is load-bearing: a later operator depends on what an earlier one selected.
04
Audit
structure + measurement
Audits the draft against the framework’s structural and measurement checklists. A failing audit is the pipeline’s one loop back — it returns the draft to drafting for revision.
05
Score
three honest axes
Scores the result honestly on three axes — token economy, task fit, and operator coherence — and confirms no unused scaffolding slipped into the draft.
06
Deliver
prompt + verifier
Delivers the prompt with a verifier specification and, where it applies, a ready-to-run verifier — emitted as plain blocks, changing nothing on disk.
What you get
More than prompts and agents
Prometheus does not just write a prompt and stop. The same operator model compiles into whatever the task actually needs — and it was built from the start to give life to real agents and agentic workflows, not only single-shot instructions.
What you get
Prompts
Generic agents
Evaluators
agentic
agentic
Cognitive-tool scaffolds
For hard multi-step reasoning: a system prompt plus ready-to-register tool definitions you wire into your own tool-calling runtime.
Agents
Full agentic loops — persona, tool contracts, and a memory discipline — designed to run over many turns against real tools, not a one-off reply.
Agentic workflows
Multi-step pipelines and orchestration blueprints — ordered stages, hand-offs, and stop conditions — that wire several prompts into one working system.
Graders & evaluators
LLM-as-judge rubrics with explicit, checkable criteria — the shape Prometheus reaches for when the task is to score, not to generate.
Verifiers
Every deliverable ships with a verifier spec across three layers, so you can prove the artifact does what it claims.
Grounded in the research
Get started
Drop it in. It routes itself.
No build step, no dependencies. Place the skill folder on your agent’s search path and Prometheus auto-triggers the moment you describe a prompt-design task.
bash
# drop the skill onto the search path
cp -a prompt-architect ~/.claude/skills/
# then just describe the prompt you need
> design a prompt for a support agent
No build step
No dependencies
Auto-triggers on intent
MIT-licensed
also on GitHub