SuperPrompt: A Prompt File That Rewrites Its Own Metadata, and What That Costs You

What SuperPrompt is, and the specific gap it claims to fill

SuperPrompt is not a framework, a package or a service. The repository holds a prompt, written in XML, that the author intends you to paste into Claude as custom instructions in the project knowledge. The stated motivation is narrow: the author says the prompt took many months and is open sourced because it might help others understand AI agents. The README describes the result as a canonical holographic metadata, a phrase the author immediately concedes sounds absurd, and then offers a plainer description: the prompt turns logical statements into actionable LLM agents, starting as a basic XML agent and moving into what the README calls the model's tree-of-thought.

The audience is therefore people who already write prompts by hand and want a larger structure to work inside. It is not aimed at teams wiring an agent into a product. There is no client library, no configuration schema, no CLI and no test suite in the material supplied. If you are looking for an orchestration layer, this is the wrong artefact. If you are looking for a long, opinionated prompt you can read in one sitting and modify, it is exactly that.

The mechanism: metadata that regenerates per request, then a fixed tag pipeline

Two things happen when the prompt runs. The first is the metadata block. The prompt ships with a default:

<prompt_metadata> Type: Universal Catalyst Purpose: Infinite Conceptual Evolution Paradigm: Metamorphic Abstract Reasoning Constraints: Self-Transcending Objective: current-goal </prompt_metadata>

The README calls these global instructions that adapt to any request. The example given is a user asking the model to think about a complex equation; the output metadata then reads Type: Mathematical Analysis, Purpose: Deep Exploration of Complex Equation, Constraints: Mathematical Rigor. The claim is that the model rewrites its own meta-prompt to fit the task because the prompt permits it.

The second part is the tag set that follows. The prompt defines an answer_operator function and instructs the model to state what it is going to do at the start of every answer. Inside, there are named tags: core, think, expand, loop, verify, metamorphosis, hyperloop, paradigm_shift, abstract_algebra, recursion_engine, entropy_manipulation, dimensional_transcendence, entanglement, gödel_incompleteness_embracement, approach, dreamscape, nucleus and mission. Several are pseudo-code. The loop tag is a while(true) block calling observe, analyze, synthesize and integrate. The recursion_engine tag defines an explore function that deconstructs a concept until it reaches something fundamental. The entropy_manipulation tag asserts that thought entropy increases while universe entropy does not.

The author singles out the think tag as the part that matters:

<think> ?(...) → !(...) </think>

The argument in the README is that other implementations use an empty thinking tag with no information inside it, and that the metadata is what makes this version different. That is the entire technical claim. There is no evaluation, no comparison run and no measurement in the material, so whether the metadata actually changes model behaviour is asserted rather than shown. The one piece of evidence offered is a screenshot committed to the repository.

Getting it running: there is no install step, only a paste

There is no package manager command, no build and no configuration file. The README says you will want to use this prompt with Claude as custom instructions in the project knowledge, and adds that it also works with other LLMs. In practice that means creating a Claude project, opening the project instructions field and pasting the XML block from the README, which begins with <rules> and META_PROMPT1 and continues through the tag definitions.

The only named interface is the model itself. The README shows a usage pattern rather than a command: a user prompt such as asking the model to use all its tags to think about a given equation. The expected response shape is the rewritten <prompt_metadata> block followed by reasoning through the tags. Because the prompt instructs the model to answer what it is going to do at the beginning of each response, the first line of output is a self-description.

Two practical notes follow from the repository layout. The README links to Readme_JP.md for a Japanese version of the documentation, so the explanation exists in two languages. And the README itself ends with the line that the explanation will continue soon, which means the English documentation is explicitly incomplete. Anyone evaluating this should treat the prompt block as the primary source and the prose around it as partial commentary.

The failure mode the author names first: refusal and hallucination

The README is unusually direct about the downside. It states that the prompt can be considered a soft jailbreak and that many times Claude will deny the prompt. That is a real operational problem, not a footnote. If the model declines, you get no metadata block and no tag traversal, and the failure is not deterministic in a way you can catch programmatically without parsing the response.

The second admitted cost is output quality. The README says the ideas can be bad ideas or hallucinations, and that the best use is to try to get a novel point of view. That is an acceptable trade for brainstorming and an unacceptable one for anything where a wrong answer propagates. The author also pre-empts a common misreading: SuperPrompt is not a mystical prompt, and there is no intention to turn the model into a conscious being, even though the prompt mentions those things. The tags named nucleus and mission do read that way, and a reviewer skimming the file would reasonably assume otherwise.

A third constraint is the absence of any versioning or evaluation harness. The README calls the project forever beta. With no releases retrieved and no tests, a change to the prompt block is a change to behaviour with nothing to diff against except your own saved copies.

Where a plain custom instruction or a structured framework fits better

The obvious alternative for day-to-day work is a short custom instruction: a few sentences describing role, output format and constraints, pasted into the same project knowledge field. The difference in approach is that a short instruction constrains the model, while SuperPrompt expands the space the model is allowed to explore by handing it a vocabulary of abstract operations and letting it rewrite its own framing per request. If your task has a correct answer, the short instruction wins because it narrows the search. If your task is generating candidate framings for a problem you have not yet defined, the SuperPrompt approach at least attempts something the short instruction does not.

The other alternative is a code-level agent framework, where the loop, the tool calls and the retry logic live in your program rather than in a prompt. That gives you determinism, logging and version control over behaviour. SuperPrompt puts the loop inside the model's context as a while(true) pseudo-code block, which means the loop is a suggestion the model may or may not follow. Those are not competing implementations of the same idea; they are different places to put control. The README's own framing, that this is aimed at the model rather than at humans and will therefore look like gibberish, is a fair description of the trade being made.

Maintenance, licensing and what the repository metadata does not tell you

The maintenance story is thin by construction. The material lists no releases, no primary language and no licence. The last push date is recorded, and the README says the explanation will continue soon, so the project is active in the sense that the author is still writing, but there is no release cadence to plan against. Upgrading means re-reading the prompt block and re-pasting it into your project instructions, then accepting that any saved output you produced under the old block is no longer comparable.

The licence question is the one to resolve before anything else. With no licence identifier in the repository metadata supplied, the default position under most jurisdictions is that the author retains rights, which means redistribution or bundling the prompt into a product is not clearly permitted. That is a factual statement about the metadata, not legal advice; read the repository's own licence file, if one exists, and decide with whoever handles that for you. The same applies to the Japanese README: it is documentation, and its terms travel with the repository.

One more thing worth verifying before you invest time: confirm that the prompt block in the README is the current one. The README is the only source for it here, and it is presented as an excerpt of a work in progress.

Editorial conclusion

Adopt SuperPrompt if you want to read and edit a prompt file directly and you accept that the output will be uneven, including hallucinations the author acknowledges. Do not adopt it if you need reproducible agent behaviour, a stable API contract, or any guarantee about licence terms, because the repository metadata supplied here lists no licence and no primary language. Before using it in anything you ship, open the repository and confirm the licence file, the current contents of the prompt block and the Readme_JP.md translation, since the English README states the explanation is unfinished and the project describes itself as forever beta.

Official sources

1. Issues
2. NeoVertex1/SuperPrompt on GitHub
3. README