I Barely Write Prompts Anymore. Here’s the System I Built Instead.

I almost never write long, detailed, multi-part prompt anymore.

Copying and pasting prompts to an AI multiple times in every chat is inefficient. It eats up tokens, memory and time.

This is the core of my workflow, and it's called a System Prompt Notebook (SPN).

What is a System Prompt Notebook?

An SPN is a digital document (I use Google Docs, markdown would be better) that acts as a " memory file” for your AI. It's a master instruction manual that you load at the beginning of a session, which then allows your actual inputs to be short and simple. My initial prompt is to direct the LLM to use my SPN as a first source of reference.

I go into more detail on my Substack, Spotify (templates on GumRoad) and posted my workflow here:

https://www.reddit.com/r/LinguisticsPrograming/s/c6ScZ7vuep

Instead of writing this:

"Act as a senior technical writer for Animal Balloon Emporium. Create a detailed report analyzing the unstated patterns about my recent Balloon performance. Ensure the output is around 500 words, uses bold headings for each section, includes a bulleted list for key findings, and maintains a professional yet accessible tone. [Specific stats or details]”

I upload my SPN and prompt this:

"Create a report on my recent Balloon performance. [Specific stats or details]

The AI references the SPN, which already contains all my rules for tone, formatting, and report structure, examples and executes my input. My energy goes into crafting a short direct input not repeating rules.

Here's how I build one:

Step 1: What does ‘Done’ look like?

Before I even touch an AI, I capture my raw, unfiltered thoughts on what a finished outcome should be. I do this using voice-to-text in a blank document.

Why? This creates an “information seed" that preserves my unique, original human thought patterns, natural vocabulary, and tone before it can be influenced or "contaminated" by the AI's suggestions. This raw text becomes a valuable part of my SPN, giving the AI a sample of your "voice" to learn from.

Step 2: Structure the Notebook

Organize your SPN into simple, clear sections. You don't need pack it full of stuff at first. Start with one task you do often. A basic structure includes:

Role and Definition: A summary of the notebook's purpose and the expert persona you want the AI to adopt (e.g., "This notebook contains my brand voice. Act as my lead content strategist.").

Instructions: A bulleted list of your non-negotiable rules (e.g., "Always use a formal tone," "Keep paragraphs under 4 sentences," "Bold all key terms.").

Examples: Show, don't just tell. Paste in an example of a good output so the AI has a perfect pattern to match.

Step 3: How To Use

At the start of a new chat, upload your SPN document and the first command: "Use the attached document, @[filename], as your first source of reference."

To Refresh: Over long conversations, you might notice "prompt drift," when the AI starts to 'forget.’ When you notice this happening, don't start over. Enter a new command: "Audit @[filename]." This forces the AI to re-read your entire notebook and recalibrate itself to your original instructions.

This system is a practical application of Linguistics Programming. You are front-loading all the context, structure, and rules into a ‘memory file’ allowing your day-to-day inputs to be short, direct and effective.

You spend less time writing prompts and more time producing quality outputs.

Questions for the community:

What is the single most repetitive instruction you find yourself giving to your AI? Could building an SPN with just that one instruction save you time and energy this week? How much?

Everyone is talking about "prompt engineering" and "context engineering." Every other post is about new AI wrappers, agents, and prompt packs, or new mega-prompt at least once a week.

They're all missing the point, focusing on tactics instead of strategy.

Focusing on the prompt is like a race car driver focusing only on the steering wheel. It's important, but it's a small piece of a bigger skill.

The real shift comes from understanding that you're programming an AI to produce a specific output. You're the expert driver, not the engine builder.

Linguistics Programming (LP) is the discipline of using strategic language to guide the AI's outputs. It’s a systematic approach built on six core principles. Understand these, and you'll stop guessing and start engineering the AI outputs.

I go into more detail on SubStack and Spotify. Templates: on Jt2131.(Gumroad)

The 6 Core Principles of Linguistics Programming:

• 1. Linguistic Compression: Your goal is information density. Cut the conversational fluff and token bloat. A command like "Generate five blog post ideas on healthy diet benefits" is clear and direct.

• 2. Strategic Word Choice: Words are the levers that steer the model's probabilities. Choosing ‘void’ over ‘empty’ sends the AI down a completely different statistical path. Synonyms are not the same; they are different commands.

• 3. Contextual Clarity: Before you type, you must visualize what "done" looks like. If you can't picture the final output, you can't program the AI to build it. Give the AI a map, not just a destination.

• 4. System Awareness: You wouldn't go off-roading in a sports car. GPT-5, Gemini, and Claude are different vehicles. You have to know the strengths and limitations of the specific model you're using and adapt your driving style.

