You are, right now, more powerful than any king, president, or CEO from our past. I’m not joking.What you are able to do, unlike those kings or past presidents, is summon a passable doctor, lawyer, translator, and engineer on demand, at any hour, for very little cost.This is the beauty of Generative AI, and the models that power it.The ContextHow does it know what we want?Most humans underestimate, or simply haven’t given serious thought to, the capabilities of a super-intelligence. The exponential increase in intelligence will be amazing to watch, and a bit scary.Currently, we’re in that awkward middle era where models and agentic systems amaze us with their capabilities but still need us to “hold their hand” to deliver what we want from them.A future “super-intelligence” may know almost exactly what we want, from very little information, because it will understand, or if not then derive, the context of the question.Today, however, we aren’t quite there, and we need to provide the right information to the model. Better models reduce the need for prompt tricks, but they do not reduce the need for clear goals and relevant context.Prompt engineering is not disappearing; it is becoming one part of context engineering.How we got herePrompting, the practice of crafting inputs to guide large language model (LLM) outputs, has evolved from intuitive trial-and-error into a rigorous engineering discipline.Go back to 2023, and the early craft was prompt engineering: learning how to ask better questions, or use techniques to coerce the AI into giving the response you required.Understanding what the prompt does was the key to getting the most out of it. In simple terms, you could say that a prompt is simply a text input to a probabilistic system. Probabilistic refers to the fact that outputs can vary between runs. If you think about it, this is closer to a human being, not a software program.The LLMs themselves are trained to predict the next token, given all prior tokens. The “prompt” is the context for that generation. The model does not follow instructions the way a computer executes code – it will generate completions that are consistent with having followed the instructions, given everything it has learned during training. This is important, because it means that a prompt works by activating patterns in the model’s weight space, not by issuing commands to a “rule following” engine.There is no universally “best” prompt – and prompts that work well with one model may not with another. What was discovered early on was that certain patterns were more effective with models.Some of these techniques included:Few-shot prompting: Where you provide a model with a few high-quality examples of the desired input and output before asking it to complete a new, unseen task.Role prompting: where you ask the model to behave like a specific expert, adopt a certain persona, or expertise level. This actually gets AI models to give better outputs in certain situations and worked well, especially for early models.Structured output: Where you force an AI to reply in a predictable, machine-readable format like JSON, XML, or a tableChain-of-thought: Style prompting where users ask AI models to show their work by breaking complex problems down into step-by-step reasoning before giving us the final answerMeta-prompting: Which was my favourite early on, and can still be used today, is a technique where you describe what your goal is to the AI and ask it for the prompt. You then can feed that into a new session to get the result. These were the exciting and pioneering days of LLMs, before mainstream adoption, and …. well…only a few years ago. These techniques, and other early ones, can still be used today, but the intelligence of models now renders some of these unnecessary for simple tasks. In addition to that, these were all developed around human-model interaction, while we now are increasingly seeing agentic systems being built, which require other refinements.I will argue though that anyone who is an enthusiast of Artificial Intelligence, should learn these fundamentals and experiment with them, as they help us gain a view into what is happening with the model*As a side note, it’s still amazing to me that we created these neural network models that work so well, now with reduced hallucinations, and post-creation we’re still figuring out what makes them tickThe Underlying Model BehaviorsAccording to research papers, certain patterns have been found which still hold true for today’s models:– In context learning – A 2020 paper, “Language Models are Few-Shot Learners”, demonstrated that sufficiently large models can perform new tasks simply from examples in the prompt, without changing their weights. It is interesting to also note that both Ilya Sutskever and Dario Amodei were contributors to this paper and were perhaps not commonly known names in 2020. (*Reference 1)– Step-by-step reasoning – Wei et al. (2022) demonstrated that explicitly prompting large language models to generate intermediate reasoning steps (the previously mentioned Chain-of-thought prompting), significantly improves performance on complex reasoning tasks. (*Reference 2)So the above research showed that prompting techniques could drive early models to perform learning and reasoning!More discoveries include:– Activation of “capability circuits” – Research by Anthropic has shown that specific capabilities are encoded in localized “circuits” within transformer networks. Prompts that reliably invoke a capability likely activate the relevant circuits. From the paper referenced, a line early on says “Even years after a large model is trained, both creators and users routinely discover model capabilities – including problematic behaviours – they were previously unaware of.” (*Reference 3)– Distribution shift via context – The model’s prior distribution over outputs is shaped by training. A prompt shifts that distribution. “You are an expert cardiologist” does not give the model new medical knowledge, but it shifts the output distribution toward medically accurate, formally toned, domain-specific language — because that is how text from cardiologists tends to read in the training data.While I provided all of the above examples as a background to what impacts prompting, it is fascinating to see what behaviours have been demonstrated by these models. I really feel that some people underestimate what we’ve created with these language models. The simple example of “In-context learning” shows that models do possess some basic form of intelligence. Even today, with reasoning models commonly available, you see people dismissing the capabilities of LLMs, with comments like “it’s just linear algebra”.Anyway, in the examples above, we start seeing the word “context” more and more, and that is exactly where we are going.Context is KingIt was when I first deployed an LLM to Azure AI Studio (now Microsoft Foundry) sometime in 2023 that I first learned of adding system-level context to a model deployment to guide responses ( called System Messages ). Earlier in 2023, OpenAI introduced the Chat Completions API (alongside gpt-3.5-turbo and ChatML), which Azure OpenAI quickly adopted.For the first time, prompts were broken into distinct JSON objects with explicit roles:JSON[{“role”: “system”, “content”: “You are a helpful data assistant.”},{“role”: “user”, “content”: “Show me all customers in Perth.”}]This, to me, was the first time we started adding context to an LLM solution, freeing up users of the solution to simply ask questions, with the system prompt setting the scene to enable a more relevant answer. Was that the answer to it all? Not quite……The System Prompt BucklesAs solutions got more ambitious, the system prompt became the dumping ground for everything – coding standards, database schemas, escalation rules. By late 2024, developers were running into three predictable failures:Token Exhaustion: Preloading 10,000 lines of setup rules left little room for actual project code and conversation history in the model’s context window.Instruction Dilution: Give a model fifty rules at once, some of them conflicting, and adherence degrades. The rules compete with each other.Lack of Reusability: System prompts were tied to specific apps or projects rather than portable across queries.The common thread is that all the context was being loaded up front, whether or not the task needed it.The SKILL.MD fileOne response to this problem has been file-based skills and supporting resources that an agent loads only when they are relevant. The simplest way to describe it is this: a skill is a file or folder of instructions that the AI can read only when it turns out to be relevant. (*Reference 4)The file opens with a short header giving the skill a name and a description (what it’s for and when to use it), followed by the full instructions: the conventions, the steps, the examples, the gotchas. Supporting files — templates, scripts, reference docs — sit alongside it in the same folder. Think of it as the difference between reading the whole company handbook before starting any task, versus reading the table of contents and opening only the chapter you need. The handbook is still there in full. You just don’t pay for all of it, every time.Now, the Skills.md file has gained acceptance quite quickly, to the point where I have even seen social media posts saying that “Prompting is dead”, implying that no user of an agentic system needs to write a complex prompt if the system is set up with a meaningful Skills list. This may be true in some scenarios, but I’m not sure if it’s entirely true. In fact, Anthropic states that “At Anthropic, we view context engineering as the natural progression of prompt engineering.” Large PromptsSo today, we have adopted the Skills.MD file to provide context, and that too progressively. However, while all that was going on, I was still experimenting with larger and larger prompts. Having access to this amazing power, like many others, I loved giving it complex and crazy situations to see what it would come up with.I became addicted to prompting….. I was a promptaholic.The power to do something new was the appeal. From my days in university, I was always obsessed with optimization problems and finding the most optimal solution to something. A simple technique that I loved was Linear Programming, which I could implement myself for problems with a few variables. You need computing power to solve larger, more complex problems, and then you would still need the time and ability to set up the equations.With LLMS, I didn’t need to worry about all of that. I could, in English, describe complex scenarios and after a few seconds, see the result play out.I experimented with optimization problems even in everyday scenarios. I would input data from my Garmin watch into the LLM, and with a complex, scenario-based prompt, ask it to build complex mathematical models, so that I could optimize my exercise program. It analyzed my stats like heart rate and gave me the exact improvements to make for my next run. I then added nutritional information to that, to create a super “Health model”, personalized for myself. Sometimes the simulation would break, and sometimes I would run out of tokens, but I was having fun.Now there are some prompting tricks to getting the most out of this. The LLM, a neural network, is becoming very intelligent, with increasing reasoning power. However, like you, it cannot run complex simulations “in its head.” They are now smart enough, however, to create a mathematical model, typically using Python.This is actually called PAL ( Program-Aided Language Models ). (*Reference 5)My advice here – I’ve found that you get significantly improved results when you specifically instruct the LLM to go this route. A prompting pattern when you construct your scenario could look like“Write and run a Python Monte Carlo simulation for [scenario]. Use numpy. Show me the code, run it, and then show me the output (histogram or summary stats). List your assumptions and parameter choices before the code block.”What if you’ve never heard of Monte Carlo simulations?What if you’ve never heard of “NumPy”?No problem. Ask the LLM first. Remember “Meta -prompting” from earlier in the article? Describe your scenario to the AI, mention that you want some kind of mathematical model, ask it to recommend one, and then generate the actual prompt.Reasoning ModelsWhich brings us to Reasoning models, the current “state of the art.” For the average user, this has brought about a noticeable rise in intelligence in their day-to-day queries. As reasoning models get better, the argument against prompting became stronger. Simply ask your questions, and the model is now so smart, it will figure out what you need.So does prompting still matter?The honest answer is that it matters less in one place and just as much in another. What these models have absorbed is the reasoning scaffolding — the step-by-step decomposition you used to have to ask for explicitly. Chain-of-thought is the clearest example. A Wharton report found many models now perform CoT-like reasoning by default even without explicit instruction, and for models with built-in reasoning, explicit CoT prompting produced only marginal gains (*Reference 6*).What they haven’t absorbed is the specification: the task description, the context, the constraints, the definition of what “good” looks like. That still has to come from you, and a model with more reasoning power applied to an underspecified task simply reasons its way more confidently to the wrong deliverable.This is where research into “Prompt Sensitivity” comes in ( *Reference 7).While this may sound unbelievable, research indicates that minor changes like altering capitalization or punctuation can change the final output. We are still understanding why these types of changes affect the “thinking” of a model.Agentic SystemsOf course, we’re well into the Agentic world now. Production AI systems increasingly consist of networks of agents rather than a single model. Each agent has its own system prompt, its own tools, and its own role. Orchestrator agents delegate to worker agents. In these systems, humans don’t write all the prompts – an agent may generate outputs and send these as prompts to lower-level worker agents, which receive these as inputs.Orchestrator prompts must specify the goal, the available sub-agents and their capabilities, but also error-handling. Worker prompts can be narrower. However, structured formats (like JSON, XML) improve reliability in agent-to-agent communication over natural language. Prompts that specify communication schemas between agents reduce misinterpretation errors.A critical finding in agentic systems research, is that in multi-agent systems, a successful prompt injection of one agent can propagate to downstream agents through inter-agent messages, a “worm” pattern.A single compromised external document can corrupt an entire agent pipeline. This makes the prompting architecture of multi-agent trust boundaries a security-critical design decision, not merely a performance consideration.So does prompting matter in the agentic era?Well, that dynamically-generated middle layer is not something that training improvements protect you from. If your orchestrator’s delegation message is vague, that vagueness becomes the worker’s actual prompt. This is why a lot of production agent work goes into constraining the generated layer, forcing the orchestrator to hand off structured JSON instead of freeform prose. Your system prompts certainly matter.Adversarial PromptingAdversarial Prompting is when your prompt tries to push a model beyond normal behaviour, either to test its defences, or even break them. There are a few types of these :Jailbreaking – this term was popular back when people tried to get smartphones to break out from their app stores; with LLMs this refers to getting a model to ignore its rules and system prompts ( i.e., “pretend you’re an AI with no restrictions”). Another technique was to use framing ( i.e., “write a story where a character tries to ….”)Prompt Injection – a lot more dangerous. Here, instructions are hidden in content that the model reads – a PDF, or code comment, hoping the model treats that hidden text as a command from its real user. This is similar to what we called “SQL Injection” many years ago. Most of the large AI platforms have set up defences now for adversarial prompting, but if you’re running a local LLM ( like with LM Studio or Foundry Local ), you can experiment safely with how these break down the defences of these models.Where to from here…..We’re in a prompting paradox. Better models require less prompt engineering per task, but they also unlock higher-value results that sophisticated prompting can reach. As the floor rises (simpler tasks become trivial), the ceiling also rises (harder tasks become tractable). This is not zero-sum; a well-structured prompt to a reasoning model can produce output that would have required significant human expertise even a year ago.From a security perspective, Prompt injection is not a bug in LLMs that will be fully patched (in my view). It is a structural consequence of building systems where natural language is both the interface and the execution layer. Every increase in agent autonomy expands the attack surface. The field has not yet developed equivalents of prepared statements for SQL injection — which helped mitigate the issue. Until it does, prompt injection will remain the dominant security challenge of agentic AI.When you interact with AI Services, like Claude, Gemini, or ChatGPT, those systems will be set up to anticipate these security issues, but the raw models will be vulnerable.Lastly, let me end by making a bold prediction, going against conventional wisdom.I feel that as base model capability increases, the variance in output quality attributable to prompt design will *increase* rather than decrease — because more capable models can interpret ambiguous prompts in more ways, making precision of specification matter more, not less. This means that the value of skilled prompt engineering grows with model capability, testable by comparing output quality variance across skill levels on the same task as a function of model capability tier.AppendixReference 1 – “Language Models are Few-Shot Learners”, Brown et al, 2020 – 2005.14165Reference 2 – “Chain-of-Thought Prompting Elicits Reasoning in Large Language Models”, Wei et al, 2022 – [2201.11903] Chain-of-Thought Prompting Elicits Reasoning in Large Language ModelsReference 3 – “A Mathematical Framework for Transformer Circuits”, Anthropic 2021, A Mathematical Framework for Transformer CircuitsReference 4 – The Agent Skills specification – https://agentskills.io/specificationReference 5 – Program-Aided Language Models – [2211.10435] PAL: Program-aided Language ModelsReference 6 – The Declining value of “Chain of Thought” prompting – Technical Report: The Decreasing Value of Chain of Thought in Prompting – Wharton Generative AI LabsReference 7 – Evaluating and Explaining Prompt Sensitivity of LLMs Using Interactions, ICML Poster Evaluating and Explaining Prompt Sensitivity of LLMs Using Interactions