Prompt · Context · Loop · Harness · Chart · Skill

The frame
keeps zooming out.

Six labels, one direction of travel. Every few months the working unit of AI engineering gets larger: from one sentence, to one context window, to one loop, to the whole program around the model. Two of the six are not layers at all. They are the ways the system gets drawn and packaged so somebody other than you can use it. None of the older layers went away. They just stopped being the whole job.

Field guide Timeline 2020 to 2026 Six disciplines Dates are approximate

Nested scopes

CHART / plan view SKILLS LOADED ON DEMAND HARNESS / what it can do LOOP / what happens next CONTEXT / what it can see PROMPT / what you say

Pick a layer

The four solid frames contain each other, inner to outer, in the order the industry learned to name them. The two dashed elements are not layers: they cut across the whole thing.

Idle

When each label landed

The vocabulary lags the practice by about a year.

People were doing all six of these before anyone agreed on names for them. The bars below mark roughly when each term went from niche jargon to something you would hear in a normal meeting. Pale end means early circulation, solid end means broadly understood.

Layer2020202120222023202420252026
Prompt
Context
Loop
Harness
Chart
Skill

Dates are judgement calls, not citations. "Entered the zeitgeist" here means the point where you could use the term with a colleague and not have to define it.

The six, in detail

What each one actually controls.

The first four are concentric, not competing. A problem at an outer layer cannot be fixed by working harder at an inner one, which is the single most common waste of time in this whole field. The last two are not layers. They cut across the stack: one is how the system gets represented, the other is how a capability gets packaged.

Scope: one message

Prompt engineering

Shaping the instruction itself. Role, task, constraints, output format, worked examples, and the reasoning scaffolds that get a model to think before it answers.

Entered the zeitgeist
2020 to 2021 in research circles, around GPT-3 and early work on "prompt programming." Went fully mainstream December 2022 through 2023 after ChatGPT, complete with a brief and slightly silly market for "prompt engineer" job titles.
Core moves
Few-shot examples, chain of thought, explicit output schemas, negative constraints, role framing, delimiters, self-checking instructions.
few-shotCoToutput schemaCO-STAR
Failure mode
Endlessly rewording an instruction when the real problem is that the model cannot see the information it needs. That is a context problem wearing a prompt costume.
Status in 2026
Quietly essential, loudly unfashionable. Models follow intent far better than they did in 2023, so the returns moved outward, but a sloppy instruction still poisons everything downstream.
Scope: one model call

Context engineering

Deciding what is in the window at the moment of inference. Your prompt is one item in that window. Retrieval results, file contents, prior turns, tool output, and system instructions are all competing for the same finite attention.

Entered the zeitgeist
Practice starts with retrieval augmentation around 2020 and long-context models in 2023 to 2024. The label itself caught fire in mid-2025, when builders started arguing publicly that it was the better name for what they had been calling prompt engineering all along.
Core moves
Just-in-time retrieval instead of preloading, compaction and summarization, trimming tool output, persistent memory files, deliberate ordering, and treating tokens as a budget rather than a limit.
RAGcompactionmemory filestoken budget
Failure mode
Stuffing the window because it is large. Attention dilutes, the middle gets ignored, and quality drops as the context grows. More visible information is not more usable information.
Relation to prompt
Strictly contains it. Prompt engineering asks what to say. Context engineering asks what should be on the desk while it is said.
Scope: many calls over time

Loop engineering

Control flow. What triggers a turn, what the model does with the result, when it tries again, when it stops, and who gets asked before anything irreversible happens.

Entered the zeitgeist
The pattern is old: reason-and-act agent loops date to late 2022, and the 2023 wave of autonomous agent demos taught everyone what an ungoverned loop looks like. As a named discipline it is a 2025 to 2026 thing, still mostly folklore rather than textbook.
Core moves
Stopping conditions, verification steps the model cannot skip, retry and escalation policy, turn and cost budgets, when to compact, when to spawn a subagent, human checkpoints, and a written definition of done.
stop conditionsverify stepbudgetshandoff
Failure mode
Two opposite ones. Loops that never terminate and burn tokens confidently going nowhere, and loops that terminate the moment the model claims success without ever checking.
Relation to context
The loop is what mutates the context between calls. Every iteration is a decision about what to keep, drop, or fetch, which makes loop design and context design almost the same conversation.
Scope: the whole program

Harness engineering

The software the model runs inside. Tool definitions, permissions, sandboxing, file access, state and logging, subagents, and the interface a human uses to watch and interrupt.

Entered the zeitgeist
The word is borrowed from evaluation harnesses, around 2021, where it meant the rig that runs a model through a benchmark. It slid across to mean agent scaffolding during 2024, and became common vocabulary in 2025 once agentic coding tools made it obvious that identical models perform very differently in different rigs.
Core moves
Tool design and naming, error messages written for a model to read, permission gates, sandboxes, durable state between sessions, observability, and giving the model a way to verify its own work such as tests or a linter.
tool designpermissionssandboxobservability
Failure mode
Blaming the model. Vague tool descriptions, silent failures, and no feedback signal will make any model look incompetent, and no amount of prompt polish will rescue it.
Relation to loop
The harness is the machine, the loop is the program running on it. The harness sets what is possible, the loop decides what actually happens.
Scope: the system, seen from above

