Series on making your healing more effective and reliable. Today: What if the force you channel doesn’t understand your instructions?
When you send out your intent, you’re asking some force outside yourself to act on those instructions. I call those external forces “ethereal software” because, like computer software, they’re programmed to respond to specific commands.
But what happens if you ask for something the software doesn’t know how to do?
If you’ve never thought about that, don’t worry. Most mages don’t. Most mages just send out their intent, in the form of a visualization or a ritual or a servitor, and trust that whatever executes those intents will execute theirs as well. But once you start communicating with ethereal software with words, and receiving its questions / confirmations / errors as words, you’ll realize that there’s a lot more to it than asking for what you want to happen.
Last week, Taylor suggested healing hives by “communicating with [the person's] neurotransmitters directly,” which got me thinking about this post. Now, neurotransmitters are inanimate chemicals, so you can’t communicate with them any more than you could communicate with a glass of milk. But a lot of magick is about symbolically asking for impossible things, so let’s say you visualize chemicals with Pixar smiley faces nodding to your instructions, and leave the details to the healing forces you channel.
Here’s what happens next:
- The visualization tells your unconscious mental muscles about what you want to happen.
- Your mental muscles contact the external force (the “ethereal software”) you use for healing.
- The ethereal software connects to your mind, reads your intent, and acts on those instructions as best it can.
A servitor ought to work basically the same way, though I haven’t used them myself. If anyone has consciously stepped through servitor-based magick, please fill me in on the details.
Steps 1 and 2 are simple enough: A visualization can communicate your intent to your mental muscles (as long as concepts like “neurotransmitters” are familiar enough that you can meaningfully visualize them), and the ethereal software ought to pick up that instruction easily enough.
But what about that final step, where the ethereal software executes the command? The software I use can accelerate or decelerate cellular processes, but not communicate with inanimate chemicals. So what happens when you ask for something it can’t do?
Implementing Unknown Instructions
I see four possibilities for how ethereal software might react to an unknown instruction. Here’s my best guess, from most to least likely:
1. Best Approximation
The ethereal software will probably make its best guess, picking a command it knows that sounds similar to what you want.
In the example, the software would probably pick up your overall intent to heal the hives, along with the specific instruction to communicate with the neurotransmitters. If it doesn’t know what to do with the neurotransmitters, it could still take its best shot at healing the hives.
Which sounds pretty good, until you remember that the software I used didn’t have a “heal the hives” command. It had a “numb the itch” command that didn’t work, and another “numb the itch” command that worked for a week before becoming ineffective. The command that seems to be healing her hives wasn’t a simple phrase, it was a long, seemingly-unrelated instruction: “Increase neurotransmitter reuptake for the nerves you’ve been numbing, for the neurotransmitter that’s been building up, and run this command to completion without requiring involvement from me or Lisa.” (The second half is so the command will run as we sleep). In other words, you’re pretty unlikely to stumble onto that command through luck.
So there’s a good chance that, after discarding “communicate with the neurotransmitters” as an unrecognized instruction, the ethereal software would implement “heal the hives” as one of those less-than-stellar anti-itching commands, giving temporary relief that stops working after a week.
2. Do Nothing
Most of the time, when I give ethereal software an instruction it doesn’t recognize, it tells me that it doesn’t understand me. I then ask for instructions, try new commands, or get help from a spirit, and eventually figure out the right way to ask for what I want.
Even though this is the most common case for me, I put it second because I think most ethereal software only does this if you’re listening for its response.
3. Proper Healing
Now we’re getting into the less likely possibilities. This is basically “Option 1, done right.” We’d discussed this at the end of the healing post: If you’re very lucky, the ethereal software you use has the right programming to execute your general intent, and you don’t have to do any debugging or tweaking to get a good healing. If that’s the case, though, you can skip the whole discussion of neurotransmitters and just ask it to heal the hives.
4. Unexpected Result
Or the ethereal software might do something unexpected, like actually influence the neurotransmitters in the person’s body. Which sounds good, until you realize that the same neurotransmitter that signals itching is also used by other nerves in other parts of the person’s body and brain, meaning that affecting a neurotransmitter would produce unpredictable results. (In many fields of science, “Unpredictable results” is how we say “Bad things happen.”)
Which is why all ethereal software I’ve ever used has safety protocols built in. Because it would be unsafe to use otherwise.
For example, the ethereal software I used for healing the hives has safeguards to (1) ensure that any tissue regrowth it triggers is normal tissue, not scar tissue, and (2) prevent it from influencing chemicals like neurotransmitters without an explicit instruction in words, not just an intent, plus probably lots of other checks I don’t know about yet. That’s why “Unexpected Result” is so low on the list.
As always, it comes back to debugging.
Like anything else, you won’t get a new technique right the first time. I sure don’t. The hives case study is a great example: First try was a failure, second was a success that lasted a week, third try appears to be successful after two weeks, though we continue monitoring it to be sure.
But what happens to that debugging if you just send out your intent? You don’t know which of these scenarios you’ll get. You might even get something I haven’t thought of.
The more you know about how your magick gets implemented, the more you’ll be able to debug it, and produce reliable, effective results. Part of that is listening to the ethereal software’s responses to your commands. (Post on that is in the works). And part of that is using commands the ethereal software knows, so you know what you’re getting.
Other posts in this series:
Note: This will be a series eventually. For now, it’s a one-post series.
- Debugging Your Healing: Using Unknown Commands (This post) (January 5, 2012)