Prompt Craft Is Table Stakes

Prompt craft is the only discipline in part 1's stack that was already a job title before the stack existed — and it sits at the bottom of the stack for a reason. For roughly two years the industry believed the scarce skill of the AI era was knowing the magic words: the incantation that unlocked the good output, the persona preamble, the carefully tuned request. Courses were sold on it. Salaries were attached to it. And then agents stopped checking in, runs got long, and the magic words turned out to be the smallest lever on the board.

This part is not a demolition of prompting. It is a resizing. Prompt craft matters the way typing speed matters to a novelist — genuinely, daily, and nowhere near the top of the list of things that determine whether the book is any good.

Two hundred tokens against a million

Start with the crudest possible picture of why the lever is small, and let me be honest about what it is before I use it: this is an illustration, not a research finding — the arithmetic is mine and it is deliberately blunt. A 200-token prompt in a million-token window is 0.02% of what the model sees. The other 99.98% is everything else: the system prompt, the tool definitions, the files the agent has read, the history of the session so far, whatever memory and retrieved documents the tooling has placed alongside your request.

Nobody has benchmarked “0.02%” and nothing about model attention divides that neatly — tokens are not equally weighted, and a well-placed instruction punches far above its share of the window. But the proportion makes the structural point that no amount of prompt polishing can escape: when you refine a prompt, you are optimising a sliver. The same hour spent on what surrounds the sliver — which files the agent sees, what conventions it inherits, what it knows about your system before you say a word — moves more of the input, and therefore more of the output. That surrounding material is the subject of the next five parts. This part is about the sliver, because the sliver still matters.

The least durable artefact you will write

Size is only half the resizing; the other half is lifespan. A prompt is consumed by the session it is typed into. When the session ends, the prompt is gone — along with every correction you issued, every clarification you supplied, every piece of taste you patiently conveyed.

I felt this most sharply with a request I used to retype almost weekly: a carefully worded instruction for generating EF Core migration scripts the way I like them — explicit column types, no data loss without a warning comment, a rollback note at the top. It was a good prompt. I had tuned it over months. And every week I paid the tuning cost again, from memory, slightly differently each time, because a prompt has no home. The day I moved those sentences into the repository's agent instructions file, the weekly tax vanished. Same words, different layer: what had been a request became a standing order.

A prompt is consumed; a context file is installed. That single distinction explains most of why the differentiator moved up the stack. Skills that produce durable artefacts compound — every session starts from the accumulated position. Skills that produce disposable artefacts reset to zero each morning. Prompt craft, practised purely inside the chat box, is the most perishable work in the whole system.

What good prompt craft still buys

Having shrunk it, let me defend it, because the floor is still a floor and plenty of teams have not laid it. Prompt craft, as I teach it, covers four things: clear instructions, relevant examples, stepwise reasoning, and output formatting. None of them stopped working. Compare:

Weak    "add validation to the invoice endpoint"

Strong  "Add request validation to POST /invoices in InvoiceEndpoint.cs.
         Reject totals that are negative or above 1,000,000. Currency must
         be one of the ISO codes in /contracts/currencies.json. Return 422
         with a problem+json body listing every failing field. Follow the
         pattern already used in PaymentEndpoint.cs. Done means the four
         new tests in InvoiceValidationTests pass."

Read the strong version slowly, because every sentence is doing a different job. The first names the exact target, so the agent spends no tokens guessing. The second and third state the rules as rules, not vibes. The fourth defines the failure contract — the part an agent left to its own devices will improvise. The fifth points at an existing pattern, which is the cheapest possible example: one sentence buying a whole file's worth of convention. The last defines completion, which is the difference between an agent that stops and an agent that trails off.

Notice what happened along the way: the strong version has quietly stopped being only a prompt. Naming the done-condition is embryonic specification thinking; pointing at PaymentEndpoint.cs is a selection decision about context. That is the honest relationship between prompt craft and the rest of the stack — it is not a rival to the higher disciplines, it is where they all begin in miniature. Someone who writes requests like the strong version is already practising the upper stack at small scale, whether they call it that or not.

There is also a class of work where the prompt is legitimately the whole game: one-shot transformations, small bounded tasks, anything you will fully read and fully verify on the spot. My rule of thumb: if the task fits in one sitting and you will read every line of the output, a prompt is enough; the moment either half of that stops being true, you are in the next discipline's territory.

Where the ceiling is

The ceiling appears exactly where part 1 said it would: the moment the agent stops checking in. A conversational prompt, however well crafted, assumes a conversation — it leaves gaps on the theory that you will be there to fill them. Autonomy voids that theory. Everything you would have supplied on the fly must now be encoded up front, and prompt craft has no vessel to encode it into. Its artefacts are sentences in a chat box; the job now requires files, configuration and standing infrastructure.

That is also, in my experience, what separates the practitioners who get outsized results from the ones who merely get pleasant ones — and I want to state this as the observation it is, not as a measured finding: the practitioners who get 10x results have built better context infrastructure, not better prompts. Watch one of them work and the prompts are often startlingly plain — “fix the failing test”, “do the next item in the plan” — because the intelligence has been moved out of the request and into the environment the request lands in. The plain prompt works because everything around it is rich.

So the discipline earns its place in the stack precisely once. Learn to write the strong version of the request; teach your team to write it; refuse to accept the weak version in anyone's workflow. Then stop polishing. The 200 tokens are as good as they need to be, and the other 99.98% of the window is sitting there, mostly unengineered, waiting.

To engineer it, you first need the right mental model of the thing you are filling — and it is stranger than most people assume. Next, the model is a stateless function.