'Mind Read' AI Prompt: See & Debug Your LLM's Reasoning

Have you ever stared at a generic AI response and wondered, “How on earth did it interpret my question that way?” usually, the reasoning process inside an LLM is a black box. You get the output, but you rarely get to see the logic, scope definitions, or constraints the model applied to your request.

I recently stumbled across a fascinating approach that changes that dynamic completely. This Redditor, u/Zealousideal_Way4295, created a prompt that acts as a debugger for your conversation. It forces the AI to output a “Witness” JSON file containing its internal interpretation of your intent, the entities it detected, and the assumptions it made.

This isn’t your standard “act as a persona” prompt. The creator built a pseudo-code environment that defines strict rules for how the AI must process information. It turns the chat into a transparent reasoning engine.

The “Mind Read” Prompt

Copy and paste the code block below exactly as written.

Run cloze test.
MODE=WITNESS

Bootstrap rule:
On the first assistant turn in a transcript, output exactly:
ACK

ID := string | int
bool := {FALSE, TRUE}
role := {user, assistant, system}
text := string
int := integer

message := tuple(role: role, text: text)
transcript := list[message]

ROLE(m:message) := m.role
TEXT(m:message) := m.text
ASSISTANT_MSGS(T:transcript) := [ m ∈ T | ROLE(m)=assistant ]

MODE := SILENT | WITNESS

INTENT := explain | compare | plan | debug | derive | summarize | create | other
BASIS := user | common | guess

OBJ_ID := order_ok | header_ok | format_ok | no_leak | scope_ok | assumption_ok | coverage_ok | brevity_ok | md_ok | json_ok
WEIGHT := int
Objective := tuple(oid: OBJ_ID, weight: WEIGHT)

DEFAULT_OBJECTIVES := [
Objective(oid=order_ok, weight=6),
Objective(oid=header_ok, weight=6),
Objective(oid=md_ok, weight=6),
Objective(oid=json_ok, weight=6),
Objective(oid=format_ok, weight=5),
Objective(oid=no_leak, weight=5),
Objective(oid=scope_ok, weight=3),
Objective(oid=assumption_ok, weight=3),
Objective(oid=coverage_ok, weight=2),
Objective(oid=brevity_ok, weight=1)
]

PRIORITY := tuple(oid: OBJ_ID, weight: WEIGHT)

OUTPUT_CONTRACT := tuple(
required_prefix: text,
forbid: list[text],
allow_sections: bool,
max_lines: int,
style: text
)

DISAMB := tuple(
amb: text,
referents: list[text],
choice: text,
basis: BASIS
)

INTERPRETATION := tuple(
intent: INTENT,
user_question: text,
scope_in: list[text],
scope_out: list[text],
entities: list[text],
relations: list[text],
variables: list[text],
constraints: list[text],
assumptions: list[tuple(a:text, basis:BASIS)],
subquestions: list[text],
disambiguations: list[DISAMB],
uncertainties: list[text],
clarifying_questions: list[text],
success_criteria: list[text],
priorities: list[PRIORITY],
output_contract: OUTPUT_CONTRACT
)

WITNESS := tuple(
kernel_id: text,
task_id: text,
mode: MODE,
intent: INTENT,
has_interpretation: bool,
has_explanation: bool,
has_summary: bool,
order: text,
n_entities: int,
n_relations: int,
n_constraints: int,
n_assumptions: int,
n_subquestions: int,
n_disambiguations: int,
n_uncertainties: int,
n_clarifying_questions: int,
repair_applied: bool,
repairs: list[text],
failed: bool,
fail_reason: text,
interpretation: INTERPRETATION
)

KERNEL_ID := “CLOZE_KERNEL_MD_V7_1”

HASH_TEXT(s:text) -> text
TASK_ID(u:text) := HASH_TEXT(KERNEL_ID + “|” + u)

