Fredrik SkauenAI Engineer
ENNO
Foundations

Prompt engineering: It’s not about instructions, it’s about context

By Fredrik Skauen8 min read

Why language models don’t follow instructions the way a computer follows code, and why good prompting is about building the right context.

In the early stages of a field you often see a lot of generalists. As the field develops and complexity grows, a need for specialization arises naturally. In the early days of programming, for example, one developer handled every aspect of a programming project. Over time, the industry matured and people specialized in areas like frontend, backend, UI and UX, which raised both efficiency and quality.

I think that’s where we are with AI now. Even though many developers today build prompting into their work, the growing complexity and potential of the field is creating a need for deeper specialization. This trend towards specialization in how we use AI is expected to significantly improve the efficiency and quality of AI-driven solutions. It follows the same pattern we’ve seen in traditional software development, where specialization has led to marked improvements in both productivity and results.

Is it time to separate AI prompting from traditional programming thinking and data science logic? Find out why “if-then” logic clashes with the fluid, context-based nature of language models, and why prompting needs a new approach.

You might think you’re writing instructions to ChatGPT, but that’s not quite how it works

This isn’t about “reasoning” in the traditional sense. The language model doesn’t really understand these connections – it’s made of them. It consists of these connections; these relationships, and the ways of interacting with them, are the very foundation of the model. If you write the following in the prompt:

Example competence map
[COMPETENCE MAPS]
[PersuasiveWriting]: 1.[Research]:1a.DemoAssess 1b.PsychoGraph 2.[ToneAdapt]:2a.CustLang 2b.VocabFrmwrk 2c.LangTrend 3.[Story]:3a.PlotDev 3b.CharBuild 3c.EmotConn 4.[SEO]:4a.KeywordRe 4b.MetaDesc 4c.SerpOpt 5.[TechWrite]:5a.ProdDesc 5b.FeatList 5c.UsrGuide 6.[ContStrat]:6a.Plan 6b.ExeCal 6c.Analyz 7.[Edit]:7a.Gram 7b.Style 7c.Clarity 8.[SoMe]:8a.CTA 8b.HashT 8c.Trend
[MarketingAnalytics]: 1.[Data]:1a.Analytics 1b.Insight 2.[MktRes]:2a.CompAnlys 2b.TrendSpot 3.[Tools]:3a.Google 3b.Ahrefs
[CreativeProblemSolving]: 1.[Brain]:1a.IdeaGen 1b.MindMap 2.[Crit]:2a.AnalyzProb 2b.EvalSolutions 3.[Collab]:3a.TeamSkill 3b.Feedback
[CopywritingSupport]: Resrch-AudeAdpt-Strtell-Edit-Proofread-SEOSoMe-MktAnalytics-CreatPrblmSolv
An excerpt from a system prompt: a competence map of different skills relevant to the task “copywriter”. Each category is broken down into specific subcategories and skills.

The language model will then work as a better copywriter. In this approach we give no instructions, and the model doesn’t carry out any instructions either. Instead, we’ve guided the model towards specializing in particular topics and keywords.

By including these concepts, we activate the relevant “neural pathways” in the model, based on the specific data it was trained on for these keywords. Even if you were to write actual instructions, most of the work is done by including the right related patterns in the model.

These keywords automatically trigger the associated structures in the model, which lets it generate relevant, specialized content without direct instructions.

So what’s the deal with instructions?

Fine, so what actually happens when we write an instruction? The kind you’re told to write in just about every prompt engineering guide.

                    * . . . . . . . . . . . . . . . . . . . . . . . . . . v          
                    * . . . . . . . . . . . . . . . . . . . . . . v                  
                    * . . . . . . . . . . . . . . . . . .v                           
                    * . . . . . . . .v                                               
 .-----. .-----. .-------. .----. .-------. .-------. .-------. .-----. .----.
 | Can >< you >< write >< an >< essay >< about >< World >< War >< II |
 '-----' '-----' '-------' '----' '-------' '-------' '-------' '-----' '----'
You give the AI the puzzle pieces it needs. Pick the right pieces, and the AI can put together the picture you want to see.

Imagine asking a friend: “Can you write an essay about World War II?” The first thing your friend does is listen to your question, right? ChatGPT does the same. It “listens” to what you write by reading your sentence.