Chart engineering

Diagramming the workflow. Turning an agent system into nodes, edges, branches and states so a human can reason about it, argue with it, and hand it to someone else.

Entered the zeitgeist
Be honest about this one: it is the least settled label of the six and you should not assume a colleague knows it. The practice is real and older than the name. Visual workflow builders arrive 2023, graph-based agent frameworks make the diagram the actual runtime in early 2024, and text-based diagramming as a design artifact becomes routine through 2025 and 2026.
Two flavours
Descriptive: a drawing of a system that exists in code, used to explain and review it. Prescriptive: a graph that is the system, where the diagram compiles and runs.
mermaidstate graphDAGvisual builders
Failure mode
Diagram rot. A beautiful chart that stopped matching the running system three commits ago is worse than no chart, because people trust it.
Why it sits outside
It is not a layer in the stack. It is the map of the stack, so it cuts across all four. The moment a system has more than one branch or handoff, the chart is where design disagreements surface before they get expensive.
Cross-cutting: a capability, packaged

Skill engineering

Turning a procedure you keep re-explaining into a portable unit: a folder holding instructions, reference files, and sometimes runnable scripts, pulled in only when the task matches.

Entered the zeitgeist
Precursors go back to shared prompt libraries and configurable assistants in 2023. As a portable, file-based, model-loadable format it is a late 2025 arrival, spreading through 2026. "Skill engineering" as a phrase is newer and less settled than any of the other five, so expect to explain it.
Core moves
Writing the trigger description so it fires on the right tasks and stays quiet on the rest, keeping the body short and pointing outward to reference files, bundling scripts so the model runs a known-good routine instead of improvising one, and versioning the thing like code.
trigger descriptionprogressive disclosurebundled scriptsversioning
Failure mode
Two of them. A skill that never fires because the description does not match how anyone actually phrases the request, and skill sprawl: forty overlapping folders, none maintained, quietly contradicting each other.
Why it sits outside
Mechanically it is a context engineering technique, since the whole point is keeping instructions out of the window until they are needed. But it depends on the harness to discover, rank and load it, and it is authored once and reused across many loops. That makes it a delivery mechanism rather than a layer.

How they connect

One turn, six owners.

Follow a single agent turn from left to right and every discipline shows up exactly once. This is the clearest way to see that they are not alternatives to each other. Prompt and skill both feed the context step, which is the tell that skills are a packaging decision rather than a new scope.

CHART: THIS WHOLE PICTURE, DRAWN ON PURPOSE HARNESS: TOOLS, PERMISSIONS, STATE, LOGS Assemble context RETRIEVE · TRIM · ORDER Model call THE ONE PART Tool calls YOU DEFINED THESE Verify or stop DONE? OR AGAIN? LOOP: NOT DONE, GO AGAIN WITH WHAT WE LEARNED PROMPT SKILL
Prompt Context Loop Harness Chart Skill
PromptWhat you sayOne message
ContextWhat it seesOne call
LoopWhat happens nextMany calls
HarnessWhat it can doThe program
ChartWhat it looks like from aboveCross-cutting: the map
SkillWhat it already knows how to doCross-cutting: the package

Cheat sheet

Side by side.

LayerUnit of workQuestion it answersRoughly when namedFails as
PromptOne messageHow do I ask?2020, mainstream 2023Vague or overloaded instruction
ContextOne callWhat should it see?2024, mainstream 2025Overstuffed window, diluted attention
LoopA runWhen does it stop?2025, still informalRunaway loop or premature success
HarnessThe programWhat can it touch?2021 in evals, 2025 in agentsBad tools, no verification signal
ChartThe systemCan someone else follow it?2024 to 2026, unsettledDiagram drifts from reality
SkillA capabilityCan we reuse this?Late 2025, newest labelNever fires, or fires constantly

Which layer is your problem?

Most complaints are aimed one layer too far in.

The symptom usually shows up at the prompt, because that is where you are typing. The cause is usually further out.

It ignored the thing I told it three messages ago.

Context. The instruction is probably still technically in the window and functionally invisible. Move it somewhere durable rather than repeating it louder.

It says it finished but nothing actually works.

Harness. There is no way for it to check. Give it a test, a build step, a linter, anything that returns a real signal instead of its own opinion.

It went off for twenty minutes and produced a mess.

Loop. No stopping condition and no checkpoint. Decide up front what done means and where a human gets a look.

The output format is wrong every time.

Prompt. This one really is the prompt. Show an example of the exact shape you want rather than describing it.

Nobody else on the team can run this thing.

Chart. The system exists only in your head and in scattered files. Draw it, then keep the drawing next to the code so it rots slower.

It keeps picking the wrong tool.

Harness. Tool names and descriptions are prompts too, and they are usually the worst written prompts in the system.

I paste the same four paragraphs into every session.

Skill. That procedure wants to be a file with a trigger on it, not muscle memory. If two people are pasting it, it definitely wants to be a file.

I wrote a skill and it never gets used.

Skill. Almost always the trigger description, not the body. Write it in the words people actually type, and name the cases where it should stay quiet.