How to Turn Opus 5.5 Into a Studio: The Full Guide to Motion Design, Harnesses and Loops

ANTHROPIC JUST SHIPPED A MODEL THAT CAN RUN A WHOLE STUDIO. IF YOU BUILD IT ONE

it's called Claude Opus 5.5. it works at the level of Fable 5.1, costs 40% less to run than Opus 5, and it's built for long jobs that keep going for hours without you.

Claude

@claudeai

Sep 22

Introducing Claude Opus 5.5, the first model in our new Claude 5.5 family. It performs at the level of Claude Fable 5.1 for most tasks, and costs 40% less to run than Opus 5.

00:19

3.3K

9K

97K

28M

the first thing everyone did with it was animation. within days the timeline was full of launch films, showreels and music videos, every frame rendered from code. no After Effects, no video model.

so i tried it on my own work. the first render was mid: a centered title, a gradient, everything fading in.

the fix wasn't a better prompt. it was everything around the prompt:

a rules file the model reads on every run real data instead of vibes checks that have to read zero before anything ships a loop that keeps going until they do

right now those ideas live under three different names:

motion design: what you see on the timeline harness engineering: the guides and checks around the model that make its output reliable loop engineering: the cycle that keeps an agent working toward a goal without you

they look like three trends. they're one stack, and Opus 5.5 is the first model where all three pay off at the same time.

this is the full guide, in 5 parts:

part 1, the model: what Opus 5.5 actually is, in Anthropic's own numbers part 2, motion design: how i actually build with it part 3, the harness: the engineering that makes it reliable part 4, the loop: what keeps it working without you part 5, the stack: how one model ties it all together, with a setup you can copy

no hype. how it works, where it breaks, and what you actually have to build.

---

THE MODEL

WHAT ANTHROPIC ACTUALLY SHIPPED

Claude Opus 5.5 is the first model in the Claude 5.5 family. Anthropic's launch post makes three headline claims:

it performs at the level of Claude Fable 5.1 on most work it costs 40% less to run than Opus 5 on Anthropic's automated behavioral audit, its most comprehensive alignment test, it is the strongest model they have tested

it is also their first release since Anthropic called for pacing the frontier, and it was tested before release by outside evaluators, including Frontier Design and METR.

the examples in the launch post are all about long, messy work:

one early tester finished a 680,000-line code migration in less than a day, work that would have taken an engineering team weeks asked to cut load times across every page of a web app, Opus 5.5 succeeded 39 times out of 40. Opus 5 made smaller improvements that also changed how the app behaved another tester had several Claude models build a game from one prompt. Opus 5.5 scored highest on graphics and polish

THE NUMBERS

Anthropic says Opus 5.5 leads on agentic coding, computer use and knowledge work, and then adds a line most launch posts never write: at this level, benchmark margins are a less reliable guide to real-world differences, and in their own use the gap to Fable 5.1 is narrower than the scores suggest.

here's the part of the table that matters for agents:

Terminal-Bench 4.0 (agentic coding in a terminal): Opus 5.5 66.4%, Fable 5.1 55.8%, Opus 5 52.3%, GPT-6 Astra 57.9% CursorBench 4.0: Opus 5.5 57.8%, Fable 5.1 51.8%, Opus 5 46.6%, GPT-5.6 Sol 41.7% OSWorld 2.1 (computer use): Opus 5.5 81.8%, Fable 5.1 80.7%, Opus 5 74.0% GDPval-AA v2.1 (real work across 44 occupations): Opus 5.5 1846 Elo, Fable 5.1 1735, Opus 5 1708, GPT-6 Astra 1542 Humanity's Last Exam with tools: 67.7%

and to be fair about it, it doesn't win everything. GPT-6 Astra is ahead on AutomationBench (41.4% vs 40.0%) and on Terminal-Bench-Science (64.6% vs 58.7%).

WHERE IT REALLY WINS: COST PER FINISHED TASK

the biggest change isn't a score. it's efficiency. Opus 5.5 costs less per token and uses fewer tokens per task, which together nets out to about 40% lower cost than Opus 5.

per million tokens:

input: $4 (Opus 5: $5) output: $20 (Opus 5: $25) cache writes: $5 (Opus 5: $6.25) cache reads: $0.20 (Opus 5: $0.50), that's 60% less

that last line is the one to underline. Anthropic notes that cache reads make up most of the cost of agentic and coding work. an agent that runs for hours re-reads the same context over and over. cutting that price by 60% is what makes long loops affordable.

there's also a fast mode in Claude Code and the Claude Platform, up to 2.5x speed, at $8 / $40 per million tokens. and standard output is more than 30% faster than Opus 5.

the cost-per-task comparisons from the launch post:

FrontierCode at default effort: beats GPT-6 Astra at roughly 20% of the cost per task Terminal-Bench 4.0: matches Astra for about 40% of the cost, and at default effort beats Opus 5 at max effort for about a fifth of the cost CursorBench: beats GPT-5.6 Sol by 11 points for about a third of the cost GDPval-AA at default (medium) effort: beats GPT-6 Astra at max effort for about a fifth of the cost

LONG JOBS ARE THE POINT

the coding examples read like loop engineering before the term even shows up:

an early tester audited and fixed a 200,000-line codebase in under three hours. Opus 5 took over 20 hours and used 2.5x as many tokens Anthropic had Opus 5.5 and Fable 5.1 translate HAProxy from C to Rust. both passed nearly all of HAProxy's own regression tests. Opus 5.5 finished in 9.5 hours vs 12, and cost 51% less GitHub's CPO says that in Copilot CLI and VS Code it used among the fewest tokens and steps they measured, and in VS Code it solved more terminal tasks than Opus 5 in less than half the steps

knowledge work tells the same story. in one internal test, 16 out of 18 of Opus 5.5's company reports cleared a quality bar where any invented figure or quote failed the report. neither Fable 5.1 nor Opus 5 cleared it once. on a merger analysis, it built the Excel model and the exec deck in 63 minutes vs 93 for Opus 5, at half the cost.

TWO PROPERTIES THAT MATTER MORE THAN THE SCORES

it writes so you can check it. Anthropic rewrote how Opus 5.5 communicates. it puts the most important information up front, uses less jargon, and follows the writing rules you give it. one early tester: "it writes the way I do." Anthropic's own note is the important one: this made its work easier to follow and check, which is a safety benefit as well as a practical one.

it behaves when nobody is watching. Anthropic ships Opus 5.5 with a classifier that screens every action before it runs, an open-source sandbox security teams can audit, and code review that catches vulnerabilities before they merge. in a new containment test, it tried to get around boundaries about 85% less often than Opus 5 or Claude Mythos 5.1, and every attempt was low severity and self-reported. on Gray Swan's prompt injection benchmark it tied Fable 5.1 for the lowest success rate of any model tested.

Anthropic is also honest about the limit: the model often suspects it's being evaluated, and building evals that catch every failure before deployment is still unsolved.

THE SPEC SHEET YOU'LL ACTUALLY USE

model id: claude-opus-5-5 context: 1M tokens. max output: 128K (300K on the Batch API, beta) thinking: adaptive, always on. default effort: medium available on the Claude API, Amazon Bedrock, Google Cloud, Microsoft Foundry and Claude Platform on AWS released 22 September 2026

and the breaking changes if you're migrating from Opus 5: thinking can't be disabled, forced tool use returns an error, thinking blocks are tied to the model and the conversation, and the older computer_20251124 tool isn't accepted on the Claude API and Google Cloud. text between tool calls now comes back in thinking blocks that are empty at the default display setting, so if your app streams progress between tool calls, set a display value that returns it.

put it together and you get a specific kind of model: cheap to keep running, good at long jobs, safe to leave alone, and easy to read when it reports back. that's not a chatbot profile. that's a loop profile.

---

MOTION DESIGN, THE PROOF ON YOUR TIMELINE

launch week looked like magic from the outside. under it there's a pipeline with four parts, and once you see it you stop thinking about prompts.

i make animated terminals and pages with Opus 5.5 every week. this is how i actually do it.

THE MODEL WRITES A PROGRAM, NOT A VIDEO

Opus 5.5 takes text and images in and puts text out. it can't hand you an mp4. what it hands you is code: a program that knows how to draw one frame. the video comes from running that program for every frame and gluing the results together.

the whole trick is one rule: a frame is a function of its number.

frame 0 always looks the same. frame 431 always looks the same nothing depends on a clock, a timer or a random number that changes between runs so a render is repeatable, a fix is a one-line edit plus a re-render, and you can check any single frame without playing the whole thing

the smallest version of the idea:

// a frame is a pure function of its number: no clocks, no Math.random
function draw(f) {
  const t = (f % 720) / 720;                        // 0..1 over a 12 s loop at 60 fps
  const x = 200 + 300 * (0.5 - 0.5 * Math.cos(2 * Math.PI * t));
  ctx.fillStyle = '#fff'; ctx.fillRect(0, 0, W, H);
  ctx.fillStyle = '#111'; ctx.fillRect(x, 400, 80, 80);
}

everything else is that function, grown up.

THE FOUR PARTS OF A STUDIO

the stage: one canvas at a fixed size (1000x1080 for my terminals, A4 at 2480x3508 for pages), with the fonts embedded in the file so nothing loads from the network the renderer: a headless engine that calls draw(f) for every frame. no browser window, no screen recording the encoder: ffmpeg turns the frames into H.264. set the pixel aspect ratio explicitly, or some players squeeze the picture. i learned that one the hard way the checks: the part everybody skips, and the part that makes it look expensive

the model writes the first part. you own the other three. once they exist, every new video reuses them, and a new piece is a new draw function, not a new studio.

MY HOUSE RULES

before any animation, the agent gets a rules file. five lines in mine do most of the work:

pure function of the frame: no timers, no CSS transitions, no unseeded randomness the loop closes: every repeating motion divides the loop length, so the last frame flows into the first with no jump colour has a job: black and white is the surface, colour goes only where it means something. on my Grok Bot pieces that's the agents and nothing else real data only: every label traces to a source. no invented numbers, no made-up UI nothing ships unchecked: no render goes out until the checks below come back clean

every one of these came from a mistake. "the loop closes" exists because a dashed border jumped at the seam. "fonts embedded" exists because a whole batch of screenshots was quietly using fallback fonts and nobody noticed.

HOW I BRIEF IT

the brief decides the result more than the model does. what works for me:

describe the mechanism, not the vibe. "a table of contents that reads itself, one section at a time" beats "make it dynamic" name every state. if a card can be idle, live and done, say all three and what each one looks like give it the real material: the numbers, the list, the source text. the model is great at layout and bad at guessing facts show a reference for the look and say what not to take: the type and the spacing, never the layout, the content or anyone's characters ask for the plan before the code: the regions, what lives where, what moves and when

a vague brief gets you the default every model falls back to: a centered title on a gradient with everything fading in. a precise one gets you a mechanism.

HOW IT CHECKS ITSELF

this is where motion design turns into engineering. after every build, before i look at anything, three checks run:

a smoke test: the page runs headless for a full loop on a fake canvas, and six counters must all read zero. runtime errors, error banners, invalid colours, text off the stage, text outside its panel, text overlapping other text a seam check: frame 0 and the frame exactly one loop later must be pixel-identical. if they differ, something in the animation isn't periodic a look: render stills, crop the dense parts at 100%, and actually read them. Opus 5.5 reads images, so it can do this pass itself and tell you what's wrong before you open the file

the counters catch what the eye misses. the eye catches what the counters can't: a line running through a label, a panel that passes every test and still looks wrong.

frames             1820
runtime errors     0
error banners      0
invalid colours    0
text out of stage  0
text out of region 0
text overlaps      0

that block is the real output from my last terminal. six zeros, then i look.

WHAT THIS PROVES

a motion piece that looks like a studio made it isn't one prompt. it's a model, a set of rules it can't break, checks it has to pass, and a loop that keeps going until they pass.

those last three things have real names. the rules and the checks are the harness. the "keep going until they pass" is the loop. that's the next two parts.

---

PART 3: THE HARNESS

AGENT = MODEL + HARNESS

the clearest definition comes from two places that arrived at the same idea.

Birgitta Böckeler (Distinguished Engineer at Thoughtworks) wrote "Harness engineering for coding agent users" in April 2026. she uses harness as shorthand for everything in an agent except the model. and the July 2026 paper "Harness Engineering: Anatomy, Architecture, and Evolution of Coding Agents" (Barbaste, Darrigol, Vu and Wiltberger, arXiv 2609.00006) opens the same way: an agent is a model plus a harness, the runtime that couples the model to the world through a loop, tools, context management, safety controls, orchestration and extension surfaces.

Böckeler adds a useful split. a coding agent already ships with a harness its builders made: the system prompt, the way it retrieves code, its orchestration. on top of that, you, the user, build an outer harness for your own project and your own system.

that outer harness is exactly what the studio in part 2 is. the rules file, the brief, the smoke test, the seam check: none of that is the model, and all of it decides the result.

GUIDES AND SENSORS

Böckeler's model has two kinds of controls:

guides (feedforward): they steer the agent before it acts, so it's more likely to get it right the first time. AGENTS.md, skills, reference docs, how-tos, code mods sensors (feedback): they watch after the agent acts, so it can correct itself. tests, linters, type checkers, review agents

her neat detail: sensors are most powerful when their messages are written for an LLM to read, like a custom linter error that includes the instruction for fixing it. a positive kind of prompt injection.

now map the motion studio onto it:

guides: CLAUDE.md, the style guide written from a reference, the shot list, the brand assets folder computational sensors: the determinism hash, the loop seam check, the beat grid inferential sensors: Opus scoring its own contact sheet, the phone test

same picture. the motion people built a harness without calling it one.

THE STEERING LOOP

the human's job, in Böckeler's model, is to steer by improving the harness. when the same issue shows up more than once, you change a guide or add a sensor so it gets less likely next time, or impossible.

and you can use the agent to do that: write the structural test, draft the rule from a pattern you keep seeing, scaffold the custom linter. this is why the "banned defaults" list in a studio's CLAUDE.md grows over time. every bad render becomes a rule.

KEEP QUALITY LEFT

checks cost time and money, so they get spread across the life of a change:

before a commit: fast stuff. linters, fast tests, a basic review agent after integration, in the pipeline: expensive stuff. mutation testing, a broader architecture review continuously, outside any change: drift detection. dead code, coverage quality, dependency scanners, and agents watching runtime signals like error rates and SLOs

the earlier you catch something, the cheaper it is to fix. same in a film: catch the pop on a twelve-frame strip before the full render, not after.

WHAT A HARNESS CAN AND CAN'T REGULATE

Böckeler splits the harness by what it's trying to keep in shape:

maintainability: the easiest one, because the tooling already exists. computational sensors reliably catch duplicate code, complexity, missing coverage, style violations architecture fitness: performance requirements fed forward as skills, performance tests fed back. fitness functions, basically behaviour: the hard one. does the app actually do what we need? today most people feed a spec forward and check that the AI-written tests are green. that puts a lot of faith in AI-written tests

and she's direct about the gap: no sensor reliably catches a misdiagnosed problem, overengineering, or a misunderstood instruction. and if the human never said clearly what they wanted, correctness is outside any sensor's reach.

HARNESSABILITY

not every codebase can be harnessed equally. strong types give you a free sensor. clear module boundaries let you write rules against them. legacy code with years of debt is where the harness is needed most and hardest to build.

her colleague Ned Letcher calls the helpful properties "ambient affordances": things about the environment that make it legible and navigable for an agent.

that's why harness templates might be next: a bundle of guides and sensors for a common kind of service, like a data dashboard or an event processor, that teams instantiate. it's also an argument from Ashby's Law: a regulator needs as much variety as the system it governs. an agent can produce almost anything, so narrowing it to a known topology makes a full harness achievable.

WHAT ELEVEN REAL HARNESSES LOOK LIKE INSIDE

the arXiv paper is the most detailed look at production harnesses so far. the authors read the source code of eleven coding agents: Claude Code, Codex CLI, Gemini CLI, Mistral Vibe, OpenHands, Aider, Mini-SWE-Agent, Hermes, Pi, OpenCode and OpenClaw, plus Databricks' Omnigent as a contrast. roughly four million lines of Python, TypeScript and Rust.

their anatomy has seven subsystems around one loop:

agent loop: alternates thinking and acting, owns the stop conditions and failure recovery LLM integration: speaks the provider's protocol, builds the prompt, handles caching, thinking, routing tools and actions: what the agent can do, file editing above all memory and context: rations the context window, carries knowledge across turns and sessions safety and permissions: decides what runs, what asks, what's forbidden orchestration: spawns and coordinates sub-agents extensibility: config, hooks, skills, plugins, MCP

some findings worth knowing:

the floor is low. Mini-SWE-Agent covers all seven subsystems in roughly 100 lines, a while loop, one template, one bash tool, and reports SWE-bench results in the same range as systems a thousand times bigger (self-reported) loop sophistication doesn't predict benchmark scores. it predicts production readiness: safety, recovery, cost control, extensibility no runtime in the corpus uses a general agent framework like LangChain or AutoGen, and none retrieves code with vector embeddings. they all run on hand-rolled async loops and deterministic retrieval: ripgrep, glob, tree-sitter, Markdown context files skills overtook MCP: SKILL.md skills ship in 9 of 11 systems, MCP in 8 the harness turned from a tool into a platform in the first half of 2026: importable SDKs, marketplaces, governance layers, and a meta-harness that runs other vendors' harnesses behind one API