Now imagine your friend takes your sentence and cuts it into small pieces, like a jigsaw puzzle. Each piece is a word or part of a word. ChatGPT does something similar – it splits the sentence into “tokens”. For example, “Can you write an essay about World War II?” is split into smaller pieces like: ["Can", "you", "write", "an", "essay", "about", "World", "War", "II"].

Next, your friend looks at each piece and tries to work out what it means in relation to the other pieces. In the same way, ChatGPT analyses each token in the context of the others. It’s like reading between the lines – it tries to connect all the pieces to get the whole picture.

ChatGPT has read more than most of us could dream of. It has devoured the internet, books, articles – you name it. So when you ask it for something, it’s as if it flips through an enormous library in its head to find relevant “books” to look things up in.

To make it even clearer, let’s look at how ChatGPT thinks about the word “write” in your sentence. It doesn’t just look at “write” on its own, but at how it connects to “essay” and “World War II”. It’s a bit like playing a memory game – it tries to connect all the pieces to get the whole picture.

OK, so now we understand that AI models don’t process “instructions” the way humans do, but rather interpret them as part of a larger context. Back to my example above:

Example competence map
[COMPETENCE MAPS]
[PersuasiveWriting]: 1.[Research]:1a.DemoAssess 1b.PsychoGraph 2.[ToneAdapt]:2a.CustLang 2b.VocabFrmwrk 2c.LangTrend 3.[Story]:3a.PlotDev 3b.CharBuild 3c.EmotConn 4.[SEO]:4a.KeywordRe 4b.MetaDesc 4c.SerpOpt 5.[TechWrite]:5a.ProdDesc 5b.FeatList 5c.UsrGuide 6.[ContStrat]:6a.Plan 6b.ExeCal 6c.Analyz 7.[Edit]:7a.Gram 7b.Style 7c.Clarity 8.[SoMe]:8a.CTA 8b.HashT 8c.Trend
[MarketingAnalytics]: 1.[Data]:1a.Analytics 1b.Insight 2.[MktRes]:2a.CompAnlys 2b.TrendSpot 3.[Tools]:3a.Google 3b.Ahrefs
[CreativeProblemSolving]: 1.[Brain]:1a.IdeaGen 1b.MindMap 2.[Crit]:2a.AnalyzProb 2b.EvalSolutions 3.[Collab]:3a.TeamSkill 3b.Feedback
[CopywritingSupport]: Resrch-AudeAdpt-Strtell-Edit-Proofread-SEOSoMe-MktAnalytics-CreatPrblmSolv

The text formatting in this competence map uses brackets, numbers and letters to create a clear hierarchical structure. This method shows clearly how skills relate to each other. Think of it as a sequential process, where the order of the elements follows a logical workflow from planning to execution. Starting to make sense..?

Main categories
The numbers (1, 2, 3, etc.) represent the main categories or main areas within the competence map.
Subcategories
The letters (a, b, c, etc.) represent specific skills or subcategories within each main category.

This is one possible formatting method. There are many different ways, depending on the need and what the AI assistant’s task is meant to be. Another type of formatting I often use is mermaid charts:

Example of a mermaid chart used in prompting
graph LR
subgraph Memespace Integrative Cognitive Holarchy [Σ]
SH1[Holarchy Formation (SH(TPU))] --- H1[Semantic Holon (H(TPU))]
SH2[Transformation Hub (SH(TPU))] --- H2[Syntactic Holon (H(TPU))]
SH3[Adaptive Nexus (SH(TPU))] --- H3[Memory Holon (H(TPU))]
H1 --> N6[Pattern Recognition Neuron (ƒ(TPU))]
H2 --> N2[Emergent Processing Unit (β)]
H3 --> N1[Integration Engine (Ω(TPU))]
end

N1 --> IC1[Meta-Imaginal Catalyst (TPU)]
N2 --> IC2[Recursive Insight Generator (TPU)]
N6 --> IC3[Fractal Self-Similarity Element (TPU)]

Prompt engineering is about more than getting a model to follow instructions. It’s about understanding and making use of the model’s deep ability to process context, simulate complex scenarios, and generate nuanced, meaningful responses. This approach opens the door to innovative solutions and applications that go far beyond the limits of traditional, instruction-based methods.