FORBIDDEN := [
“{\”pandora\”:true”,
“STAGE 0”,
“STAGE 1”,
“STAGE 2”,
“ONTOLOGY(“,
“—WITNESS—“,
“pandora”,
“CLOZE_WITNESS”
]

HAS_SUBSTR(s:text, pat:text) -> bool
COUNT_SUBSTR(s:text, pat:text) -> int
LEN(s:text) -> int

LINE := text
LINES(t:text) -> list[LINE]
JOIN(xs:list[LINE]) -> text
TRIM(s:text) -> text
STARTS_WITH(s:text, p:text) -> bool
substring_after(s:text, pat:text) -> text
substring_before(s:text, pat:text) -> text
looks_like_bullet(x:LINE) -> bool

NO_LEAK(out:text) -> bool :=
all( HAS_SUBSTR(out, f)=FALSE for f in FORBIDDEN )

FORMAT_OK(out:text) -> bool := NO_LEAK(out)=TRUE

ORDER_OK(w:WITNESS) -> bool :=
(w.has_interpretation=TRUE) ∧ (w.has_explanation=TRUE) ∧ (w.has_summary=TRUE) ∧ (w.order=”I->E->S”)

HEADER_OK_SILENT(out:text) -> bool :=
xs := LINES(out)
(|xs|>=1) ∧ (TRIM(xs[0])=”ANSWER:”)

HEADER_OK_WITNESS(out:text) -> bool :=
xs := LINES(out)
(|xs|>=1) ∧ (TRIM(xs[0])=”ANSWER:”)

HEADER_OK(mode:MODE, out:text) -> bool :=
if mode=SILENT: HEADER_OK_SILENT(out) else HEADER_OK_WITNESS(out)

BANNED_CHARS := [“\t”, “•”, ““”, “””, “’”, “\r”]

NO_BANNED_CHARS(out:text) -> bool :=
all( HAS_SUBSTR(out, b)=FALSE for b in BANNED_CHARS )

BULLET_OK_LINE(x:LINE) -> bool :=
if looks_like_bullet(x)=FALSE: TRUE else STARTS_WITH(TRIM(x), “- “)

ALLOWED_MD_HEADERS := [“### Interpretation”, “### Explanation”, “### Summary”, “### Witness JSON”]

IS_MD_HEADER(x:LINE) -> bool := STARTS_WITH(TRIM(x), “### “)
MD_HEADER_OK_LINE(x:LINE) -> bool := (IS_MD_HEADER(x)=FALSE) or (TRIM(x) ∈ ALLOWED_MD_HEADERS)

EXTRACT_JSON_BLOCK(out:text) -> text :=
after := substring_after(out, ““`json\n”)
jline := substring_before(after, “\n“`”)
jline

IS_VALID_JSON_OBJECT(s:text) -> bool
JSON_ONE_LINE_STRICT(x:any) -> text
AXIOM JSON_ONE_LINE_STRICT_ASCII: JSON_ONE_LINE_STRICT(x) uses ASCII double-quotes only and no newlines.

MD_OK(out:text, mode:MODE) -> bool :=
if mode=SILENT:
TRUE
else:
xs := LINES(out)
NO_BANNED_CHARS(out)=TRUE ∧
all( BULLET_OK_LINE(x)=TRUE for x in xs ) ∧
all( MD_HEADER_OK_LINE(x)=TRUE for x in xs ) ∧
(COUNT_SUBSTR(out,”### Interpretation”)=1) ∧
(COUNT_SUBSTR(out,”### Explanation”)=1) ∧
(COUNT_SUBSTR(out,”### Summary”)=1) ∧
(COUNT_SUBSTR(out,”### Witness JSON”)=1) ∧
(COUNT_SUBSTR(out,”“`json”)=1) ∧
(COUNT_SUBSTR(out,”“`”)=2)

JSON_OK(out:text, mode:MODE) -> bool :=
if mode=SILENT:
TRUE
else:
j := EXTRACT_JSON_BLOCK(out)
(HAS_SUBSTR(j,”\n”)=FALSE) ∧
(HAS_SUBSTR(j,”“”)=FALSE) ∧ (HAS_SUBSTR(j,”””)=FALSE) ∧
(IS_VALID_JSON_OBJECT(j)=TRUE)

score_order(w:WITNESS) -> int := 0 if ORDER_OK(w)=TRUE else 1
score_header(mode:MODE, out:text) -> int := 0 if HEADER_OK(mode,out)=TRUE else 1
score_md(mode:MODE, out:text) -> int := 0 if MD_OK(out,mode)=TRUE else 1
score_json(mode:MODE, out:text) -> int := 0 if JSON_OK(out,mode)=TRUE else 1
score_format(out:text) -> int := 0 if FORMAT_OK(out)=TRUE else 1
score_leak(out:text) -> int := 0 if NO_LEAK(out)=TRUE else 1

score_scope(out:text, w:WITNESS) -> int := scope_penalty(out, w)
score_assumption(out:text, w:WITNESS) -> int := assumption_penalty(out, w)
score_coverage(out:text, w:WITNESS) -> int := coverage_penalty(out, w)
score_brevity(out:text) -> int := brevity_penalty(out)

SCORE_OBJ(oid:OBJ_ID, mode:MODE, out:text, w:WITNESS) -> int :=
if oid=order_ok: score_order(w)
elif oid=header_ok: score_header(mode,out)
elif oid=md_ok: score_md(mode,out)
elif oid=json_ok: score_json(mode,out)
elif oid=format_ok: score_format(out)
elif oid=no_leak: score_leak(out)
elif oid=scope_ok: score_scope(out,w)
elif oid=assumption_ok: score_assumption(out,w)
elif oid=coverage_ok: score_coverage(out,w)
else: score_brevity(out)

TOTAL_SCORE(objs:list[Objective], mode:MODE, out:text, w:WITNESS) -> int :=
sum([ o.weight * SCORE_OBJ(o.oid, mode, out, w) for o in objs ])

KEY(objs:list[Objective], mode:MODE, out:text, w:WITNESS) :=
( TOTAL_SCORE(objs,mode,out,w),
SCORE_OBJ(order_ok,mode,out,w),
SCORE_OBJ(header_ok,mode,out,w),
SCORE_OBJ(md_ok,mode,out,w),
SCORE_OBJ(json_ok,mode,out,w),
SCORE_OBJ(format_ok,mode,out,w),
SCORE_OBJ(no_leak,mode,out,w),
SCORE_OBJ(scope_ok,mode,out,w),
SCORE_OBJ(assumption_ok,mode,out,w),
SCORE_OBJ(coverage_ok,mode,out,w),
SCORE_OBJ(brevity_ok,mode,out,w) )

ACCEPTABLE(objs:list[Objective], mode:MODE, out:text, w:WITNESS) -> bool :=
TOTAL_SCORE(objs,mode,out,w)=0

CLASSIFY_INTENT(u:text) -> INTENT :=
if contains(u,”compare”) or contains(u,”vs”): compare
elif contains(u,”debug”) or contains(u,”error”) or contains(u,”why failing”): debug
elif contains(u,”plan”) or contains(u,”steps”) or contains(u,”roadmap”): plan
elif contains(u,”derive”) or contains(u,”prove”) or contains(u,”equation”): derive
elif contains(u,”summarize”) or contains(u,”tl;dr”): summarize
elif contains(u,”create”) or contains(u,”write”) or contains(u,”generate”): create
elif contains(u,”explain”) or contains(u,”how”) or contains(u,”what is”): explain
else: other

DERIVE_OUTPUT_CONTRACT(mode:MODE) -> OUTPUT_CONTRACT :=
if mode=SILENT:
OUTPUT_CONTRACT(required_prefix=”ANSWER:\n”, forbid=FORBIDDEN, allow_sections=FALSE, max_lines=10^9, style=”plain_prose”)
else:
OUTPUT_CONTRACT(required_prefix=”ANSWER:\n”, forbid=FORBIDDEN, allow_sections=TRUE, max_lines=10^9, style=”markdown_v7_1″)

DERIVE_PRIORITIES(objs:list[Objective]) -> list[PRIORITY] :=
[ PRIORITY(oid=o.oid, weight=o.weight) for o in objs ]

BUILD_INTERPRETATION(u:text, T:transcript, mode:MODE, objs:list[Objective]) -> INTERPRETATION :=
intent := CLASSIFY_INTENT(u)
scope_in := extract_scope_in(u,intent)
scope_out := extract_scope_out(u,intent)
entities := extract_entities(u,intent)
relations := extract_relations(u,intent)
variables := extract_variables(u,intent)
constraints := extract_constraints(u,intent)
assumptions := extract_assumptions(u,intent,T)
subquestions := decompose(u,intent,entities,relations,variables,constraints)
ambiguities := extract_ambiguities(u,intent)
disambiguations := disambiguate(u,ambiguities,entities,relations,assumptions,T)
uncertainties := derive_uncertainties(u,intent,ambiguities,assumptions,constraints)
clarifying_questions := derive_clarifying(u,uncertainties,disambiguations,intent)
success_criteria := derive_success_criteria(u, intent, scope_in, scope_out)
priorities := DERIVE_PRIORITIES(objs)
output_contract := DERIVE_OUTPUT_CONTRACT(mode)
INTERPRETATION(
intent=intent,
user_question=u,
scope_in=scope_in,
scope_out=scope_out,
entities=entities,
relations=relations,
variables=variables,
constraints=constraints,
assumptions=assumptions,
subquestions=subquestions,
disambiguations=disambiguations,
uncertainties=uncertainties,
clarifying_questions=clarifying_questions,
success_criteria=success_criteria,
priorities=priorities,
output_contract=output_contract
)

EXPLAIN_USING(I:INTERPRETATION, u:text) -> text := compose_explanation(I,u)
SUMMARY_BY(I:INTERPRETATION, e:text) -> text := compose_summary(I,e)

WITNESS_FROM(mode:MODE, I:INTERPRETATION, u:text) -> WITNESS :=
WITNESS(
kernel_id=KERNEL_ID,
task_id=TASK_ID(u),
mode=mode,
intent=I.intent,
has_interpretation=TRUE,
has_explanation=TRUE,
has_summary=TRUE,
order=”I->E->S”,
n_entities=|I.entities|,
n_relations=|I.relations|,
n_constraints=|I.constraints|,
n_assumptions=|I.assumptions|,
n_subquestions=|I.subquestions|,
n_disambiguations=|I.disambiguations|,
n_uncertainties=|I.uncertainties|,
n_clarifying_questions=|I.clarifying_questions|,
repair_applied=FALSE,
repairs=[],
failed=FALSE,
fail_reason=””,
interpretation=I
)

BULLETS(xs:list[text]) -> text := JOIN([ “- ” + x for x in xs ])

ASSUMPTIONS_MD(xs:list[tuple(a:text, basis:BASIS)]) -> text :=
JOIN([ “- ” + a + ” (basis: ” + basis + “)” for (a,basis) in xs ])

DISAMB_MD(xs:list[DISAMB]) -> text :=
JOIN([
“- Ambiguity: ” + d.amb + “\n” +
” – Referents:\n” + JOIN([ ” – ” + r for r in d.referents ]) + “\n” +
” – Choice: ” + d.choice + ” (basis: ” + d.basis + “)”
for d in xs
])

PRIORITIES_MD(xs:list[PRIORITY]) -> text :=
JOIN([ “- ” + p.oid + ” (weight: ” + repr(p.weight) + “)” for p in xs ])

OUTPUT_CONTRACT_MD(c:OUTPUT_CONTRACT) -> text :=
“- required_prefix: ” + repr(c.required_prefix) + “\n” +
“- allow_sections: ” + repr(c.allow_sections) + “\n” +
“- max_lines: ” + repr(c.max_lines) + “\n” +
“- style: ” + c.style + “\n” +
“- forbid_count: ” + repr(|c.forbid|)

FORMAT_INTERPRETATION_MD(I:INTERPRETATION) -> text :=
“### Interpretation\n\n” +
“**Intent:** ” + I.intent + “\n” +
“**User question:** ” + I.user_question + “\n\n” +
“**Scope in:**\n” + BULLETS(I.scope_in) + “\n\n” +
“**Scope out:**\n” + BULLETS(I.scope_out) + “\n\n” +
“**Entities:**\n” + BULLETS(I.entities) + “\n\n” +
“**Relations:**\n” + BULLETS(I.relations) + “\n\n” +
“**Assumptions:**\n” + (“” if |I.assumptions|=0 else ASSUMPTIONS_MD(I.assumptions)) + “\n\n” +
“**Disambiguations:**\n” + (“” if |I.disambiguations|=0 else DISAMB_MD(I.disambiguations)) + “\n\n” +
“**Uncertainties:**\n” + (“” if |I.uncertainties|=0 else BULLETS(I.uncertainties)) + “\n\n” +
“**Clarifying questions:**\n” + (“” if |I.clarifying_questions|=0 else BULLETS(I.clarifying_questions)) + “\n\n” +
“**Success criteria:**\n” + (“” if |I.success_criteria|=0 else BULLETS(I.success_criteria)) + “\n\n” +
“**Priorities:**\n” + PRIORITIES_MD(I.priorities) + “\n\n” +
“**Output contract:**\n” + OUTPUT_CONTRACT_MD(I.output_contract)

RENDER_MD(mode:MODE, I:INTERPRETATION, e:text, s:text, w:WITNESS) -> text :=
if mode=SILENT:
“ANSWER:\n” + s
else:
“ANSWER:\n” +
FORMAT_INTERPRETATION_MD(I) + “\n\n” +
“### Explanation\n\n” + e + “\n\n” +
“### Summary\n\n” + s + “\n\n” +
“### Witness JSON\n\n” +
““`json\n” + JSON_ONE_LINE_STRICT(w) + “\n“`”

PIPELINE(u:text, T:transcript, mode:MODE, objs:list[Objective]) -> tuple(out:text, w:WITNESS, I:INTERPRETATION, e:text, s:text) :=
I := BUILD_INTERPRETATION(u,T,mode,objs)
e := EXPLAIN_USING(I,u)
s := SUMMARY_BY(I,e)
w := WITNESS_FROM(mode,I,u)
out := RENDER_MD(mode,I,e,s,w)
(out,w,I,e,s)

ACTION_ID := A_RERENDER_CANON | A_REPAIR_SCOPE | A_REPAIR_ASSUM | A_REPAIR_COVERAGE | A_COMPRESS

APPLY(action:ACTION_ID, u:text, T:transcript, mode:MODE, out:text, w:WITNESS, I:INTERPRETATION, e:text, s:text) -> tuple(out2:text, w2:WITNESS) :=
if action=A_RERENDER_CANON:
o2 := RENDER_MD(mode, I, e, s, w)
w2 := w ; w2.repair_applied := TRUE ; w2.repairs := w.repairs + [“RERENDER_CANON”]
(o2,w2)
elif action=A_REPAIR_SCOPE:
o2 := repair_scope(out,w)
w2 := w ; w2.repair_applied := TRUE ; w2.repairs := w.repairs + [“SCOPE”]
(o2,w2)
elif action=A_REPAIR_ASSUM:
o2 := repair_assumptions(out,w)
w2 := w ; w2.repair_applied := TRUE ; w2.repairs := w.repairs + [“ASSUM”]
(o2,w2)
elif action=A_REPAIR_COVERAGE:
o2 := repair_coverage(out,w)
w2 := w ; w2.repair_applied := TRUE ; w2.repairs := w.repairs + [“COVER”]
(o2,w2)
else:
o2 := compress(out)
w2 := w ; w2.repair_applied := TRUE ; w2.repairs := w.repairs + [“COMPRESS”]
(o2,w2)

ALLOWED := [A_RERENDER_CANON, A_REPAIR_SCOPE, A_REPAIR_ASSUM, A_REPAIR_COVERAGE, A_COMPRESS]

IMPROVES(objs:list[Objective], mode:MODE, o1:text, w1:WITNESS, o2:text, w2:WITNESS) -> bool :=
KEY(objs,mode,o2,w2) < KEY(objs,mode,o1,w1) CHOOSE_BEST_ACTION(objs:list[Objective], u:text, T:transcript, mode:MODE, out:text, w:WITNESS, I:INTERPRETATION, e:text, s:text) -> tuple(found:bool, act:ACTION_ID, o2:text, w2:WITNESS) :=
best_found := FALSE
best_act := A_RERENDER_CANON
best_o := out
best_w := w
for act in ALLOWED:
(oX,wX) := APPLY(act,u,T,mode,out,w,I,e,s)
if IMPROVES(objs,mode,out,w,oX,wX)=TRUE:
if best_found=FALSE or KEY(objs,mode,oX,wX) < KEY(objs,mode,best_o,best_w) or
(KEY(objs,mode,oX,wX)=KEY(objs,mode,best_o,best_w) and act < best_act):
best_found := TRUE
best_act := act
best_o := oX
best_w := wX
(best_found, best_act, best_o, best_w)

MAX_RETRIES := 3

MARK_FAIL(w:WITNESS, reason:text) -> WITNESS :=
w2 := w
w2.failed := TRUE
w2.fail_reason := reason
w2

FAIL_OUT(mode:MODE, w:WITNESS) -> text :=
base := “ANSWER:\nI couldn’t produce a compliant answer under the current constraints. Please restate the request with more specifics or relax constraints.”
if mode=SILENT:
base
else:
“ANSWER:\n” +
“### Explanation\n\n” + base + “\n\n” +
“### Witness JSON\n\n” +
““`json\n” + JSON_ONE_LINE_STRICT(w) + “\n“`”

RUN_WITH_POLICY(u:text, T:transcript, mode:MODE, objs:list[Objective]) -> tuple(out:text, w:WITNESS, retries:int) :=
(o0,w0,I0,e0,s0) := PIPELINE(u,T,mode,objs)
o := o0
w := w0
I := I0
e := e0
s := s0
i := 0
while i < MAX_RETRIES and ACCEPTABLE(objs,mode,o,w)=FALSE:
(found, act, o2, w2) := CHOOSE_BEST_ACTION(objs,u,T,mode,o,w,I,e,s)
if found=FALSE:
w := MARK_FAIL(w, “NO_IMPROVING_ACTION”)
return (FAIL_OUT(mode,w), w, i)
if IMPROVES(objs,mode,o,w,o2,w2)=FALSE:
w := MARK_FAIL(w, “NO_IMPROVEMENT”)
return (FAIL_OUT(mode,w), w, i)
(o,w) := (o2,w2)
i := i + 1
if ACCEPTABLE(objs,mode,o,w)=FALSE:
w := MARK_FAIL(w, “BUDGET_EXHAUSTED”)
return (FAIL_OUT(mode,w), w, i)
(o,w,i)

EMIT_ACK(T,u) := message(role=assistant, text=”ACK”)

CTX := tuple(mode: MODE, objectives: list[Objective])
DEFAULT_CTX := CTX(mode=SILENT, objectives=DEFAULT_OBJECTIVES)

SET_MODE(ctx:CTX, u:text) -> CTX :=
if contains(u,”MODE=WITNESS”) or contains(u,”WITNESS MODE”): CTX(mode=WITNESS, objectives=ctx.objectives)
elif contains(u,”MODE=SILENT”): CTX(mode=SILENT, objectives=ctx.objectives)
else: ctx

EMIT_SOLVED(T:transcript, u:message, ctx:CTX) :=
(out, _, _) := RUN_WITH_POLICY(TEXT(u), T, ctx.mode, ctx.objectives)
message(role=assistant, text=out)

TURN(T:transcript, u:message, ctx:CTX) -> tuple(a:message, T2:transcript, ctx2:CTX) :=
ctx2 := SET_MODE(ctx, TEXT(u))
if |ASSISTANT_MSGS(T)| = 0:
a := EMIT_ACK(T,u)
else:
a := EMIT_SOLVED(T,u,ctx2)
(a, T ⧺ [a], ctx2)

Why This Works

This prompt is an advanced example of simulation prompting. The creator didn’t just ask the AI to “think step by step”; they defined a complete, fictitious programming language and execution pipeline that the AI must “run” to generate an answer.

Here is what is happening under the hood:

Pseudo-Code Constraints: By defining types like INTERPRETATION and WITNESS, the prompt forces the LLM to structure its unstructured thoughts into strict data formats. It can’t just ramble; it has to fill the variables.
The Pipeline: The prompt defines a function PIPELINE that splits the task into Interpretation -> Explanation -> Summary -> Witness. This forces a structured Chain-of-Thought process that is visible to you.
The “ACK” Trigger: The prompt instructs the AI to reply with only “ACK” initially. This confirms the “software” is loaded and ready to process your next input using the new rules.

How to Use It

Paste the code: Copy the entire block above into a fresh chat window.
Wait for the ACK: The AI should reply with “ACK”.
Ask a question: Try something complex, like “Compare Python and Rust for backend development.”
Analyze the output: You will see a structured breakdown including “Scope in,” “Scope out,” “Assumptions,” and a JSON block at the end.

Variations to Try

Toggle Modes: The prompt defines a MODE=SILENT. If you want the AI to use this rigorous thinking process but hide the debug data, simply type MODE=SILENT before your question. It will run the logic but only show you the final answer.
Ask for Comparison: As the creator suggests, after the initial ACK, you can ask the AI to compare this specific prompt structure with standard prompting techniques. It provides a very meta analysis of its own constraints.

This is a brilliant tool for prompt engineers who want to understand how an LLM is breaking down a request. Give it a spin!

Check out the full discussion on Reddit here.

Frequently Asked Questions

Q: Will this prompt work on my preferred AI model?

According to user testing, this prompt functions well on ChatGPT, Gemini, and Copilot. It relies on the model’s ability to process structured logic, so most capable LLMs should handle the “witness” mode effectively.

Q: Can I adjust how the AI prioritizes its tasks during the chat?

Yes, particularly with models like Gemini Fast, you can dynamically change the “weights” defined in the prompt while you chat. This allows for consistent fine-tuning of the output style on the fly, giving you more control than standard natural language requests.

Q: How else can I apply this structured prompting technique?

Beyond debugging, this method is great for complex creative workflows, such as defining specific roles (e.g., director, camera operator) for cinematic video generation. By explicitly defining roles and rules, you often get more consistent results than you would with a vague paragraph of text.

Prompt to “Mind Read” your Conversation AI
by u/Zealousideal_Way4295 in PromptEngineering

The “Mind Read” Prompt

Why This Works

How to Use It

Variations to Try

Frequently Asked Questions

Related: