Claude Opus 5.5 Workflow: Five Habits for Long-Running Coding Agents

A five-part workflow for running Claude Opus 5.5 on unsupervised coding tasks of an hour or more recommends short prompts, measurable benchmarks, failure-mode tests, visual reference designs, and multi-agent orchestration in which Opus plans and reviews while faster models such as Sonnet implement. The workflow's author, writing about building PandaCode, a desktop app for running coding agents, attributes long-task quality loss to context saturation and prescribes keeping each unit of work small and handing off before quality erodes. A three-sentence prompt for a "resume at reset" feature, with no files or implementation steps specified, reportedly led the agent to find existing usage-tracking code across multiple agents and catch details a manually written plan would have missed.

Claude Opus 5.5 Workflow: Five Habits for Long-Running Coding Agents A practical workflow for Claude Opus 5.5 long tasks: simple prompts, benchmarks, tests, design references, and multi-agent orchestration. What is the Claude Opus 5.5 agent orchestration workflow? It’s a practical approach to getting reliable results from Claude Opus 5.5 on long, unsupervised coding tasks an hour or more without human input . The workflow has five parts: write short prompts and let the model choose its own path, give it a measurable benchmark instead of vague goals, require it to write and pass tests before showing you results, supply visual reference designs instead of describing style in words, and run multiple agents together, with Opus planning and reviewing while faster models like Sonnet do the implementation work. TL;DR - Short prompts beat detailed step-by-step instructions because Opus 5.5 is good at reading a codebase and finding a better execution order than a human would plan in advance. - Benchmarks turn vague goals like “make it faster” into numbers the agent can test against , which lets it work independently for long stretches without needing constant human judgment calls. - Tests should target failure modes, not coverage counts , and the rule is that no work reaches the human until it passes, which catches basic errors before they waste review time. - Reference designs screenshots, mood boards, or sketches remove design guesswork , since asking a model to “make it look good” tends to produce generic, repetitive visual patterns. - Multi-agent orchestration uses one model as architect and others as workers , splitting big tasks into smaller jobs with fresh context so quality doesn’t degrade as a single conversation grows long. - A second model from a different company acts as an independent reviewer , catching mistakes that the primary model and its workers both missed. Plans first. Then code. Remy writes the spec, manages the build, and ships the app. Why do long AI coding tasks degrade over time? The core failure mode with long-running coding agents is context saturation. As a single conversation grows, the model has to track more decisions, more files, and more intermediate state, and quality drops near the end of the task. This is the exact problem reported with Opus 5.5 on extended work: strong starts followed by the agent losing track of earlier decisions. The fix described isn’t a different model setting, it’s workflow design: keep individual units of work small enough that any one agent’s context stays manageable, and hand off work before quality erodes. Why do simple prompts work better than detailed instructions? The instinct for most people writing prompts for coding agents is to over-specify: read this file, then make a plan, then edit that file, then run this command. That approach caps the agent’s performance at whatever plan the human came up with, even when a better path exists in the actual codebase. Opus 5.5 is described as strong at reading code, understanding how parts connect, and picking a sensible order of work for that specific codebase. A concrete example from building PandaCode a desktop app for running coding agents involved a “resume at reset” feature: when an agent hits its usage limit mid-task, the app should wait for the limit to reset and continue automatically, with the user able to cancel. The full prompt was about three sentences. No files were specified, no implementation steps were listed. The agent found the existing usage-tracking code across multiple agents and built the feature around it, reportedly catching details a manually-written plan would have missed. The suggested structure for a simple prompt has three parts: what you want, how you’ll know it’s done, and what the agent must not touch without asking for example, don’t change the database format, don’t delete user data . Everything else, the actual path to the solution, gets left to the model. How do benchmarks make long tasks easier to trust? “Make it faster” is a weak instruction because there’s no way for the agent, or the human, to verify progress. A benchmark converts that into a number: time to open a window, memory used at idle, time to first response token, number of re-renders per state change. Once that number exists, the agent can run it, make a change, run it again, and know immediately whether the change helped. This matters specifically for unsupervised work. A benchmark gives the agent a concrete target to keep pushing toward, rather than stopping after the first plausible-looking fix. In practice, this was used to optimize PandaCode’s startup time and idle memory, and separately to reduce the delay between sending a follow-up message and seeing the first word of a response cut from around 8 seconds to around 4 seconds by having the agent start the next process in the background when a turn ends . The instruction to give an agent is specific: write a benchmark for this, show me the number, then improve the number. - ✕a coding agent - ✕no-code - ✕vibe coding - ✕a faster Cursor The one that tells the coding agents what to build. Why does test coverage matter more on long tasks than short ones? Opus 5.5 tends to produce strong code but thin test coverage by default, sometimes a single shallow test or none at all. On a short task that’s a minor annoyance. On a long task, where the agent is touching many files over an hour or more, it becomes a real risk: a change in one place can silently break something elsewhere, and without tests the agent won’t notice until much later, if at all. The fix is to explicitly ask the agent to think through how a feature can break and write tests for those specific cases empty inputs, error states, race conditions rather than a large number of superficial tests. The hard rule is that nothing gets shown to the human until it passes. A concrete example is PandaCode’s “merge into main” feature, which merges an agent’s commits into the user’s main branch locally, a risky operation by nature. Before trusting it, the workflow called for tests covering uncommitted changes and merge conflicts, with the rule that in both cases the app must stop and change nothing. This logic can be written once into a project’s instructions file referred to here as a claw.md file so it doesn’t need repeating in every prompt. How do reference designs reduce guesswork in AI-generated interfaces? Visual design is subjective, and an instruction like “make it look good” forces the model to guess at taste, usually defaulting to familiar generic patterns heavy gradients, oversized rounded cards . The fix is to supply actual reference material: screenshots of layouts, color choices, or spacing pulled from design sites, or even a rough hand-drawn sketch when no existing reference fits. Opus 5.5 is described as capable of reading a reference image and extracting spacing, font sizing, color choices, and overall mood, then applying that to new interface work. This approach was used throughout PandaCode’s interface, including its approval bar and task board. The practical upgrade here is persistence: collecting references into a reusable “mood board” tied to a project, so every future task can draw on the same visual language instead of re-explaining it each time. What does multi-agent orchestration look like in practice? Orchestration addresses the context-saturation problem directly. Instead of one agent handling an entire large task in one continuous conversation, one agent acts as an architect: it plans the work, breaks it into smaller pieces, and assigns each piece to a separate worker agent with its own fresh context. The architect doesn’t write most of the code itself, it reviews output and holds the overall plan in view. A specific model assignment was described: Opus 5.5 as the architect, since it’s strongest at planning and reviewing; Sonnet handling most worker tasks, valued for speed, lower cost, and solid performance on clearly scoped jobs; and Codex brought in separately as a reviewer, on the reasoning that a model from a different company catches a different set of mistakes than the primary model and its own workers would catch between them. Remy is new. The platform isn't. Remy is the latest expression of years of platform work. Not a hastily wrapped LLM. Critically, the earlier habits compound inside this structure. The architect can assign one worker to write a benchmark and another to improve the number, assign tests to a worker and require every other worker’s output to pass them, and hand design references to whichever worker owns interface work. An example cited is PandaCode’s GitHub view showing repos, pull requests, and issues with one-click actions : one worker handled data, another handled interface using existing design references, a third wrote tests, and Codex reviewed the complete change before it reached the human. Supporting mechanics for this kind of long-task management include running work in isolated git worktrees so a long task can’t break what’s happening elsewhere on the main branch , queuing follow-up messages versus steering an agent immediately without interrupting it, and tracking usage limits so a task can pause and resume automatically rather than stalling when a rate limit is hit mid-run. Is this workflow worth the extra setup effort? It depends on the scale of what’s being built. For quick, single-file changes, the overhead of benchmarks, dedicated test suites, and multi-agent coordination isn’t worth it. For substantial, long-running engineering work, the tradeoff shifts: the point isn’t that these habits make an agent perfect splits can still go wrong, a worker can still head in the wrong direction , it’s that human review happens less often and catches fewer basic, already-fixable problems when it does happen. That shift, from constant babysitting to periodic review, is the actual time savings being described. Frequently Asked Questions What is Claude Opus 5.5 best used for in this workflow? It’s positioned as the planning and reviewing layer: writing initial prompts, architecting multi-agent task breakdowns, and reviewing worker output, rather than handling every line of implementation itself. Why use Sonnet instead of Opus for worker tasks? Sonnet is described as faster and cheaper, and well suited to clearly scoped jobs once Opus or an architect agent has broken a large task into smaller, well-defined pieces. What does Codex add if Opus is already reviewing the work? Codex comes from a different model provider, and the reasoning given is that a second model trained differently tends to catch mistakes that the primary model and its own worker agents miss, acting as an independent check. Do I need a tool like PandaCode to use this workflow? No. The five habits simple prompts, benchmarks, required tests, reference designs, and multi-agent orchestration are workflow principles that can be applied manually with any agentic coding setup; PandaCode is one implementation that automates the orchestration and tooling around them. How do benchmarks actually help with agent autonomy? A benchmark gives the agent an objective, checkable target. Instead of stopping after one plausible change and asking the human to judge whether it’s “good enough,” the agent can test its own output against a number and keep iterating until that number improves, which is what makes long unsupervised runs more reliable.