Claude Duet vs Claude Code: Same Model, Two Very Different Ideas of Done

Here is the asymmetry that explains almost everything else. Ask Claude Code to ship a bug fix and there is a moment when the work is simply finished: the diff applies, the suite goes green, CI agrees, and a reviewer either merges it or does not. Ask Claude Duet to handle the same morning's admin and the finish line is not a test suite — it is your judgment. Duet drafts the action, shows it to you, and waits; whether the result was right is a question no oracle in the system can answer. Both surfaces run the same underlying Claude Opus 5.5 model on the same account with the same usage limits, and yet one has an objective definition of done and the other has a social one. That single difference — an oracle versus your opinion — is the argument of this comparison, and most of the product detail below follows from it.

One model, two contracts

Start with what is genuinely shared, because it is more than the marketing implies. Claude Code is an Anthropic product on the same Pro, Max, Team, Enterprise or Console account as everything else, and Duet is included in Pro and Max. Anthropic describes Duet as designed around Claude Opus 5.5, and the Claude Code page's own fast-mode note confirms that Opus 5.5 is the model behind that surface too. So the model is not the differentiator. The contract around the model is.

Claude Code's contract is narrow and legible: it works in a repository, it reads and writes files, it runs commands, it runs your tests. It is available as a terminal tool, a desktop app, a web interface and a mobile app, with integrations for GitHub and IDEs including VS Code and JetBrains. It shows up in Slack. It runs on macOS, Linux and Windows. Everything it produces lands somewhere you can inspect — a working tree, a diff, a pull request — and everything it asserts can be checked by executing something.

Duet's contract is broad and fuzzy by design. It lives in its own app on iOS and Android and on claude.ai, it draws on more than 6,000 connectors and plugins, and it spends its day among the artifacts of knowledge work: mail, documents, invoices, messages, schedules. None of those carry a test suite. When Duet says it matched two invoices, the check is you looking at the two invoices.

On the code side, done has a verdict

The interesting thing about Claude Code is how much of the product is built to let a machine say no. Hand it a bug, a test, or a multi-day migration and it plans, asks clarifying questions, writes the code, runs the tests, and either opens a pull request or reports that it could not get the thing working. Those are not equivalent outcomes and the interface does not pretend they are.

Anthropic's own sample session is instructive. Handed a duplicate-charge bug, the agent reproduces it, traces the idempotency key, finds that the key is generated per call rather than per checkout session, edits the file, and reports a plus-nine minus-three change. Another sample adds a dark mode toggle: it reads four files, edits a provider, persists the choice to local storage, and hands back a working preview. In both cases the deliverable is a reviewable change and the evidence is that something ran.

This is why the developer surface keeps growing in its own direction. The Claude Code page's related-articles block records Code Review shipping generally available on 2026-10-15, and Claude Security opening a continuous-scanning public beta for Enterprise on 2026-10-21 — two launches aimed squarely at the question "was the change correct," one of them by adding another automated reviewer to the loop. Whatever Anthropic's agent strategy does next, the code surface is accumulating its own machinery for deciding whether work is good.

On the briefing side, done has a person

Duet inverts the loop in a way that makes an automated verdict structurally impossible. It generates a brief every morning and checks connected accounts every few hours, which means it is producing work nobody requested against criteria nobody wrote down. There is no test to run on "is this the thread I needed to see." The only oracle is whether you found it useful at 8am.

So the approval gate is doing different work than a permission prompt. When Duet shows you an action and waits, it is not checking correctness; it is transferring accountability. You are the reviewer, and the review is a judgment call rather than a diff. That is also why the refusals are hard-coded earlier in the pipeline: securities trading and moving money between accounts are off the table even with your approval, and a classifier declines to handle credit card numbers and government identification at all. If your judgment is the last line of defence, the system has to be conservative about what it will even offer you.

Anthropic is candid that this is hard. Duet might misread a thread or miscalibrate what is urgent, it is weaker at personal errands than at work tasks, and it cannot yet show you its browser — which means the one piece of evidence you would most want before approving a web action is, for now, unavailable. That last limitation reads like an honest gap rather than a roadmap tease, and it is the clearest illustration of the asymmetry: the code surface can show you the test output, and the briefing surface cannot yet show you the page.

The same person, on a walk

One detail from Anthropic's announcement makes the pairing concrete rather than theoretical. Among the testers quoted on the Duet page is Boris Cherny, who leads the Claude Code team, describing working through his to-do list while out on a walk. That is the argument in miniature: the person who builds the code surface is also the person using the briefing surface, for a different job, in a different posture, with a different standard of proof. Nobody at Anthropic appears to think these are competing products.

The practical version of that for anyone choosing between them is unglamorous. If the work has a definition you can automate, you want the surface built around that definition, because the automation is what lets you walk away from it. If the work only has a definition you can articulate to yourself, you want the surface that brings it to you and waits, because the waiting is the only safeguard available.

Meeting in the middle, carefully

Both surfaces have been creeping toward the other's territory, and this is worth noting without reading a roadmap into it. Computer use — the ability to interact with a screen directly — is in research preview for Claude Code as well as for Cowork, per Anthropic's own wording, so the code agent can already reach past the repository when it has to. Duet, for its part, is generating artifacts that look a lot like deliverables.

There is also a sentence on the Duet page that invites over-reading. Duet "lives in its own app, separate from the main Claude app," Anthropic writes, and adds that what it learns from early users will shape how those two surfaces work alongside each other. The "two" there is Duet and the main Claude app, not Duet and Claude Code. It would be easy to build a theory of convergence on that line, and the honest reading is narrower: Anthropic is telling you the surfaces are still moving, which is a reason to standardise your own workflow on things that do not move.

What stays constant when the packaging changes

The durable questions are the same ones you would ask of any two tools that act on your behalf. Where does the action land — a working tree you can diff, or a mailbox you cannot roll back? What stops it — a compiler or a test suite, or a gate that asks you first? And what evidence do you get afterward — a log of commands run, or a summary written by the thing that did the work?

Notice that those three questions sort the two surfaces cleanly and do not depend on either one's current name, icon, or menu position. They also survive the moment when a feature crosses over. If Claude Code someday drafts your morning brief, the question "what evidence do I get" still has an answer, and it is still different from the answer Duet gives today.

Where the model fits, if that is what you need

Both of these are Anthropic products with Anthropic's interface wrapped around Anthropic's model, and neither can be re-pointed at a different endpoint — the agent layer is the product. If what you actually want is Claude Opus 5.5 inside your own pipeline, where "done" is whatever your code defines it to be, that is a different purchase and it is the one we sell: 4.00 dollars per million input tokens, 20.00 per million output tokens, a 1M-token context window, and 0.20 dollars per million cache reads, at 0 percent markup, through one OpenAI-compatible key that reaches more than 200 models.

That is not a rival to either surface. It is the layer underneath both of them, bought directly, which means the approval gate, the schedule, and the definition of done all become yours to write. Some teams want that; most people, most mornings, would rather open a window and let someone else's opinion about "done" stand in for theirs.

If you are picking between the two agents, the question to ask is not which one is stronger. It is whether this piece of work has a verdict you could automate. If it does, hand it to Claude Code and let the suite decide. If it does not, hand it to Claude Duet and decide yourself — just be aware that you are the oracle, and that being the oracle is a job, not a formality.