NLP Is Back. Now Its Victims Are Neural Networks

After more than twenty years in marketing and sales, I've learned one thing above all: the product doesn't close the deal. What closes it is the word, the tone, the pause, the ability to step into someone else's shoes for a moment and feel what they're actually afraid of. Nobody teaches you this in any classroom. You pick up the skill at the negotiating table, trying over and over until the formula starts to click.

Today I watch prompt engineers talking to language models, and I recognize my own experience. The setting is different, but the method is the same: feel your way toward phrases that work, and don't ask why. Almost nobody remembers the ancestor of this approach, the one that two people in California invented half a century ago.

The people who came up with NLP (Neuro-Linguistic Programming) had no psychotherapy degrees. They relied on their own instinct for language, and now their product is everywhere.

The method crept into business long ago, dissolving into basic techniques: asking open-ended questions, mirroring the client's own words back to them, and pausing to make the other person finish your sentence for you. In the corporate world, people avoid saying the letters "NLP" out loud — it carries too much baggage. The technique itself is invisibly present in every successful deal, though. For any skilled negotiator, it's become as natural as breathing.

The Technique Nobody Names Out Loud

In the early seventies, psychology student Richard Bandler was picking up extra money transcribing audio recordings for a publishing house. When listening to tapes of sessions with the late Gestalt therapist Fritz Perls, he noticed a pattern: certain verbal constructions instantly shifted the state of the patients, others didn't. Bandler shared his discovery with John Grinder, a young linguistics professor, and the two of them found the same pattern in the work of family therapist Virginia Satir.

Bandler and Grinder weren't interested in deep causes, only in pure engineering: how to build phrases that work. In 1975, they published The Structure of Magic: A Book About Language and Therapy and named their first tool the metamodel.

The metamodel turned out to be less a therapy than a fine-tuning of language. It's a system of skeleton-key questions that pry open what a person leaves unsaid.

A client complains: "Nobody understands me."

The metamodel presses back: "Nobody? No one at all?" It forcibly returns the person to specifics.

Later came the addition of the "Milton model," the deliberately vague language of psychiatrist and hypnotherapist Milton Erickson, founder of the American Society of Clinical Hypnosis. Academic science rejected these discoveries — they had no evidence base and nobody could explain why any of them worked — but the craft survived without the science. It became a set of applied tools focused anchoring and reframing, with visual, auditory, and kinesthetic elements.

What Makes a Phrase Work

Half a century later, a new crowd talking to AI systems is applying the metamodel. They're generally not physicists or linguists, but managers, engineers, and editors — people who noticed the patterns and learned how to squeeze value out of them. Like the pioneers of NLP, they don't ask why the model answers one way and not another. They're solving a purely applied problem: how to make the system produce the result they want. Asking "why" isn't necessary; all that matters is "it worked" or "it didn't."

Take "presupposition" from the NLP toolkit. The question is built to rule out the unwanted answer in advance. You don't ask "Do you want to change?" but "What will happen once you change this belief?" Agreement is already baked into the grammar, so the other person ends up arguing not with the idea but with the shape of the sentence itself.

Prompt engineers have a kindred technique: few-shot prompting (more on this in "The Illusion of the Complex Prompt"). Where NLP sidesteps argument by building the desired thought into the structure of the question, few-shot prompting sidesteps direct instructions by building the rule into examples. In both cases, what does the work isn't a direct instruction but a given form that steers the answer down the right channel.

Another example is the "Milton model" and its deliberately vague language, like "and as you read these lines, you may notice something inside beginning to shift." The phrase is so general that everyone finds something of their own in it, and so confident that nobody wants to argue.

For prompt engineers, the role frame plays a similar part. "You are an experienced editor with twenty years in the business," doesn't give the model a single fact or hand it a rigid algorithm, but it narrows the semantic field. Just as Milton Erickson's trance switches a patient's state while bypassing logic, a role frame switches the weights of words inside a neural network, setting the tone and boundaries of the answer without a single direct command.

The most celebrated discovery shared by both fields is the trigger phrase. In NLP, it's anchoring: one word or touch instantly snaps a person back into a given state. In prompting, it's the phrase "let's think step by step." Mathematically, this forces the model to generate intermediate tokens, recalculating probabilities along the way. To the user, it looks like a pure anchor: five simple words suddenly flip the neural network into a different mode and change the quality of its answer. The user doesn't need to understand the math behind that miracle at all.

"Generating a chain of thought — a series of intermediate reasoning steps — significantly improves the ability of large language models to perform complex reasoning."

— Wei et al., "Chain-of-Thought Prompting Elicits Reasoning in Large Language Models", NeurIPS 2022

Both crafts were born of the same drive to crack open an enigmatic system. The human psyche is a black box, and not even its owner holds the keys. A language model's billions of parameters make it a black box as well, and not even the people who trained it can explain any single answer it gives. The skeleton key to these boxes always comes from a simple observation: say what you want exactly like this, and the lock clicks.

NLP technique	Prompting analog	Shared principle
Presupposition	Few-shot prompting	Form dictates the answer, bypassing objection
Milton model	Role frame	A vague instruction steers the tone
Anchoring	Chain of thought	One phrase switches the mode of operation

The "why" doesn't much matter. It works — that's the only proof this craft ever recognizes.

The Line Between Persuasion and Manipulation, and Why You Can't Check It

Both fields inherited the same shadow, the prospect that control, not care, lies behind every elegant technique. The therapist repainting someone's pain in a different color with presupposition might help them or might slip past their justified resistance to a suggestion, maybe even for personal gain. The salesperson's motive is even more transparent: close the deal fast and collect the commission.

The engineer slips a fake role into the prompt, a fake sense of urgency, a fake "my life depends on this." We're not, of course, harming the machine — an algorithm has no feelings, no psyche to traumatize — but we're imitating hackers, bypassing built-in safeguards and rules to get what we want.

Nobody's drawn a line between honest persuasion and manipulation. Where a programming technique falls depends only on the speaker's intent — the one thing you can't check.

No Explanation. No Warning.

NLP techniques never got scientific backing. Science turned away, but the practice stuck around in sales manuals, or in the way a life coach looks at you over a notepad and waits for you to finish a sentence for them. Bandler and Grinder ran no controlled studies and published no results. They spotted a pattern, one that keeps making money.

Prompt engineering faces the same skepticism today that NLP did in its time. Experts say it's not engineering, it's "interface superstition," and all your coaches will turn into pumpkins the moment a new model drops. Practitioners know this better than any critic: every one of them has watched a reliable trick simply stop working.

So why do we keep coming back to these models? Maybe it's because language is the last territory where a person still believes they can control something bigger and more complex than themselves. Someone else's psyche, say, or a neural network that's read more text than any of us ever will.

We do the exact same thing in both cases: we pick words like skeleton keys, and we try. We try. We try again, until something opens.