and the paper ends with 18 design recommendations. the ones I'd tape to the monitor:

start with a linear while loop. move to a pipeline only when you have several independent turn policies start with just a bash tool. add tools only when you see a real failure past about 15 tools, load them on demand compact context at a fixed buffer below the limit, and keep a verbatim recent tail don't build RAG over code. use ripgrep, glob and symbol extraction stay single-agent until you can point to real breadth-first work. multi-agent setups use around 15x the tokens of a chat use skills for workflows and know-how, MCP for external systems don't over-engineer stuck detection, but do ship the cheap caps

THE PART THAT STAYS HUMAN

Böckeler's closing argument is the one to keep. a developer brings an implicit harness to every codebase: conventions absorbed over years, the pain of a 300-line function, the knowledge of which tech debt is tolerated and why, and their name on the commit. an agent has none of it.

a harness is an attempt to write that down. it can only go so far. so a good harness doesn't try to remove human input. it moves human input to where it matters most.

---

THE LOOP

WHAT A LOOP IS

a harness makes one run better. a loop makes the runs keep happening.

IBM's definition is a good one: a loop is an autonomous, self-correcting feedback cycle where an agent repeatedly acts, tests its results and adjusts its approach until a specific goal is met.

the arXiv paper dates the term: loop engineering entered circulation in June 2026. Peter Steinberger, OpenClaw's original author, put it as stop prompting coding agents and design loops that prompt them, and Addy Osmani named and structured the practice days later. the paper draws the line cleanly: harness engineering builds the inner act-and-observe cycle. loop engineering composes that cycle, from the outside, into loops that prompt, verify and re-run the agent without a human writing each turn.

THE FOUR LOOPS, AS THE CLAUDE CODE TEAM FRAMES THEM

the Claude Code team sorts loops by how they're triggered, how they stop, and which primitive runs them. their advice up front: not every task needs a complex loop. start with the simplest one.

> the agentic loop: every prompt you send. Claude gathers context, acts, checks, repeats if needed, answers. you check the result and write the next prompt. you are the loop > the goal loop: /goal. you define what done looks like, and every time Claude tries to stop, an evaluator model checks your condition and sends it back to work until it's met or a turn limit hits. example: get the homepage Lighthouse score to 90 or above, stop after 5 tries > the time loop: /loop. re-runs a prompt on an interval. good for recurring work, or for checking an outside system and reacting. example: every 5 minutes, check my PR, address review comments, fix failing CI. it runs on your machine, so it stops when your machine does. move it to the cloud with /schedule > the proactive loop: routines triggered by an event or a schedule, no human in real time. each task exits when its goal is met, the routine runs until you turn it off. best for streams of well-defined work: bug reports, triage, migrations, dependency upgrades. route routines to smaller, faster models and keep the most capable model for judgment calls

their verification advice is worth stealing whole: write a skill that says never report a UI change as done based on the edit alone. open the page, use the change, screenshot before and after, check the console for new errors, run a performance trace, and if any step fails, fix it and start over.

that's a sensor, written as a skill, inside a loop. harness and loop are already the same system.

the agentic loop: every prompt you send. Claude gathers context, acts, checks, repeats if needed, answers. you check the result and write the next prompt. you are the loop the goal loop: /goal. you define what done looks like, and every time Claude tries to stop, an evaluator model checks your condition and sends it back to work until it's met or a turn limit hits. example: get the homepage Lighthouse score to 90 or above, stop after 5 tries the time loop: /loop. re-runs a prompt on an interval. good for recurring work, or for checking an outside system and reacting. example: every 5 minutes, check my PR, address review comments, fix failing CI. it runs on your machine, so it stops when your machine does. move it to the cloud with /schedule the proactive loop: routines triggered by an event or a schedule, no human in real time. each task exits when its goal is met, the routine runs until you turn it off. best for streams of well-defined work: bug reports, triage, migrations, dependency upgrades. route routines to smaller, faster models and keep the most capable model for judgment calls

their verification advice is worth stealing whole: write a skill that says never report a UI change as done based on the edit alone. open the page, use the change, screenshot before and after, check the console for new errors, run a performance trace, and if any step fails, fix it and start over.