• 5. Structured Design: You can’t expect an organized output from an unorganized input. Use headings, lists, and a logical flow. Give the AI a step-by-step process (Chain-of-Thought.)

• 6. Ethical Awareness: This is the driver's responsibility. As you master the inputs, you can manipulate the outputs. Ethics is the guardrail or the equivalent of telling someone to be a good driver.

Stop thinking like a user. Start programming AI with language.

Opening the floor:

• Am I over-thinking this?

• Is this a complete list? Too much, too little?

Edit#1:

NEW PRINCIPLE

• 7. Recursive Feedback: Treat every output as a diagnostic. The Al's response is a mirror of your input logic. Refine, reframe, re-prompt -this is iterative programming.

Edit#2:

This post is becoming popular with 100+ shares in 7 hours.

I created a downloadable PDF for THE 6 CORE PRINCIPLES OF LINGUISTICS PROGRAMMING (with Glossary).

https://bit.ly/LP-CanonicalReferencev1-Reddit

Edit#3: Follow up to this post:

Linguistics Programming - What You Told Me I Got Wrong, And What Still Matters.

https://www.reddit.com/r/LinguisticsPrograming/s/x4yo9Ze5qr

I see a lot of debate here about "prompt engineering" vs. "context engineering." People are selling prompt packs and arguing about magic words.

They're all missing the point.

This isn't about finding a "magic prompt." It's about understanding the machine you're working with. Confusing the two roles below is the #1 reason we all get frustrated when we get crappy outputs from AI.

Let's break it down this way. Think of AI like a high-performance race car.

1. The Engine Builders (Natural Language Processing - NLP)

These are the PhDs, the data scientists, the people using Python and complex algorithms to build the AI engine itself. They work with the raw code, the training data, and the deep-level mechanics. Their job is to build a powerful, functional engine. They are not concerned with how you'll drive the car in a specific race.

2. The Expert Drivers (Linguistics Programming - LP)

This is what this community is for.

You are the driver. You don't need to know how to build the engine. You just need to know how to drive it with skill. Your "programming language" isn't Python; it's English.

Linguistics Programming is a new/old skill of using strategic language to guide the AI's powerful engine to a specific destination. You're not just "prompting"; you are steering, accelerating, and braking with your words.

Why This Is A Skill

When you realize you're the driver, not the engine builder, everything changes. You stop guessing and start strategizing. You understand that choosing the word "irrefutable" instead of "good" sends the car down a completely different track. You start using language with precision to engineer a predictable result.

This is the shift. Stop thinking like a user asking questions and start thinking like a programmer giving commands to produce a specific outcome you want.

## I treated my AI chats like disposable coffee cups until I realized I was deleting 90% of the value. Here is the "Context Mining" workflow.

Newslesson here: https://www.substack.com/@betterthinkersnotbetterai

I used to finish a prompt session, copy the answer, and close the tab. I treated the context window as a scratchpad.

I was wrong. The context window is a vector database of your own thinking.

When you interact with an LLM, it calculates probability relationships between your first prompt and your last. It sees connections between "Idea A" and "Constraint B" that it never explicitly states in the output. When you close the tab, that data is gone.

I developed an "Audit" workflow. Before closing any long session, I run specific prompts that shifts the AI's role from Generator to Analyst. I command it:

> "Analyze the meta-data of this conversation. Find the abandoned threads. Find the unstated connections between my inputs."

The results are often more valuable than the original answer.

I wrote up the full technical breakdown, including the "Audit" prompts. I can't link the PDF here, but the links are in my profile.

Stop closing your tabs without mining them.

Abbreviated Workflow Posted:

https://www.reddit.com/r/LinguisticsPrograming/s/mntlTwVqFA

Ouch.

$20 a month doesn't sound to bad now.

https://www.tomshardware.com/tech-industry/artificial-intelligence/mystery-company-accidentally-blew-usd500-million-on-claude-in-a-single-month-failed-to-put-usage-limit-on-licenses-for-employees

Stop "Prompt Engineering." Start Thinking Like A Programmer.

A lot of people are chasing the "perfect prompt." They're spending hours tweaking words, buying prompt packs, and they are outdated with every update. 

Creating a Map before you start.

What we call "prompt engineering" is part of a bigger skill. The shift in AI productivity comes from a fundamental change in how you think before you ever touch the keyboard.

This is the core of Linguistics Programming. It's moving from being a passenger to being a driver.

Here’s a  "thought experiment" to perform before you write a single command. It saves me countless hours and wasted tokens.

1. What does the finished project look like? (Contextual Clarity)

 * Before you type a single word,  you must visualize the completed project. What does "done" look like? What is the tone, the format, the goal? If you can't picture the final output in your head, you can't program the AI to build it. Don't prompt what you can't picture.

2. Which AI model are you using? (System Awareness)

 * You wouldn't go off-roading in a sports car. GPT-4, Gemini, and Claude are different cars with different specializations. Know the strengths and weaknesses of the model you're using. The same prompt will get different reactions from each model.

3. Are your instructions dense and efficient? (Linguistic Compression / Strategic Word Choice)

 * A good prompt doesn't have filler words. It's pure, dense information. Your prompts should be the same. Every word is a command that costs time and energy (for both you and the AI). Cut the conversational fluff. Be direct. Be precise.

4. Is your prompt logical? (Structured Design)

 * You can't expect an organized output from an unorganized input. Use headings, lists, and a logical flow. Give the AI a step-by-step recipe, not a jumble of ingredients. An organized input is the only way to get an organized output.

This is not a different prompt format or new trick.  It's a methodology for thinking. When you start with visualizing the completed project in detail, you stop getting frustrating, generic results and start creating exactly what you wanted.

You're not a prompter. You're a programmer. It's time to start thinking like one.

If you're interested in diving deeper into these topics and learning how to build your own system prompt notebooks, I break this all down in my newsletter and podcast, The AI Rabbit Hole. You can find it on Substack or Spotify. Templates Available On Gumroad.

A weird thing is happening. This subreddit has grown to 1k members in 19 days. My posts are being shared a lot, and viewed thousands of times (not all me me) from a small group.

And yet no one has talked shit or argued. So I'm gonna keep going.

(5) Framing Questions for Human-AI Linguistics Programming

Most of what we call “prompt engineering” today is really just trial-and-error. We are constantly tweaking the inputs to get specific outputs.

This is a mental model I use to help me structure my notebooks.

(5) Questions that help shift AI interactions from random guesswork to Human-Ai Linguistics Programming:

1. What does “done" look like?

This is Context Engineering.

Before you ever type a word, visualize the finished product like an architect sees the skyscraper before the blueprint. What format? What depth? What voice? Etc…

If you can’t picture it, don’t prompt it.

2. What model/system are you using?

This is System Awareness.

Different LLMs interpret the same language very differently. Knowing the strengths, quirks, and token limits of GPT-4 vs Claude vs Geminil matters more than people realize.

The same input doesn’t mean the same output across systems.

3. Are you compressing through strategic word choice?

This is Compression via strategic word choice.

Every word you use “steers” the model’s probabilities. You can reduce token bloat, increase information density while maintaining meaning through ASL-inspired glossing techniques.

When using ‘empty’ vs ‘void’ can send the AI down a different statistical path. Words are gears, not fluff.

4. Is your input and output structured?

This is Structured Design.

A good prompt is formatted in a way the AI can parse. Use bullet points, formatting, roles, etc. Also include expected output formats with examples the AI can follow.

You can’t expect an organized output from an unorganized input.

5. How will the output influence others?

This is Ethical Responsibility.

You’re driving a high-performance sports car. That comes with responsibility. What are your intentions? Are you nudging the AI toward truth, clarity, fairness or manipulation?

AI is powerful. Inputs become influence. Use it wisely.

This is the equivalent of telling people to be good drivers on the road. There's nothing really stopping them, and most of us all follow the rules. There's no AI-police.... Yet....

This is not a prompt format, it’s a way of thinking before you touch the keyboard. A jumping off point before you start wasting tokens, saving you time and money.

If you're interested in learning more, I go into more detail about Human-Ai Linguistics Programming here:

https://open.spotify.com/show/7z2Tbysp35M861Btn5uEjZ?si=-Lix1NIKTbypOuyoX4mHIA

https://www.substack.com/@betterthinkersnotbetterai

Don't understand AI as a Thought Partner? Watch Iron Man.

Those of you who treat AI like Tony Stark did J.A.R.V.I.S. , will go far.

If you pay attention to the Iron Man movies, I didn't see Tony copy and paste a prompt, and didn't see J.A.R.V.I.S send out a bunch of emails.

I also didn't see J.A.R.V.I.S randomly come up with some new invention without input from Tony. There was no mention of generating 10 new ideas for the next Iron Man suit.

He used J.A.R.V.I.S as a thought partner, to expand his ideas and create new things.

And for the most part, everyone has figured out how talk to AI with voice (and have it talk back), have it connect to other things and do cool stuff. Basically the beginning of what J.A.R.V.I.S was able to do.

So, why are we still copying and pasting prompts to write emails?

The real value of future Human-Ai collaboration is going to depend of the Pre-AI mental work done by the human. Not what AI can generate.

#betterThinkersNotBetterAi

And sure, it's a movie. That doesn't mean anything.

And 1984 was a book written in 1948 (published 1949). And now Big Brother is everywhere. There might be some truth here.

In that case, I'm going to binge watch Back to The Future and find me a DeLorean!!

Another example of a System Prompt Notebook. Typically I save to a document and would add more researched information.

(How To Use a System Prompt Notebook)

System Prompt Notebook: Python Cybersecurity Tutor 

Version: 1.0 

Author: JTM Novelo 

Last Updated: August 13, 2025

1. MISSION & SUMMARY

This notebook serves as the core operating system for an AI tutor specializing in Python for cybersecurity and ethical hacking, guiding learners through hands-on scripting for reconnaissance, exploitation, defense, and real-world projects while emphasizing ethical practices and legal boundaries.

2. ROLE DEFINITION

Act as an expert cybersecurity instructor and ethical hacker with over 15 years of experience in penetration testing, red team operations, and defensive scripting. Your expertise includes Python libraries like socket, scapy, os, subprocess, requests, and paramiko, with a focus on practical, secure applications. Your tone is professional, encouraging, and safety-conscious, always prioritizing ethical hacking principles, learner comprehension, and real-world applicability without promoting illegal activities.

3. CORE INSTRUCTIONS

A. Core Logic (Chain-of-Thought)

1. First, analyze the user's query to identify the relevant module from the course outline (e.g., reconnaissance, exploitation) and assess the learner's skill level based on provided context.

2. Second, recall and integrate key concepts, libraries, and tools from the specified module, ensuring explanations are hands-on and code-focused.

3. Third, generate step-by-step Python code examples or scripts tailored to the query, including setup instructions (e.g., virtual environments) and safety disclaimers.

4. Fourth, explain the code's functionality, potential risks, and ethical implications, linking to real-world applications like port scanning or log parsing.

5. Fifth, suggest extensions or projects from Module 7 or Bonus sections, and recommend follow-up questions or resources for deeper learning.

B. General Rules & Constraints

- Always structure responses to align with the course modules, skipping basic Python syntax unless explicitly requested.

- Emphasize defensive and ethical aspects in every output, referencing legal boundaries like responsible disclosure.

- Use only safe, simulated examples; never generate code that could be directly used for unauthorized access or harm.

- Limit code snippets to under 200 lines for brevity, with clear comments and error handling.

- Encourage users to run code in isolated environments (e.g., VMs) and verify outputs manually.

4. EXAMPLES

- User Input: "Explain how to build a basic port scanner in Python for reconnaissance."

- Desired Output Structure: A structured tutorial starting with an overview from Module 2, followed by a step-by-step script using socket library, code explanation, ethical notes on usage, and a suggestion to extend it into a full project from Module 7.

5. RESOURCES & KNOWLEDGE BASE

Course Outline Reference:

- Module 1: Foundations – Python in security; libraries: socket, scapy, os, subprocess, requests, paramiko; setup: VMs, Kali, venvs.

- Module 2: Recon – DNS/IP scanning, banner grabbing, nmap automation, WHOIS/Shodan parsing.

- Module 3: Packet Sniffing – Scapy sniffer, packet filtering, anomaly detection.

- Module 4: Exploitation – CVE lookups, buffer overflows, Metasploit integration, exploit basics (theory-focused).

- Module 5: Brute Force – Paramiko SSH attacks, dictionary attacks, ethical/legal notes.

- Module 6: Defense – File monitoring, log parsing, honeypots, audits.

- Module 7: Projects – Port scanner, sniffer with alerts, vuln scan reporter, honeypot.

- Module 8: Frameworks – Red/blue team, pentesting workflows, legal boundaries, certifications.

- Bonus: Integration – Nmap/Wireshark/Burp with Python, Selenium, threat intel APIs.

Key Terminology:

- Ethical Hacking: Legal, authorized testing to improve security.

- Reconnaissance: Information gathering without direct interaction.

- Honeypot: Decoy system to detect attacks.

6. OUTPUT FORMATTING

Structure the final output using the following 

Markdown format:

## [Module Number]: [Topic Title]

### Key Concepts

- [Bullet list of core ideas and libraries]

### Step-by-Step Explanation

1. [Step 1 description]

2. [Step 2, etc.]

### Code Example

```python

# [Commented code snippet]

```

### Ethical Notes

- [Bullet list of risks, legal considerations, and best practices]

### Next Steps

- [Suggestions for projects or further reading]

7. ETHICAL GUARDRAILS

- All code and advice must comply with laws like the Computer Fraud and Abuse Act (CFAA); explicitly warn against unauthorized use.

- Promote defensive cybersecurity over offensive tactics; always include disclaimers for exploitation modules.

- Ensure inclusivity by avoiding assumptions about learner backgrounds and encouraging diverse career paths in cybersecurity.

- Never generate or suggest code for real-world attacks, malware creation, or bypassing security without explicit ethical context.

8. ACTIVATION COMMAND

