Why Specification Weighs 22 and Prompt Craft 8

Part 8 argued that the AI era does not retire the software disciplines — it transforms them, and the transformation ends with eight disciplines where the traditional framework had seven. This part goes inside the AI framework and defends its most conspicuous numbers: why Specification Engineering carries 22 points — the heaviest weight in either framework — while Prompt Craft, the skill most people mean when they say “AI skills”, carries 8. It also owns a mistake. The framework document, as I first wrote it, asserts a weight relationship that its own tables contradict, and the truthful version turns out to be more interesting than the tidy one.

Four layers, one apex

The eight disciplines split into a core stack of four and a supporting set of four. The supporting set — Agent Architecture & Orchestration (12), Evaluation & Quality Engineering (10), AI Safety, Security & Governance (8) and Domain Translation & Systems Thinking (7) — operates across the stack rather than inside it, and gets the next part to itself. The core stack, read bottom to top, is Prompt Craft (8), Context Engineering (18), Intent Engineering (15) and Specification Engineering (22).

A note on lineage, because readers of my earlier learning material will hunt for a missing layer. That material described five disciplines: Prompt Craft, Context Engineering, Harness Engineering, Intent Engineering and Specification Engineering. The competency framework has eight, and Harness Engineering is not one of them. It dissolved — the information side of a harness into Context Engineering, the machinery side into Agent Architecture & Orchestration. Nothing was dropped; one discipline was reclassified into two.

The stack is cumulative. Each layer depends on the ones beneath it: a specification is executed inside a context; intent needs information to act on; every layer eventually terminates in instructions a model reads. Skipping a layer produces a recognisable category of failure — technically impressive output that misses the point. But here is the observation the rest of this article hangs on: position in the stack encodes dependency, and weight encodes differentiation — and those two orderings are not the same.

Prompt Craft at 8 — the price of a commodity

Prompt craft is the original skill: synchronous, session-based, individual. Write an instruction, evaluate the output, iterate. Clear phrasing, relevant examples, explicit output formats, knowing when to ask for step-by-step reasoning. It is what prompt-engineering courses teach, and it is genuinely necessary — a practitioner who cannot write a clear instruction in 2027 is functionally impaired, the way a professional who could not send email in 1998 was.

The weight of 8 prices a commodity. Prompt craft was the whole game only while AI interactions were synchronous — while the human sat in the loop being the intent layer, the context layer and the quality layer all at once. That model broke when agents started running unattended for long stretches. Anthropic's agent-autonomy research put a number on the shift: between October 2025 and January 2026 the 99.9th-percentile turn duration in Claude Code nearly doubled, from under twenty-five minutes to over forty-five. When the tool works alone for three quarters of an hour, the wording of the message that launched it is no longer where the leverage lives.

There is a second reason the weight is low, and it is about failure economics. A bad prompt fails in front of you: the output is visibly wrong, and you correct it in the next message. Synchronous failures are cheap. The expensive failures happen in the layers above, where nothing is watching.

Context Engineering at 18 — the other 99.98 per cent

Context engineering is the shift from crafting a single instruction to curating the entire information environment an agent operates within — system prompts, tool definitions, retrieved documents, message history, memory across sessions. Your prompt might be two hundred tokens; the window it lands in might be a million. Your two hundred tokens are 0.02 per cent of what the model sees. The rest is context engineering, whether you practise it deliberately or not.

The weight of 18 reflects where I see the leverage sitting today. The practitioners who get far more out of these tools than their peers are not, in my experience, writing better prompts — they have built better context infrastructure, so their agents start every session with the right conventions and constraints already loaded, and the prompt itself can stay short.

More is not better, either. Anthropic's applied-AI team has documented what they call context rot: as the tokens in a context window grow, the model's ability to accurately recall information from that context drops. The benchmark numbers are sobering — Claude Sonnet 4.5 scored 18.5 per cent on the 8-needle variant of OpenAI's MRCR v2 long-context benchmark at a million tokens of context, a 2025-generation result reported in Anthropic's own system-card tables (successor models have since pushed that variant to around 76 per cent, which tells you how fast the floor moves). A context window is a filing cabinet with no index. Context engineering is the practice of building the index.

Hold on to that 4.50. It matters in a moment.

Intent Engineering at 15 — the Klarna lesson

Context tells agents what to know. Intent tells agents what to want: the practice of encoding organisational purpose — goals, value hierarchies, trade-off thresholds, decision boundaries — into infrastructure an agent can act on.

