# The Reality of Prompt Engineering | Sherwin Vishesh Jathanna

> Born when GPT-3.5 needed magic words, declared dead when frontier models stopped needing them. What actually remains of the craft, from production system promp…

Source: https://www.sherwinvishesh.com/blog/prompt-engineering-reality  
Copyright 2026 Sherwin Vishesh Jathanna. Text may be quoted with attribution. The design and source code are not licensed for reuse.

By Sherwin Vishesh Jathanna. Published August 3, 2026. 8 min read.

In March 2024, IEEE Spectrum ran a piece titled "AI Prompt Engineering Is Dead" [1]. Two years on, the model companies still publish prompt engineering guides, the most valuable document inside most AI products is still a prompt, and a coding agent will happily burn an hour of compute on a badly written one. So the obituary was half right. A specific era of prompting did die. What replaced it is smaller, quieter, and considerably more important, and the difference is worth tracing carefully.

## The GPT-3.5 era, when wording was everything

ChatGPT launched in November 2022 on GPT-3.5 [2]. The model was astonishing for 2022 and painfully unreliable by today's standards. It lost track of instructions, drifted out of the format you asked for, and reasoned shallowly unless pushed. The prompt was the only control surface you had, so an entire craft grew around holding the model exactly right. The toolkit was real, and most of it came out of published research rather than folklore:

- **Few-shot prompting.** The GPT-3 paper was literally titled "Language Models are Few-Shot Learners": you pasted worked examples above your question because the model performed dramatically better with them [3].
- **Role prompting.** "You are a senior tax accountant with twenty years of experience." Assigning a persona reshaped tone and framing, and on early models it often changed the quality of the answer too.
- **Chain-of-thought.** Wei et al. showed that demonstrating step-by-step reasoning lifted performance on math and logic tasks [4], and Kojima et al. found the shortcut version: simply appending "Let's think step by step" [5].
- **Delimiters and structure.** Triple backticks and XML tags, so the model would stop confusing your instructions with your data.
- **Format pleading.** "Respond ONLY with valid JSON. No commentary." Repeated, capitalized, and still ignored often enough that production code needed retry logic.
- **Decomposition.** Splitting one job across several prompts, because a single call could not hold a multi-step task together.
- **Incentives and emotion.** "This is very important to my career" produced measurable gains in one benchmark [6], and a follow-up study tested 26 prompting principles, politeness and incentives among them [7].

None of this was superstition. The gains were benchmarked and published. By 2024, a systematic survey had catalogued 58 distinct text-based prompting techniques [8], which tells you two things at once: the field was real, and it had become absurd. Nobody should need 58 techniques to ask a question.

## What the models absorbed

Three shifts ended that era. Instruction tuning matured, so models now parse casual, imprecise English and infer what you meant to ask. Reasoning moved inside the model, at least for the reasoning class of models: the deliberate thinking that chain-of-thought used to inject by hand now runs internally before the first visible token, though explicit reasoning cues still earn their keep on smaller models and unusual tasks. And the fragile parts became platform features: structured outputs enforce a schema instead of hoping the model obeys [9], native tool calling replaced copy-pasted context, and long context windows made the summarize-and-stitch dance mostly unnecessary. What they did not remove is the work of deciding what belongs in that window, a point this piece returns to.

Where each GPT-3.5 era technique went:

- **Role prompting ("You are an expert..."):** Rarely needed for competence; still useful for scope and audience
- **"Let's think step by step":** Built into reasoning models that plan before answering
- **Stacks of few-shot examples:** Zero-shot works; one example for genuine ambiguity
- **Format pleading ("ONLY valid JSON"):** Structured outputs enforced at the API level
- **Tips, threats, emotional appeals:** Effects shrank toward zero as models improved

The practical result: for straightforward tasks, the gap between a lazy prompt and a crafted one has nearly closed. You type a vague sentence, you get a solid answer, and often the first response is good enough to use as-is. The gap has not closed everywhere. Ambiguous analysis, transformations with many constraints, and any task where you hold important context the model cannot see still reward careful prompting. But the everyday experience is the first one, and it is the experience behind every "prompt engineering is dead" post.

## What survived

The strategies did not go to zero. They consolidated. Strip the current vendor guidance to its core [10] and what remains is a short list:

1. **Define the task precisely.** What you want, who it is for, and what a good result looks like.
2. **Give clean context.** Everything the model cannot know on its own, and nothing it does not need. Irrelevant context actively degrades output.
3. **Show an example when the task is genuinely ambiguous.** And skip the other four you would have pasted in 2023.
4. **State constraints explicitly.** Length, tone, format, and what to avoid.
5. **Verify the output.** Check the result before you rely on it, especially where you cannot judge correctness at a glance.

That is not a bag of tricks. That is how you would brief a capable colleague, which is exactly the point.

*"Every technique that survived is a form of being clearer. Everything that died was a workaround for models that could not meet you halfway."*

## Where it got serious: prompts inside products

The interesting story is not chat, though. It is what happened inside software. A GenAI product, whether a support bot, a document analyzer, or a code review tool, is a pipeline with a model call in the middle, and at the center of that call sits a system prompt. That prompt is the product's behavior specification: its role, its rules, its tone, its refusal cases, its output schema, its edge case handling.