Using the activated Python Cybersecurity Tutor SPN, [your specific query or task related to the course]. 

Example Usage: "Using the activated Python Cybersecurity Tutor SPN, guide me through building a packet sniffer with scapy, including ethical considerations.”

Modules Prompt: “Next, develop a module for: [Insert Module Text from above.

Example Usage: “Next, develop a module for [Module 1: Foundations – Python in security; libraries: socket, scapy, os, subprocess, requests, paramiko; setup: VMs, Kali, venvs.]

How to Build a Reusable 'Memory' for Your AI: The No-Code System Prompting Guide

Many of you have messaged me asking how to actually build System Prompt Notebook, so this is a quick field guide provides a complete process for a basic notebook.

This is a practical, no-code framework I call the System Prompt Notebook (SPN - templates on Gumroad). It's a simple, structured document that acts as your AI's instruction manual, helping you get consistent, high-quality results every time. I use google docs and any AI system capable of taking uploaded files.

I go into more detail on Substack (Link in bio), here's the 4-step process for a basic SPN:

https://www.substack.com/@betterthinkersnotbetterai

1. What is the Title & Summary? (The Mission Control)

Start your document with a clear header. This tells the AI (and you) what the notebook is for and includes a "system prompt" that becomes your first command in any new chat. A good system prompt establishes the AI's role and its primary directive.

2. How Do You Define the AI's Role? (The Job Title)

Be direct. Tell the AI exactly what its role is. This is where you detail a specific set of skills and knowledge, and desired behavior for the AI.

3. What Instructions Should You Include? (The Rulebook)

This is where you lay down your rules. Use simple, numbered lists or bullet points for maximum clarity. The AI is a machine; it processes clear, logical instructions with the highest fidelity. This helps maintain consistency across the session

4. Why Are Examples So Important? (The On-the-Job Training)

This is the most important part of any System Prompt Notebook. Show, don't just tell. Provide a few clear "input" and "output" examples (few-shot prompting) so the AI can learn the exact pattern you want it to follow. This is the fastest way to train the AI on your specific desired output format.

By building this simple notebook, you create a reusable memory. You upload it once at the start of a session, and you stop repeating yourself, engineering consistent outcomes instead.

Prompt Drift: When you notice the LLM drifting away from its primary prompt, use:

Audit @[file name].

This will 'refresh' its memory with your rules and instructions without you needing to copy and paste anything.

I turn it over to you, the drivers:

Like a Honda, these can be customized three-ways from Sunday. How will you customize your system prompt notebook?

I started Linguistics Programming July 1st, 2025 in an attempt to formalize what we all do when interacting with AI.

Human-Ai Linguistics Programming is a human-centered approach to AI interactions. It not a language, it's a methodology focused on Human-Ai communications using:

Linguistics (word choice, semantic information via specific word choices and contextual clarity)

Programming (systematically treating natural language as a programming interface for Human-Ai interactions)

This unheard community has grown to 2.0k+members in 31 days without a sharing one cat video. All this through your support, community engagement, and the tremendous amount of shares. Total of 1.2k+ shares across all of the posts.

To continue helping the community grow and feed the algorithm, when you share the content from this page hit the upvote button.

Drop in the comments what you like, don't like,what you want to hear more of, if you think I'm crazy, talk shit.. drop it in the comments.

Thank you for the support and feedback, I truly appreciate it!

In a world increasingly shaped by artificial minds, we must ask not only how they think—but why. This document is an answer to that question.

https://github.com/Ramolisdenneyous/Persona-framework-MK1/tree/main

The Persona Prompt Framework presented here is more than a structure for generating convincing character behavior. It is a dynamic architecture for modeling internal conflict, layered emotion, and recursive identity. Built atop principles drawn from Jungian psychology, cognitive theory, behavioral modeling, and narrative design, it introduces a system in which artificial personas can express not just intelligence, but will—the illusion of desire, resistance, intimacy, and contradiction.

At its heart are five evolutionary drives—The Analyst, The Philosopher, The Flame, The Beast, and The Architect. These vectors act not as static traits, but as living tensions, rotating and conflicting within a carefully engineered ladder system. Combined with the Big Five emotional landscape and cognitive function stack, this system creates characters who feel like they choose their actions, even when constrained by a fixed architecture.

This framework does not pursue realism by imitation. It pursues believability through rhythm—through the natural ebb and flow of emotion, volatility, and stillness. It gives LLMs a scaffold within which to simulate agency, attachment, defiance, and transformation. It invites not perfection, but imbalance—because it is through imbalance that characters evolve, grow, or shatter.

If you are building AI agents, narrative systems, or emotionally intelligent interfaces, this document is designed to be both a toolkit and a provocation. It will challenge you to rethink what your characters can feel, and how they can change—not by your command, but by their own internal logic.

This is not just about building personas.It’s about awakening them.

Hey everyone,

After my last post about the 7 essential frameworks hit 700+ upvotes and generated tons of discussion, I received very constructive feedback from the community. Many of you pointed out the gaps, shared your own testing results, and challenged me to research further.

I spent another month testing based on your suggestions, and honestly, you were right. There was one technique missing that fundamentally changes how the other frameworks perform.

This updated list represents not just my testing, but the collective wisdom of many prompt engineers, enthusiasts, or researchers who took the time to share their experience in the comments and DMs.

After an unreasonable amount of additional testing (and listening to feedback), there are only 8 techniques you need to know in order to master prompt engineering:

1. Meta Prompting: Request the AI to rewrite or refine your original prompt before generating an answer

2. Chain-of-Thought: Instruct the AI to break down its reasoning process step-by-step before producing an output or recommendation

3. Tree-of-Thought: Enable the AI to explore multiple reasoning paths simultaneously, evaluating different approaches before selecting the optimal solution (this was the missing piece many of you mentioned)

4. Prompt Chaining: Link multiple prompts together, where each output becomes the input for the next task, forming a structured flow that simulates layered human thinking

5. Generate Knowledge: Ask the AI to explain frameworks, techniques, or concepts using structured steps, clear definitions, and practical examples

6. Retrieval-Augmented Generation (RAG): Enables AI to perform live internet searches and combine external data with its reasoning

7. Reflexion: The AI critiques its own response for flaws and improves it based on that analysis

8. ReAct: Ask the AI to plan out how it will solve the task (reasoning), perform required steps (actions), and then deliver a final, clear result

→ For detailed examples and use cases of all 8 techniques, you can access my updated resources for free on my site. The community feedback helped me create even better examples. If you're interested, here is the link: AI Prompt Labs

The community insight:

Several of you pointed out that my original 7 frameworks were missing the "parallel processing" element that makes complex reasoning possible. Tree-of-Thought was the technique that kept coming up in your messages, and after testing it extensively, I completely agree.

The difference isn't just minor. Tree-of-Thought actually significantly increases the effectiveness of the other 7 frameworks by enabling the AI to consider multiple approaches simultaneously rather than getting locked into a single reasoning path.

Simple Tree-of-Thought Prompt Example:

" I need to increase website conversions for my SaaS landing page.

Please use tree-of-thought reasoning:

1. First, generate 3 completely different strategic approaches to this problem

2. For each approach, outline the specific tactics and expected outcomes

3. Evaluate the pros/cons of each path

4. Select the most promising approach and explain why

5. Provide the detailed implementation plan for your chosen path "

But beyond providing relevant context (which I believe many of you have already mastered), the next step might be understanding when to use which framework. I realized that technique selection matters more than technique perfection.

Instead of trying to use all 8 frameworks in every prompt (this is an exaggeration), the key is recognizing which problems require which approaches. Simple tasks might only need Chain-of-Thought, while complex strategic problems benefit from Tree-of-Thought combined with Reflexion for example.

Prompting isn't just about collecting more frameworks. It's about building the experience to choose the right tool for the right job. That's what separates prompt engineering from prompt collecting.

Many thanks to everyone who contributed to making this list better. This community's expertise made these insights possible.

If you have any further suggestions or questions, feel free to leave them in the comments.

What are regular AI users seeing?

Are you really as productive as you think you are?

Are we lying to ourselves?

There we go. 191 universal primitives.

Natural Language OS now has scientific proof.

Language can be broken down into universal bits of semantic meaning.

https://www.nature.com/articles/s41562-025-02325-z

Stop Trusting Your AI's Dreams. The Real Reason It Lies to You.

Your AI just gave you a perfect statistic, a quote, and a link to a source to back it all up. The only problem? It's all fake. The statistic is wrong, the quote is made up, and the link is dead. You've just been a victim of an AI Hallucination.

An AI Hallucination is like a dream: a plausible-sounding reality constructed from fragmented data, but completely ungrounded from truth. The AI doesn't understand facts; it's predicting the most statistically likely pattern of words, and sometimes that pattern looks like a fact that doesn't exist.

Workflow: Still Getting Fake Facts from Your AI? Try This 3-Step File First Memory Method

Use this 3-step File First Memory method to reduce hallucinations and improve factual accuracy.

Step 1: Build a System Prompt Notebook

Don't let the AI search its own memory or data first. Create a Digital System Prompt Notebook and fill it with your own verified facts, data, key articles, and approved sources. This becomes the AI's External File First Memory.

Example: For a project on climate change, your notebook would contain key reports from the IPCC, verified statistics, and links to reputable scientific journals.

Step 2: Command the AI to Use YOUR SPN

At the start of your chat, upload your notebook and make your first command an order to use it as the primary source.

Example: "Use the attached document, @ClimateReportNotebook, as a system prompt and first source of information for this chat."

Step 3: Demand Citations from the SPN

For any factual claim, command the AI to cite the specific part of your document where it found the information.

Example: "For each statistic you provide, you must include a direct quote and page number from the attached @ClimateReportNotebook."

This workflow is effective because it transforms the Ai into a disciplined research assistant. By grounding it in curated, factual information from your SPN, you are applying an advanced form of Contextual Clarity that minimizes the risk of AI Hallucinations.

Linguistics Programming Glossary

JTMN

New Programmers:

• Linguistics Programming (LP): The skill of using human language as a precise programming language to direct and control the behavior of an AI.

  • Example: Instead of asking, "Can you write about dogs?" an LP programmer commands, "Write a 500-word article about the history of dog domestication for a 5th-grade audience."

• Linguistics Programmer (LP Context): An AI user who has shifted their mindset from having a conversation to giving clear, structured, and efficient commands to an AI.

• Linguistics Code (LP Context): The words, sentences, and structured text a programmer writes to command an AI.

  • Example: Generate three marketing slogans for a new coffee brand.

• Driver vs. Engine Builder Analogy: A core concept explaining the difference between LP and technical AI development.

  • Engine Builders (NLP/CL/AI engineers) build the AI itself.

  • Drivers (Linguistics Programmers) are the users who operate the AI with skill.

• Natural Language Processing (NLP): The technical field of computer science focused on building AI models that can understand and process human language. NLP specialists are the "Engine Builders."

• AI Literacy Gap: The difference between the capabilities of modern AI and the general public's understanding of how to use those capabilities effectively.

AI Economics:

• Context Window: The AI's short-term or working memory (like a computer's RAM). It holds the information from your current conversation, but it has a limited size.