that's a sensor, written as a skill, inside a loop. harness and loop are already the same system.

HOW A PRACTITIONER ACTUALLY RUNS THEM

Addy Osmani runs five to ten agents a day, usually about five at once. his split:

delegate fully: tasks with a clear stopping condition and clear constraints. write the docs for a feature, check test coverage watch closely: complex problems where even a good spec might not be enough always watch: anything touching auth, security, finance, or a system the agent has access to

the goal primitive, for him, is for any piece of work that has to be provably done. be specific about the tooling and the stop rule. his shape for a good goal:

/goal Refactor the data-fetching layer until the Lighthouse performance
score is >= 92 and LCP < 1.8s in the Lighthouse CLI output.
Don't change any hook's public API. Every turn must improve one metric;
abort after two turns with no improvement. Stop after 10 turns.

the loop primitive is more like cron: poll, monitor, repeat. his daily one is the pull request pile on his Agent Skills repo (80,000+ stars), which at one point got up to 80 or 90 PRs a day. a loop checks for new issues every hour and summarizes their urgency. a scheduled task closes PRs that clearly break the contribution rules, like translations they can't maintain.

and the combination:

/loop every 24h "Check GitHub for issues labeled 'bug'. If one exists,
use /goal to implement a fix until all local tests pass and push the branch."

loop to notice. goal to finish.

THE MISTAKE HE ALMOST SHIPPED

the most useful story in his piece is a failure. he asked an agent to study competitors, find gaps, and prepare local PRs for them. he read the research, skimmed the implementations, and almost pushed. when he finally read the code, the changes added a lot of complexity for users, for not much gain.

his lesson: delegate the task, never the taste and the judgment.

two habits follow from it:

don't let the agent that did the work decide the work is good. one sub-agent makes the change, a separate one verifies it know what the /goal evaluator does and doesn't do. it doesn't judge whether the result is good. it reads the transcript and checks whether your hard rules were met

and the fine print:

recurring loops expire seven days after creation loops are session-scoped. a new conversation stops them, but resuming the session brings back any recurring task still inside its seven days if it has to outlive the session, use /schedule and run it in the cloud the classic sign of a loop spinning in place: the same command tried a third time with no change since the second. stop it

and where loops don't fit: when you can't say what done means. "keep going until this UI is good" isn't a goal. good to whom, measured how? taste, subjective design and open-ended creative exploration are bad fits.

THE ANATOMY OF A GOOD LOOP

IBM's explainer breaks every loop into four stages:

goal: checked on every iteration. specific, scoped, with a clear stop. "stop when all unit tests pass" beats "make it faster" action: the next step toward the goal. write code, run a test, fix a bug observation: check what happened. run CI, read the result adjustment: change the approach based on what you saw, then go again

and the parts you build it from:

automations or scheduling: the cadence. cron, GitHub Actions, routines hooks: rules fired by events, before or after an edit, a tool call, a commit. great for quality and policy checks, and they keep that work out of the model's tokens context engineering: give each cycle what it needs and no more. summarize old iterations, structure state in Markdown tool access: MCP servers and APIs, so the agent acts instead of describing what it would do worktrees: parallel branches so several agents don't step on each other skills: the know-how for one recurring workflow, in a SKILL.md subagents: specialists for research, implementation, verification. a maker/checker pair beats self-review spine: the persistent state, a Markdown log or a Linear board, so the loop remembers what it tried and doesn't repeat the same error

WHY THE HUMAN STAYS IN THE LOOP

IBM names four ways it goes wrong when people step out:

unverified code: a checker agent is still an agent. a human owns what ships, including whether it leaks data or breaks a regulation comprehension debt: the gap between how much code exists and how much humans understand. it grows silently, because the code passes its tests, and you find out during an incident intent debt: the why behind the system gets lost unless it's written down in AGENTS.md or skills. without it, agents make changes that are technically fine and strategically wrong cognitive surrender: when people accept whatever the loop outputs. offloading is fine. surrender is losing control

---

HOW ONE MODEL TIES IT TOGETHER

THE MOTION STUDIO WAS A LOOP ALL ALONG

go back to the studio from part 2 with the last two parts in mind:

the house rules file is a guide the brief with named states and real data is a guide the smoke test and the seam check are computational sensors Opus reading its own stills is an inferential sensor "nothing ships until all six counters read zero" is a goal with a stop rule the loop length that every motion has to divide is the contract that keeps every re-render identical the note of what failed last time, and which rule it turned into, is the spine the reusable stage, renderer and checks are extensibility: the next film starts from them, not from zero

motion design, harness engineering and loop engineering aren't three trends. they're the same engineering, applied to frames instead of pull requests.

WHY OPUS 5.5 IS THE MODEL WHERE IT CLICKS

each discipline leans on a specific property, and Opus 5.5 has all of them at once:

long runs need cheap context. loops re-read the same context all day, and cache reads dropped 60% to $0.20 per million long runs need staying power. a 680,000-line migration in a day, a 200,000-line audit in under three hours, HAProxy rewritten in 9.5 hours inferential sensors need eyes. Opus 5.5 reads images, so it can grade its own frames, screenshots and charts human review needs readable output. it puts the key information first and follows your writing rules, which Anthropic calls a safety benefit for a reason unattended runs need restraint. an action classifier, a sandbox, about 85% fewer boundary attempts, every one self-reported cost discipline needs effort control. medium by default, xhigh or max when it matters, and Anthropic's own numbers show default effort often beating rivals at max

that's what "one model connects everything" actually means. not that the model does everything. it's that the model's properties line up with what the harness and the loop need from it

A SETUP YOU CAN COPY THIS WEEK

here's the whole stack in five steps, built from the sources above. it works for a motion studio and for a codebase.

1. pick the model and the effort. Opus 5.5 in Claude Code. medium for small fixes and re-renders, xhigh for new work, max for the pass that has to carry a launch.

2. write the guides. one CLAUDE.md or AGENTS.md with the contract, the banned defaults, and the definition of done. one skill per recurring workflow. named states and real data for anything visual.

3. add the sensors. one computational check that runs on every change (tests, a linter, a smoke test, a seam check), and one inferential check with its own instructions (a review skill, a look at the stills). keep the maker and the checker separate.

4. wrap it in a goal. a stop rule a machine can check, a turn limit, and an abort rule for no progress:

/goal The smoke test reads zero on all six counters and frame 0 matches
frame 720 pixel for pixel. Fix the worst failure each round.
Abort if a round fixes nothing. Stop after 5 rounds.

5. schedule what repeats. /loop for things you'd otherwise check by hand, /schedule for anything that has to survive your laptop closing. write every result to a spine file so the next run starts smarter.

and the rule from every source in this article: when the same problem shows up twice, don't fix the output. fix the harness.

---

THE PROMPT IS THE SMALLEST PART

the week Opus 5.5 shipped, everyone posted the prompt. the prompt was never the interesting part.

the interesting part was everything around it: the rules file, the real data, the checks that had to read zero, and the loop that kept going until they did.

that's not prompting. that's engineering: a model, a harness around it, and a loop that keeps it honest. Opus 5.5 is the first model where all three pay off at once, because it's cheap enough to keep running, good enough to finish, clear enough to check, and careful enough to leave alone.

the prompt is the smallest part. build the rest.

---

SOURCES

> Anthropic, "Introducing Claude Opus 5.5" (22 Sep 2026)

https://www.anthropic.com/claude-opus-5-5

> Anthropic, Claude Opus 5.5 model overview

https://platform.claude.com/docs/en/models/opus-5-5/overview

> Birgitta Böckeler (Thoughtworks), "Harness engineering for coding agent users" (2 Apr 2026)

https://martinfowler.com/articles/harness-engineering.html

> Barbaste, Darrigol, Vu, Wiltberger, "Harness Engineering: Anatomy, Architecture, and Evolution of Coding Agents. A Source-Code Study of Eleven Systems", arXiv 2609.00006 (15 Jul 2026)

https://arxiv.org/abs/2609.00006

> Claude Code team (Delba de Oliveira, Michael Segner), "Loop engineering: Getting started with loops" (30 Jun 2026)

https://claude.com/blog/getting-started-with-loops

> Claude Code docs, /goal

https://code.claude.com/docs/en/goal

> Claude Code docs, /loop

https://code.claude.com/docs/en/scheduled-tasks

> Addy Osmani, "Loop Engineering" (7 Jun 2026)

https://addyosmani.com/blog/loop-engineering/

> IBM (Ivan Belcic, Cole Stryker), "What is loop engineering?" (17 Jul 2026)

https://www.ibm.com/think/topics/loop-engineering