The earliest prompts felt like questions.
Write this paragraph.
Summarize this report.
Give me five ideas.
The exchange was temporary. A person asked. A machine answered. The words disappeared into the conversation once the task was complete.
That is no longer the system we are building.
An agent may now read a customer record, interpret a policy, choose a tool, calculate an adjustment, update a database and decide whether the situation requires a human. The prompt surrounding that agent is not merely asking for language.
It is establishing authority.
It defines which evidence can be trusted. Which actions are permitted. Which uncertainties require escalation. Which objectives matter most. Which failures are acceptable. Which rules override the others.
The prompt is becoming policy.
The sediment of good intentions
One of the demonstrations in Anthropic's prompting workshop begins with a customer-support system that has gradually become less reliable.
The problem is not that it lacks instructions.
It has too many.
At some earlier point, the system gave a customer incorrect information. A defensive rule was added. Then another edge case appeared, so another warning was layered onto the prompt. A calculation failed, producing a new prohibition. A policy changed, but the language preserving the old exception remained.
Every addition made sense when it was written.
Together, they became sediment.
The system began withholding information it could safely provide. It hesitated around trusted customer data. It struggled to distinguish between a prohibition against inventing an answer and permission to use a reliable source already in front of it.
The prompt contained the history of the organization's anxieties but no longer expressed a coherent model of its intent.
This is familiar far beyond artificial intelligence.
Policies accumulate after incidents. Forms collect fields after audits. Procedures absorb exceptions after complaints. Eventually, the original purpose becomes difficult to see beneath the controls designed to protect it.
We often call this bureaucracy when humans do it.
When it happens inside an AI system, we call it prompt engineering.
A small institution made of words
A production prompt increasingly resembles a small organization.
It has a mission.
It has policies and prohibitions.
It has access to records.
It has designated tools.
It has escalation paths.
It has ideas about what counts as success.
It also carries the same possibility of institutional contradiction.
"Be helpful."
"Never make assumptions."
"Resolve the customer's problem."
"Do not act without certainty."
"Be concise."
"Explain your reasoning."
Each instruction may be defensible by itself. But the system must still decide what to do when they collide.
The model does not receive intention directly. It encounters a constructed environment of words, examples, tools, records and prior interactions. Anthropic describes this larger design problem as context engineering: not merely composing the right instruction, but curating the total informational state from which the model will act. That state can include system instructions, tools, external data, message history and connections to other systems.
The prompt is therefore only one layer of the institution.
The context is its world.
No instruction can replace a missing capacity
A striking lesson in the video is how often people try to solve capability problems with stronger wording.
When a model performs a calculation unreliably, we tell it to be more careful.
When it cannot retrieve current information, we command it not to hallucinate.
When it loses track of a long workflow, we add several paragraphs urging it to remain organized.
But insistence does not create machinery.
A person cannot become an accountant because someone adds ALWAYS CALCULATE ACCURATELY to the employee handbook. The person needs methods, records, software and checks.
Models are no different.
When the task requires exact arithmetic, give the system a calculator. When it requires current records, connect the records. When it requires an action, provide a narrowly designed tool. When it needs to recover from an error, allow it to inspect the result and try again.
The prompt can direct capability.
It cannot manufacture capability that the surrounding system does not possess.
This is one reason Anthropic advises builders to begin with the simplest workable architecture and add agentic complexity only when it measurably improves the result. A single model call, retrieval or a predefined workflow may be more dependable than an autonomous agent for a well-bounded task.
More intelligence is not always the answer.
Sometimes the system simply needs a better-shaped hand.
Evaluation is how intention becomes visible
A prompt can sound excellent and still behave badly.
This is one of the conceptual difficulties of working with language models. The instructions are legible to us, but their operational consequences appear only when the system encounters actual situations.
A beautifully written policy does not prove that the institution works.
It must be observed under pressure.
That is the role of evaluations.
A useful evaluation set contains representative tasks, expected outcomes, difficult edge cases and known failure modes. Each change to the prompt, tool or architecture can then be tested against the same underlying situations.
Without this, improvement is mostly anecdotal.
Someone notices a bad answer and patches it. Someone else encounters a different failure and adds another rule. The system oscillates between local corrections without revealing whether it is becoming better as a whole.
With evaluations, behavior becomes visible across time.
The builder can ask:
Did the change repair the failure?
Did it damage a case that previously worked?
Did the system reach the correct outcome?
Did it choose the proper tool?
Did it recover when that tool failed?
Did it know when to stop?
Anthropic characterizes evaluations as a way of making behavioral changes visible before they reach users, rather than discovering problems reactively in production.
An evaluation is not merely a test of the machine.
It is a test of whether the organization has explained itself.
The specification beneath the work
Most organizations contain enormous stores of tacit judgment.
An experienced employee knows which database is usually reliable.
A nurse knows which change in condition requires immediate escalation.
A project manager knows when an apparently minor delay threatens the whole schedule.
A customer-service representative knows when following the written policy exactly would produce an absurd result.
These judgments often remain invisible because people carry them.
They live in habit, conversation, professional culture and memory.
An agent cannot inherit that environment merely by being given a job title.
The organization must begin articulating what it previously left unsaid:
What does a good outcome actually look like?
Which sources are authoritative?
Which decisions are reversible?
How much uncertainty is tolerable?
When should the system continue independently?
When should it ask?
When must it stop?
What appears to be a technical exercise in prompting is therefore a deeper exercise in institutional self-description.
The machine forces the organization to encounter the ambiguity of its own instructions.
Agency requires edges
The word agent suggests independence.
But useful agency is not the absence of boundaries. It is the ability to move meaningfully within them.
A system may be permitted to search records but not alter them.
It may draft a response but require approval before sending it.
It may issue a small credit automatically but escalate a larger one.
It may experiment inside a sandbox but not deploy directly into production.
These limits do not diminish intelligence.
They give intelligence a usable form.
Anthropic distinguishes between workflows, where the path is largely predetermined, and agents, where the model dynamically determines how to proceed. Its guidance is to reserve greater autonomy for tasks whose complexity and value justify the additional cost, latency and risk.
The important question is therefore not whether a system is autonomous.
It is whether its degree of freedom fits the consequences of its decisions.
Language enters the machinery
For most of computing history, instructions had to be translated into formal code before a machine could act on them.
Now ordinary language is entering the operational layer.
A sentence can shape a workflow.
An example can establish precedent.
A correction can alter future behavior.
A paragraph can define the limits of an agent's authority.
This is an extraordinary compression of distance between human intention and machine action.
It is also dangerous to misunderstand.
Natural language feels softer than code. It feels approximate, conversational and reversible. But once it governs a system that can take action, its ambiguity acquires consequences.
A phrase such as "never disclose account information" may protect privacy.
It may also prevent the system from answering the account holder's legitimate question.
"Always resolve the issue without escalation" may improve completion rates.
It may also encourage the system to proceed when a person should intervene.
The language is informal.
The effect is infrastructural.
Undersong
The future will not be built by discovering one perfect sequence of words.
It will be built through repeated movement among intention, behavior and revision.
Describe the task.
Observe what the system does.
Identify the failure.
Determine whether the failure comes from the instruction, the available context, the tool, the architecture or the model itself.
Change the smallest appropriate layer.
Test again.
The loop matters more than the incantation.
Anthropic's prompting workshop presents this as an empirical practice for systems that must plan, act and adapt — not as a collection of secret phrases.
That may be the most important lesson in the entire video.
We are not simply learning how to speak more clearly to machines.
We are learning that the systems around us have always been held together by prompts:
Policies.
Procedures.
Job descriptions.
Professional norms.
Exceptions whispered across desks.
Warnings inherited from failures no one remembers.
AI makes those instructions executable.
In doing so, it also makes their contradictions harder to ignore.
The prompt is becoming policy.
And the quality of the machine may ultimately depend on whether we can finally say what we mean.
Core Pattern When natural language governs systems that can act, it stops being a request and becomes policy — accumulating defensive exceptions like any bureaucracy until the original intent is buried beneath the controls meant to protect it.
What This Alters Building an agent becomes an act of institutional self-description: the machine forces an organization to state the authoritative sources, reversible decisions, tolerable uncertainty, and escalation thresholds it previously left to tacit human judgment.
Resonant Line The language is informal. The effect is infrastructural.
Passages for Transmission
- We often call this bureaucracy when humans do it. When it happens inside an AI system, we call it prompt engineering.
- The prompt can direct capability. It cannot manufacture capability that the surrounding system does not possess.
- An evaluation is not merely a test of the machine. It is a test of whether the organization has explained itself.
Source Anthropic's prompting and agent-building material, including the Code w/ Claude "Prompting Playbook" session, and the engineering essays on context engineering, building effective agents, and demystifying evals.