The oldest premise about language is also the newest: words can do work in the world, not just describe it.
The ancient premise: words that do work
Magick, in its plainest definition, is the art of causing change through will, words, and symbols. In Hermetic and Kabbalistic lines of thought, language is not a passive label. Words summon, bind, and transform. A spoken name situates a thing. A sign seals intent. A phrase, repeated with care, sets the mind and the moment in motion.
This is not about spectacle. It is about operative language—words as instruments. Rituals formalize this: a structure, a sequence, a syntax that channels attention and action. The point is not belief for its own sake. The point is directed change.
When we move from candles and chalk to keyboards and screens, the premise does not vanish. It travels. If language can do work in a symbolic field, it can do work in a computational one.
The machine that listens
Large language models do not think as people do. They compute patterns from vast text, then generate likely continuations. Under the hood, it is statistics and scale. That does not make the surface trivial. It makes the surface responsive in a new way.
A prompt is a structured input. It sets context, direction, and constraints. The model responds within that frame, drawing from patterns it has learned. In practice, this feels like speaking to a very literal collaborator who reacts faithfully to framing, detail, and sequence.
Code was the first obvious language of machines—formal, strict, unforgiving. Prompts broaden the channel.
They allow plain language to guide complex operations without formal syntax. That does not erase computation; it routes it through words. The effect is simple to witness: change appears on screen because language directed it.
The prompt as incantation
If we treat a prompt as an incantation, the metaphor clarifies more than it obscures—provided we keep our footing.
- Intent: What change are you trying to cause? Name the outcome plainly.
- Structure: What sequence will get there? Provide context, steps, and roles.
- Constraint: What must the response include or avoid? State boundaries.
- Token: What carries continuity? Use consistent terms to bind the thread.
Anatomy of a working prompt might look like this:
- Setup: “You are assisting with a research summary for a non-technical audience.”
- Objective: “Produce a clear, three-section brief on X.”
- Inputs: “Base it only on these bullet points.”
- Rules: “Avoid jargon. Use short sentences. Provide a one-paragraph conclusion.”
- Check: “If any claim is uncertain, mark it (UNVERIFIED).”
Each line does what old rites did: it invokes a role, sets a field, binds scope, and names a test. The words do work because the system reacts to them. The change is local and visible—a file generated, an outline produced, a summary drafted. The ritual is linguistic, the mechanism computational.
Where the metaphor breaks
The magick framing is helpful until it hides what matters.
- The power is mostly in the model, not the user. A clever prompt cannot conjure knowledge that is not represented in the system. It can only steer what is already latent.
- The model is bounded by its training and design. Biases, gaps, and deterministic elements persist. A clean incantation cannot bypass those constraints.
- Symbolic resonance in historical systems aimed at effects beyond material mechanism. Here, the effects are grounded in silicon and statistics. The model does not “believe” or “intend.” It estimates and outputs.
- Overuse of the metaphor can blur accountability. A spell gone wrong in a story is the spell's fault. Here, misdirection is on us: unclear prompts, poor guardrails, or ignoring known limits.
Keeping both views in sight—the ritual surface and the computational depth—protects clarity.
We can honor the felt experience of steering with words while soberly accepting what the system is and is not.
Working notes for responsible practice
Treat language as an instrument. Play it with care. A few field rules help:
1) State the change, then shape the words
- Begin with the outcome: “What should exist after this?” Write the prompt to cause that change, not to sound elegant. Plain beats ornate.
2) Structure beats flair
- Use roles, steps, and constraints. Name verification: “If unsure, mark (UNVERIFIED).” Invite the model to show its working if that helps you check it.
3) Bind context deliberately
- Carry critical terms across turns. Reuse exact labels for data, sections, or decisions. Consistency acts as a verbal seal that holds the thread together.
4) Test the edge
- Before trusting an output, try a variant prompt that asks for sources, counterpoints, or failure modes. If the story buckles, so will any decision built on it.
5) Separate ritual from result
- The ritual is the prompt. The result is the output. Do not confuse a well-phrased request with a trustworthy answer. Validate with external checks when stakes are high.
6) Name the ethics upfront
- If an instruction could cause harm, do not dress it as craft. Decline it. If a request may amplify bias, redesign it. Agency sits with the user long before words hit the model.
7) Keep a small ledger of prompts
- Save versions that worked, with notes on why. Treat it like any craft: patterns emerge when you track them. Edit the spells; do not mythologize them.
8) Use the metaphor, don't let it use you
- The spell idea unlocks intuition about framing and sequence. Good. When in doubt, drop the poetry and describe exactly what you need. The model responds to clarity, not mystique.
What this changes—and what it doesn't
The boundary between ritual language and functional code is thinner than it once felt. Prompts let ordinary words direct complex systems. That can be read as a return to an old understanding: language, when structured, does work.
What does not change is the need for responsibility and method. A prompt can steer; it cannot grant omniscience. A sentence can bind scope; it cannot erase bias. A clean ritual does not replace judgment.
The practical takeaway is modest and powerful: write like someone whose words cause effects. Declare intent, choose structure, name checks, and accept limits. In that posture, the metaphor becomes a tool rather than a mask.
To translate this into action, here's a prompt you can run with an AI assistant or in your own journal.
Try this…
Before writing your next prompt, state the exact outcome you want in one sentence, then structure your request with clear roles, constraints, and verification steps.