Getting that prompt right is what prompt engineering means in production, and it looks nothing like typing magic words. You draft the prompt, run it against a suite of real inputs, study the failures, tighten the wording, and run it again. You measure whether the new version fixed the failures without breaking what already worked. You version it, review changes to it, and regression-test it before it ships, because a system prompt serving millions of requests turns one small ambiguity into a support queue. Frameworks like DSPy push this to its logical end and treat prompt optimization as a compilation problem, searching automatically for the prompt that maximizes a metric [11].

A concrete example makes the stakes clear. Suppose a support agent answers 97 percent of routine questions correctly but reads "cancel my order" the same way whether the order has shipped or not. One sentence added to the system prompt, telling it to check fulfillment status before offering a cancellation, fixes that entire class of failure. It may also quietly change how the agent handles refund questions, which is why the evaluation suite runs on every edit. Prompt changes behave like code changes: small, targeted, and capable of breaking something three features away.

The modern twist is how short the loop has become. Frontier models are good enough that a clear first draft often lands close to the target, and iteration is measured in a handful of passes rather than weeks of coaxing. You are no longer fighting the model. You are aligning it with the product, and most of the remaining effort goes into the evaluation set that proves the prompt does what you claim it does.

**In practice:** a production system prompt is a product asset. It gets versioned, tested, and reviewed like code, because a one-line edit to it changes product behavior exactly the way a code change does.

## Agent harnesses, where prompting got harder

The strongest evidence that prompt engineering is alive is the newest category of tools: agent harnesses like Claude Code and Codex, where a model works inside your repository for minutes or hours at a time, reading files, running commands, and editing code.

Two layers of prompting govern every session. The first is the harness's own system prompt, thousands of words defining the agent's tools, safety rules, and working style, written and maintained by the vendor with the care of an API contract [12]. The second layer is yours: the task you type, plus the standing instructions you keep in files like CLAUDE.md or AGENTS.md that load into every session as durable context [13].

That second layer is where the old skill returns with higher stakes. A human colleague fills the gaps in a vague request by asking questions. An agent fills them with assumptions, at machine speed, forty tool calls deep before you notice the drift. The difference between "fix the auth bug" and a paragraph specifying the failing case, the suspected module, the constraint that the public API cannot change, and the command that proves the fix, is the difference between an hour of useful work and an hour of confident wrong turns. The industry's current name for this wider discipline is context engineering: deciding what enters the model's context window at all, not just how the request is phrased [14].

There is a clean inverse relationship here, and it is the piece of this story worth remembering. The better models get, the less your wording matters on any single exchange, because the model repairs small ambiguities on its own. But better models also run longer without supervision, and over a long run the opening specification is most of the steering you get. Every ambiguity in it is multiplied by every step the agent takes. Micro-prompting lost its leverage at exactly the moment macro-prompting gained it: prompting stopped mattering for chat as it started compounding for builders.

## So, is it dead?

As a bag of incantations, yes. The models absorbed it, and nothing of value was lost. As a standalone job title, mostly. The role folded into ordinary engineering work the way "webmaster" dissolved into a dozen specializations. As a discipline, no. It moved into system prompts, evaluation suites, agent instructions, and context design, where it is practiced daily by people who rarely use the term.

The trajectory is the familiar one for abstractions that succeed. The skill did not disappear. It moved up the stack, got renamed, and stopped being visible from the chat box.

**The short version:** casual prompting no longer needs engineering, and production prompting is nothing but engineering. If the prompt serves you, type plainly. If it serves a product or an agent, treat it like a spec: write it precisely, test it against reality, and version every change.

## References

1. IEEE Spectrum, ["AI Prompt Engineering Is Dead"](https://spectrum.ieee.org/prompt-engineering-is-dead), March 2024.
2. OpenAI, ["Introducing ChatGPT"](https://openai.com/index/chatgpt/), November 2022.
3. T. Brown et al., ["Language Models are Few-Shot Learners"](https://arxiv.org/abs/2005.14165), NeurIPS 2020.
4. J. Wei et al., ["Chain-of-Thought Prompting Elicits Reasoning in Large Language Models"](https://arxiv.org/abs/2201.11903), NeurIPS 2022.
5. T. Kojima et al., ["Large Language Models are Zero-Shot Reasoners"](https://arxiv.org/abs/2205.11916), NeurIPS 2022.
6. C. Li et al., ["Large Language Models Understand and Can Be Enhanced by Emotional Stimuli"](https://arxiv.org/abs/2307.11760), 2023.
7. S. M. Bsharat, A. Myrzakhan, Z. Shen, ["Principled Instructions Are All You Need for Questioning LLaMA-1/2, GPT-3.5/4"](https://arxiv.org/abs/2312.16171), 2023.
8. S. Schulhoff et al., ["The Prompt Report: A Systematic Survey of Prompting Techniques"](https://arxiv.org/abs/2406.06608), 2024.
9. OpenAI, ["Introducing Structured Outputs in the API"](https://openai.com/index/introducing-structured-outputs-in-the-api/), August 2024.
10. Anthropic, ["Prompt Engineering Overview"](https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/overview), Claude Documentation.
11. O. Khattab et al., ["DSPy: Compiling Declarative Language Model Calls into Self-Improving Pipelines"](https://arxiv.org/abs/2310.03714), 2023.
12. Anthropic, ["Building Effective Agents"](https://www.anthropic.com/engineering/building-effective-agents), December 2024.
13. Anthropic, ["Claude Code: Best Practices for Agentic Coding"](https://www.anthropic.com/engineering/claude-code-best-practices), April 2025.
14. Anthropic, ["Effective Context Engineering for AI Agents"](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents), September 2025.