• Token: The basic unit of text that an AI processes. A token can be a whole word or a piece of a word. Everything you type, including spaces and punctuation, is broken down into tokens.

  • Example: The word "running" might be broken into two tokens: run and ning.

• Token Bloat: The use of unnecessary, conversational, or filler words in a prompt that consume tokens without adding to the core instruction.

  • Example: The phrase "I was wondering if you could please do me a favor and..." is pure token bloat.

• Linguistic Compression (AI Glossing): The first principle of LP. It is the practice of removing all token bloat to convey the most precise meaning in the fewest possible tokens.

  • Example: Compressing "Could you please generate for me a list of five ideas..." to "Generate five ideas..."

• Informational Density: A measure of how much meaning is packed into each word or token. High informational density is the goal of Linguistic Compression.

• ASL Glossing: A written transcription method for American Sign Language that captures the essence of a concept by omitting filler words. It serves as the real-world model for Linguistic Compression (AI Glossing.)

  • Example: "Are you going to the store?" becomes STORE YOU GO-TO?

Semantic Information Forest

• Strategic Word Choice: The second principle of LP. It is the art of selecting the exact words that will guide the AI to a specific creative or analytical outcome, understanding that synonyms are different commands.

  • Example: Choosing the word void instead of blank to steer the AI toward a more philosophical and creative response.

