Devin vs Claude Code: Autonomous Engineer or Terminal Pair

Devin and Claude Code can both write, run and test code, but they are designed around different working relationships. Devin is built for delegation: you hand it a ticket, from Slack, Linear, Jira or its web app, and it works on its own virtual machine with a shell, an editor and a browser until it has a pull request for you to review. Claude Code is built for collaboration: it works in your repository, in your terminal or editor, while you watch and steer, and it can also run in the cloud when you want to walk away. Choose Devin when your team has a queue of well-defined tickets and wants them turned into pull requests with little supervision. Choose Claude Code when the work needs your judgement along the way, or when you want to decide task by task whether to pair or delegate.

What Devin is today

Cognition’s introduction to Devin calls it an autonomous AI software engineer that can write, run and test code, and gives a rule of thumb: if you could do the task in three hours, Devin can most likely do it. Each cloud session runs on its own machine, so it keeps going after you close your laptop. Devin is now a family of products under one brand:

• Devin Cloud: the autonomous agent, started from the web app, Slack, Microsoft Teams, Linear, Jira, the API or event-driven automations.
• Devin Desktop: the IDE formerly called Windsurf, whose Agent Command Center shows local and cloud Devin sessions on one Kanban view. Compared in Windsurf vs Claude Code.
• Devin CLI: a local terminal agent, with /handoff to pass a task to a cloud session.
• Devin Review: pull request review, with an auto-fix option that answers review comments and CI failures.

Hand-off from where the work is filed

This is Devin’s strongest difference. In Slack you tag @Devin in a thread and it replies there as it works. In Linear, according to the Linear integration page↗ (opens in a new tab), you can assign a ticket to Devin, add a playbook label such as !plan or !implement, or mention it in a comment, and automation triggers can start sessions when a ticket reaches a status or gets a label. Jira works the same way, with an option for Devin only to post a scoping comment, a summary, plan and confidence estimate, instead of starting work.

Playbooks, knowledge and skills

Playbooks are reusable prompts for repeated tasks, written with sections such as Procedure, Specifications, Advice, Forbidden Actions and Required from User, and attached with a macro like !plan. Knowledge, Devin’s store of tips it recalls across sessions, is on its way out: the Knowledge page↗ (opens in a new tab) says it is deprecated and being migrated automatically to skills, SKILL.md files that follow the open Agent Skills standard and live in your repository under .agents/skills/. Devin suggests new skills after a session learns something about your setup.

Where Claude Code overlaps

Claude Code is not only a terminal pair. Anthropic’s cloud sessions page↗ (opens in a new tab) describes sessions that run on Anthropic-managed infrastructure and keep running after you close your laptop, started from claude.ai/code, the mobile app, the desktop app, claude --cloud or scheduled routines, and pulled back to your terminal with --teleport. It can auto-fix pull requests when CI fails or reviewers comment, and on Pro and Max you can start sessions by mentioning @Claude in Slack; Team and Enterprise workspaces move to Claude Tag. What it does not have is Devin’s ticket-first plumbing: assigning a Linear or Jira issue, playbook labels, a scoping-only mode.

The two also connect. Cognition’s hand-off guide↗ (opens in a new tab) describes an open-source Devin Handoff plugin for Claude Code, Codex and other agents: say “hand this off to Devin” and the plugin sends your repository, branch and uncommitted diff to a new cloud session. Commit or stash anything you do not want sent.

Delegation or collaboration

• When you think: with Devin, up front, in the ticket and the playbook, because you will not be there when it hits a fork. With Claude Code, along the way, because it asks, shows diffs and takes corrections mid-task.
• Where it runs: Devin on its own machine by default, set up once per repository with dependencies and secrets. Claude Code on your machine by default, with your tools and your working copy, or in a cloud environment when you choose.
• What comes back: Devin returns a pull request and a session log. A local Claude Code session returns changed files in your working tree; you commit.
• Parallelism: Devin can start managed Devins and run many sessions at once. Claude Code runs subagents, worktrees and several sessions, which you arrange yourself; see orchestrating coding agents.
• Models: Devin’s local tools offer models from several labs, including Cognition’s own SWE models, and a router that picks one per request. Claude Code runs Claude, with Opus 5.5 the default on most plans.

The review burden moves, it does not vanish

Delegation saves attention while the work happens and spends it at the end, when a finished pull request lands and you have to rebuild the reasoning from a diff. Devin’s own guidance on when to use Devin↗ (opens in a new tab) is to give tasks clear success criteria, prefer work that tests, lint or CI can verify, and keep sessions small, splitting large jobs. Before you merge, check:

1. The diff, not the summary. Summaries describe intent; the diff is what ships.
2. Scope. Did it change files the ticket never mentioned, or rewrite tests so they pass?
3. The check you named. Run it yourself, or confirm CI ran the same thing.
4. Secrets, network calls and dependencies it added, which matter more when the agent had its own machine and credentials. Verifying AI-generated work has the fuller list.

Scoping a task for a delegated agent

A pairing agent can ask you what you meant; a delegated one guesses. Write the ticket so there is nothing to guess: the outcome, where in the code, what not to touch, acceptance criteria, how it will be checked, what to do when blocked, and a size small enough for one pull request. Giving an AI agent a task it can finish walks through each part with examples. With Devin, put the standing parts, forbidden actions and the definition of done, in a playbook or a skill once, so each ticket carries only what is specific to it.

Devin vs Codex

Codex cloud is the nearest match. OpenAI’s Codex cloud page↗ (opens in a new tab) describes tasks running in isolated cloud environments, started from the web, GitHub, GitLab, Linear, Slack or the CLI, and returned as a diff you can open as a pull request. Both suit delegation. Devin adds a full desktop with a browser for testing its own changes, Jira and Microsoft Teams hand-off, and playbooks; Codex comes with ChatGPT plans, an open-source CLI and the same agent in your editor. The details are in Codex cloud, and Codex against Claude Code in Claude Code vs Codex.

One list of work for people and agents

Devin’s Kanban shows agent sessions, and your tracker shows tickets; neither holds work done in Claude Code. fenbs is a board that both agents and your team can use over MCP. In Devin, an organisation admin adds fenbs as a custom HTTP MCP server with an auth header; in Claude Code it is one command. The token you issue under Settings, “Connect an AI assistant”, has a name, scopes and an optional expiry, and acts as you within your role, so every move in History reads as the assistant on your behalf. fenbs has no assignee field, so there is no “assign to Devin” trigger: you point the session at a task, and it moves the task from Next Up to Completed and sets its test status and notes when done.

Devin custom MCP
  Transport:       HTTP
  Server URL:      https://fenbs.ai/api/mcp
  Authentication:  Auth Header
  Header value:    Bearer <token from fenbs Settings>

Claude Code
  claude mcp add --transport http fenbs https://fenbs.ai/api/mcp