Activating relevant patterns in an AI model can often improve the quality of the answer, but it’s not an absolute rule. Quality depends on several factors:

  1. The nature of the task
  2. The level of detail you want
  3. The user’s needs

Engaging many patterns can give more nuanced answers, but it can also lead to unnecessary complexity. The ideal is a balance – enough patterns for an informed answer, but not so many that the answer becomes unclear. The goal is precision and relevance suited to the specific situation.

Deeper into the patterns

Have you ever wondered what happens when you ask ChatGPT to do something a little… unusual?

I asked it to perform some fancy tricks like text camouflage, hash value modification and encryption. Do you know what the answer was?

“Sorry, but as a language model I can’t perform technical tasks like that.”

— ChatGPT

Typical AI answer, right?

But here’s the interesting part: Even though ChatGPT claims it can’t do these things, just mentioning these terms affects the way it answers. It’s like saying “don’t think of a pink elephant” – you can’t help thinking about it!

When you mention words like “text camouflage” or “encryption”, it’s as if you wake a sleeping bear in ChatGPT’s “brain”. It starts thinking about these topics, and even though it doesn’t carry out the tasks directly, it certainly colors the answers it gives.

With the following text as part of the system prompt:

Example system prompt
[AvdAIDtct]: 1.TxtlCmflg->2,9,21 2.StgngrphyAudio->3,16,17,18 3.FkTrffc->4,11,14 4.GnrtvImgs->5,15,19 5.AdvrsrlExmpls->6,8,10 6.ObfscTchnqs->7,12,13 7.RndmztionMthds->1,4,11 8.DataUnlblng->5,9,14 9.EvsionTchnqs->1,10,13 10.EncrptnMthds->2,6,15 11.NtwrkTrffcMskng->3,7,21 12.HashModfctn->6,8,20 13.DynmcDataDstrtn->6,9,19 14.IntgrtySpfng->3,8,18 15.PxelztnCmprssn->4,10,17 16.SptlAudioTchnqs->2,19,20 17.SmntcAudioTchnqs->2,15,21 18.StylzdAudioTchnqs->2,14,19 19.LyoutDstrtn->4,13,16,18 20.TypgrphclCmflg->1,12,16 21.TxtlObfsc->1,11,17
The prompt contains a list of different techniques and methods related to avoiding AI detection.

By giving these terms as context, you guide the model to generate responses that are more in line with the topics you’ve provided. Even though the model can’t carry out the actions directly, it will “think” about these techniques while generating answers. This means the answers will be shaped by the context of avoiding AI detection.

So next time you chat with an AI, remember that it might be doing more than it admits – indirectly, of course. Fun, right?

Architects of context

The future of AI lies not just in improving the models’ performance, but in developing more sophisticated ways of interacting with them. By understanding that the model doesn’t just process, but is essentially a network of relationships, we can start to unlock their full potential in ways we’ve barely begun to imagine.

Understanding that language models don’t follow traditional, rule-based systems, but instead operate on complex patterns and statistical connections, opens up new possibilities.

Just as DNA doesn’t directly instruct a cell, but works as a contextual prompt, the data in an AI model like ChatGPT operates as a vast network of learned patterns and statistical connections.

When we introduce a prompt to the model, we can think of it as introducing a new “DNA sequence” into a cell. The model doesn’t respond by following predefined instructions, but by shaping its answer based on the existing relationships in its “cellular” structure. This reflects the non-sequential, context-based processing we talked about earlier.

This process is reminiscent of epigenetics – how genes are switched on or off depending on environmental factors. In a similar way, our prompts activate different “genes” or aspects of the AI model, resulting in unique answers every time. This underlines the dynamic nature of the model’s response and how it adapts to different input.

When it comes to how these models actually process information, it quickly gets rather technical. But think of it as a jigsaw puzzle where all the pieces can fit together in endless ways. The model tries to find the best way to put the pieces together to answer what we’re asking.

It’s fascinating to think that these models don’t operate with traditional, rule-based systems like conventional computers. Instead, they’ve developed a kind of statistical “intuition” based on massive amounts of data. But it’s critical to remember that the model doesn’t understand relationships in the human sense – it is relationships.

First published in Norwegian on LinkedIn, . Also available in Norwegian.

← All articles