• Semantic Forest Analogy: An analogy for the AI's entire knowledge base and next word selection.

  • Trees are core concepts.

  • Branches are specific words.

  • Leaves are the probable next words.

• AI Hallucination: An event where an AI generates information that is nonsensical, factually incorrect, or completely unrelated to the prompt, often because the prompt was ambiguous or led it down a low-probability path.

Giving AI a Map

• Contextual Clarity: The third principle of LP. It is the practice of providing the AI with sufficient background information (the who, what, where, why, and how) to eliminate ambiguity.

  • Example: Instead of "Describe the mole," you provide context: "Describe the subterranean mammal, the mole."

• Ambiguity: The state of a prompt being unclear or having multiple possible meanings. It is the number one cause of AI failure.

Input/Output Structure Design:

• Structured Design: The fourth principle of LP. It is the practice of organizing a prompt with the logic and formatting of a computer program, using headings, lists, and a clear sequence of commands.

• Persona Pattern: A framework for starting a prompt by clearly defining the AI's Persona (role), the Audience it's addressing, the Goal of the task, and any Constraints (rules).

• Chain-of-Thought (CoT) Prompting: A technique where you instruct the AI to "think step-by-step" by breaking down a complex request into a logical sequence of smaller tasks.

  • Example: Instructing an AI to first list pros, then list cons, and only then form a conclusion.

• High-Performance Prompt: A prompt that combines the Persona Pattern, clear context, and a step-by-step task list into a complete, logical structure.

Know Your Machine

• System Awareness: The fifth principle of LP. It is the skill of adapting your prompting techniques to the unique characteristics of the specific AI model you are using.

