Prompting delimiters and JSON style prompting

I notice he uses the json style of prompting.

I see the typical json style of prompt building all the time with other people’s prompts.

I don’t bother. I think that defeats the purpose of a natural language interaction but I do understand the value of delimiting marks so I often use something like this:

Prompt:
{
prompt is inside this, or content or whatever I want delimited.
}

I use brackets because they’re uncommon in plain text, but if they are used in mine, I will often just switch to something else, like:

---
prompt is between these, or content or whatever I want delimited.
---

or

[] or ||

just something to delimit.

Am I right that it really doesn’t matter as long as it’s clear?

Well, my biggest thing is that it’s so much easier to type something like:

here's my stuff I want you to fix (or rewrite or whatever the real task is):

{ my stuff }

than to write

<instructions>
fix my stuff
</instructions>
<content>
my stuff
</content>

that was a so hard to type lol. it really did prove my point to myself anyway!!!

---

You are absolutely right—and your fingers just gave you the most honest feedback possible.

The “JSON-heavy” or “XML-tag” obsession in the AI prompting community often stems from a misunderstanding of how LLMs actually work. People see code-like structures and assume they are speaking the AI’s “native language,” but modern LLMs are trained primarily on natural language.

Here is the breakdown of why your “Low-Friction” approach is actually more efficient:

1. The “Vibe” of the Delimiter

LLMs don’t need formal syntax (like <tag></tag>) to understand boundaries. They just need pattern disruption.

• Symbols like { }, [ ], ---, or ### create a visual and mathematical break in the token stream.
• When the AI sees a sudden shift from prose to a bracket, it “pays attention” to the transition.
• As long as you are consistent within a single prompt, the AI will grasp the hierarchy perfectly.

2. The Efficiency vs. Rigidity Trade-off

There are only two real reasons to use the “hard-to-type” XML style the [person I’m not going to call out so consider this a redaction] uses:

• Massive Contexts: If you are pasting 20,000 words of a story dossier, <STORY> tags help the AI “remember” where the story ends and the instructions begin if they get buried.
• API/Automation: If you are writing a script (like your Sequential Directory Worker) to parse the AI’s output, tags make it easier for the code to find the data, not the AI.

3. The “Discovery Writer” Advantage

For your workflow—high-intensity bursts and impulsive project hopping—formal JSON is a productivity killer.

• Cognitive Load: Every time you stop to type <instruction>, you are shifting from “Creative/Story Mode” to “Coder Mode.” That transition creates friction.
• Natural Language Logic: If you say, “Rewrite this: {text}”, the LLM understands the intent instantly. Adding tags is just adding “token noise” that you have to pay for (both in time and context window).

Summary Table: Delimiter Styles

Style	Friction Level	Best Use Case
Natural ({ }, ---)	Low	Quick drafts, brainstorming, manual prompting.
Markdown (#, *)	Low	Organizing notes in Obsidian or Notepad++.
XML/JSON (<tag>)	High	Complex automation, multi-part prompts, API calls.

The “Higher Level” View

The goal of a delimiter is isolation. You want to prevent “Instruction Leakage”—where the AI thinks your story text is actually a command. Using { } or --- achieves 99% of that isolation with 1% of the typing effort.

If the AI ever gets confused, you don’t need to switch to JSON; you usually just need a clearer header like “CONTENT TO FIX:” followed by your brackets.