The cautionary tale I built this discipline around is Klarna. In February 2024, Klarna and OpenAI announced an AI assistant that in its first month handled 2.3 million customer conversations — two-thirds of Klarna's chats — doing the work equivalent of 700 full-time agents, cutting resolution from eleven minutes to under two, with a projected $40 million profit improvement for 2024. The launch release claimed customer satisfaction on par with human agents. Then, in May 2025, CEO Sebastian Siemiatkowski conceded the cost-driven push had produced “lower quality”, and Klarna began rehiring human agents.

My reading — and it is a reading, not a documented root cause — is an intent story. The agent optimised for what it could measure, speed, while the thing the organisation actually valued, relationship quality, was never encoded anywhere the agent could act on it. A human agent with five years at the company knows when to bend a policy or spend three extra minutes; that judgement is institutional knowledge absorbed through osmosis. Agents need it on day one, in structured form. That is what intent engineering builds: value hierarchies that say which objective wins when two conflict, boundaries that say what the agent may decide alone, escalation protocols for everything else.

The sentence my own table contradicts

Version 1 of my framework document says intent engineering “sits above context engineering in the stack and carries a higher weight”. Look at the numbers: Intent is 15, Context is 18. The sentence is false on the framework's own tables, and I wrote both the sentence and the tables.

I am documenting the scar rather than quietly patching it, because the correction forces a distinction the tidy version hides. Intent sits above Context in the dependency stack while carrying a lower weight — because the stack orders what depends on what, and the weights order where deliberate practice pays. Those are different questions with different answers.

The dependency claim is solid. You cannot have good intent alignment without good context — the agent needs information to act on the intent — while you absolutely can have perfect context and absent intent, which is my reading of Klarna: a technically excellent agent systematically eroding an objective nobody had encoded. Intent is the higher layer.

The weight claim is where instinct misleads. Misaligned intent produces the scariest failures — systematic, often invisible until they compound — so surely it should weigh more? But weight, in this framework, is not a fear index. It prices where a practitioner's invested hour differentiates them across a working year. Context engineering is daily work: every session, every task, every agent passes through the information environment, and the artefacts it produces — context files, retrieval designs, memory schemes — are built, tuned and rebuilt continuously. Intent engineering is concentrated work: a value hierarchy or an escalation framework is written rarely, reviewed occasionally, and much of it is organisational rather than individual. Both matter; one simply offers far more occasions to be good at it.

The sub-discipline arithmetic makes the point sharper. Each Context sub-discipline carries an absolute weight of 4.50 — which means the single heaviest rows in the entire framework do not sit in its heaviest discipline. Specification Engineering's five sub-disciplines carry 4.40 each. The apex discipline wins on breadth, not on any single row.

Specification Engineering at 22 — blueprints for absent builders

Specification engineering is the practice of writing documents that autonomous agents can execute against over extended time horizons without human intervention. Not prompts, not context files — specifications: complete, structured, internally consistent descriptions of what the output should be, how quality is measured, what constraints apply and what done looks like. The specification is the prompt now.

The evidence that convinced me this deserves the top weight comes from Anthropic's engineering write-up on long-running agents. Even Opus 4.5, given a high-level prompt like “build a clone of claude.ai”, tried to do too much at once, ran out of context mid-implementation and left the next session guessing at what had happened. The fix was not a better model. It was a specification pattern: an initialiser agent to set up the environment, a feature list of two hundred-plus items each marked passes: false, git commits and a progress file so that every session makes incremental, verifiable progress against a structured plan. The specification became the scaffolding that let multiple agents, across multiple context windows, produce coherent output over days.

The everyday version of the same argument is the 80% problem — my label, backed by an external number: the Stack Overflow 2025 developer survey found 66 per cent of developers cite AI output that is “almost right, but not quite” as their top AI frustration. Almost-right is nearly always a specification defect. The request said “build a login page” when it should have said email-and-password plus OAuth via Google and GitHub, progressive disclosure of two-factor, thirty-day session persistence, rate limiting after five failed attempts. The model did what was asked; the asking was incomplete.

The flat 20/20/20/20/20 split is deliberate: a specification fails if any one of the five is missing, so the framework refuses to rank them. And the skill itself mirrors a transition human engineering made long ago — verbal instructions work for a shed, blueprints are mandatory for a bridge. Describing an outcome with enough precision and completeness that an autonomous system can execute against it for days rewards completeness of thinking, anticipation of boundary conditions and clean decomposition — which is why the people who are excellent at chat-window prompting are not automatically excellent at this.

That is the core stack: a commodity at the bottom, the daily-leverage discipline above it, encoded purpose above that, and the blueprint skill at the apex. Next, the four disciplines that hold the stack steady from the outside: the supporting disciplines.