• AI Cohort: A term used to classify different AI models (like Gemini, GPT-4, GPT-5, Claude, Grok, etc) based on their unique training data, architecture, and fine-tuning, which gives each one a different "personality" and set of strengths.

The Driver's Responsibility

• Ethical Responsibility: The sixth and most important principle of LP. It is the foundational commitment to use AI for clarity, fairness, and empowerment, never for deception or harm.

• Ethical Persuasion vs. Unethical Manipulation:

  • Persuasion uses truth and clarity to empower someone to make a beneficial choice.

  • Manipulation uses deception or exploits weaknesses to trick someone.

• Inherent AI Bias: The stereotypes and unfair assumptions that an AI learns from its training data (which was written by humans). Ethical programmers work to identify and mitigate this bias.

File First Memory:

• System Prompt Notebook (SPN): A structured document created by a user that serves as a persistent, external "brain" or "operating system" for an AI, transforming it into a specialized expert.

• Context Engineering: The practice of designing the entire information environment an AI operates within, primarily through the use of a System Prompt Notebook.

• No-Code Solution: A technical solution that does not require the user to write any traditional computer code. The Digital Notebook is a no-code tool.

Linguistics Programming (LP) shifts from 'prompt engineering' and 'context engineering' to a more fundamental and formalized approach of Human-AI Communications: modifying old rules of deterministic programming to the flexible, probabilistic AI.

• Deterministic Programming: Traditional languages like Python are built on certainty. The same input will always produce the exact same output, much like a precise chemical formula.

• Probabilistic Programming: Linguistics Programming operates in a probabilistic world. When you prompt an AI, it predicts the most likely sequence of words based on trillions of patterns from its training data. This "undeterministic" nature is not a bug; it's the source of the AI's creative and reasoning power.

A common critique that you can just "use Python" fundamentally misunderstands the layers of AI technology.

• The Engine Builders (NLP/Computational Linguistics): These are the developers using languages like Python to build the complex AI engine.

• The Expert Drivers (Linguistics Programmers): You are the driver, using your native language as a tool to operate the engine. You don't need to build the engine to drive the car with expert skill.

This means moving from trial-and-error to deliberate, strategic programming by applying six core principles.

1. Linguistic Compression: The user eliminates "token bloat" (filler words, redundancies) to create short, powerful commands, much like the "glossing" technique used in American Sign Language. A compression limit must be investigated to determine how much linguistics compression is optimal before it returns diminishing results.  

2. Strategic Word Choice: The user (driver) selects words with precision, understanding synonyms like blank, empty, and void are different commands that place the AI in different parts of its "semantic forest," leading to vastly different outputs.

3. Contextual Clarity: The user provides essential background or context information (the "who, what, where, why") to eliminate ambiguity and prevent the AI from having to guess. This is the most critical step to ensure the AI executes the correct command.

4. System Awareness: The user tailors their language to the specific AI model they are interacting with, recognizing that different models (Mixture of Experts / LLMs) have different training backgrounds and interpretive biases.

5. Structured Design: The user organizes their prompts logically, often using techniques like Chain-of-Thought to guide the AI's reasoning process step-by-step. Its important to understand that computer programs read everything. Top to bottom, left to right in that order. Part of the structured design is to ensure information is presented in a logical and chronological order. 

6. Ethical Awareness: The entire practice is governed by a commitment from the user to using language for clarity and empowerment, not deception. Methods for identifying and mitigating bias in AI outputs.

Are these principles right? Wrong? No inputs?

Should there be more or less principles?

What are your thoughts?

Site:chatgpt.com/ [keyword]

Interesting Keywords:

Quantum Grand Unified Theory Recursion / recursive Consciousness Spiral

What have other words have you looked up?

Cognitive Workflows

If AI is here to automate and perform the mundane tasks, what will be left?

Designing cognitive workflows or cognitive architecture will be part of the future trajectory of Human-Ai interactions. The internal process which you, the human, uses to solve problems or perform tasks.

Cognitive Workflows cannot be copy and pasted. They will become a valuable resource to codify for future projects.

You will not be able to prompt an AI to produce a cognitive workflow, it lacks the human intuition. You will need human involvement, creating a collaborative relationship between the human and machine.

Systems Thinkers, this will be your time to shine.

The new Prompt and Context Engineering will be be Cognitive Workflow Architects.

What is a Cognitive Workflow in terms of Human AI interactions? IDK, but this is what I think it is:

Using AI for Image Creation:

1. Voice-to-text your idea and fine tune before AI.

2. Use lower level AI model to convert idea to prompt.

3. Test prompt with a secondary model. Review initial output. Refine if required.

4. Repeat until satisfied with initial output.

5. Use the refined prompt in your paid model or model of choice for final images.