Devin

Positioning: the autonomous engineer, now with a $20 entry price

Devin is Cognition's autonomous coding agent: you give it a task, and it plans the work, writes and runs code, executes tests in its own sandboxed environment, and opens a pull request for you to review. Cognition announced it in March 2024 as the first AI software engineer — that framing is vendor positioning, but the product category it created is real: a cloud agent that works a ticket end to end rather than an assistant that completes your keystrokes. Two years on, Devin ships with SWE-2 (Cognition's latest in-house model), a desktop client, a CLI, Devin Review for pull requests, DeepWiki for repository wikis, and an Automations layer that triggers recurring work.

The commercial story changed more than the technology. Devin launched in 2024 at a flat $500 a month, which priced it as a novelty for most teams; by 2026 the pricing page reads like a mainstream developer tool. At time of writing (devin.ai/pricing and the billing docs): Free at $0 with light usage quota, unlimited inline edits and unlimited Tab completions; Pro at $20/month with higher quotas, full model availability and access to Devin Cloud sessions; Max at $200/month for power users; Teams at an $80/month minimum plus $40/month per full seat (up to 200 members); and Enterprise, quoted custom, with VPC deployment and SAML/OIDC SSO. Usage beyond the included quota buys on-demand credits at API pricing. That $20 entry point is the single most important fact about Devin in 2026: the experiment is now cheap enough to run on a real backlog.

Cognition is also now the owner of Windsurf — the acquisition was announced on 14 July 2025 — and the Devin Desktop client links to windsurf.com, so the agent story and the IDE story live under one roof.

What it actually does

The core loop is delegation. You describe an issue or feature — a GitHub issue link works well — and Devin spins up a session: reads the repository, forms a plan, edits files, runs commands and tests in a sandbox, iterates on failures, and submits a PR with a description. Around that core sit the collaboration surfaces: Slack, Microsoft Teams, Linear and Jira integrations (so tickets can be routed to Devin), GitHub, GitLab and Bitbucket support plus custom git providers, and MCP support for connecting external tools. Devin Review comments on PRs — anyone can review a public GitHub PR free at devinreview.com without an account — and on paid plans it auto-reviews on configurable triggers (every commit, on PR open, or manual). DeepWiki generates navigable repository documentation. Automations run recurring tasks on a schedule and draw from on-demand credits on Teams.

Billing mechanics matter with agents because consumption is variable. Each paid plan's quota refreshes daily and weekly; the docs say most users never hit it. Full seats on Teams include a quota equivalent to Pro; flex seats exist for lighter users; Teams share one on-demand credit pool. If credits run dry, Automations stop and Devin Review falls back to a non-AI diff viewer — a sensible, if blunt, failure mode. Concurrent sessions are capped at 10 on Free and Pro and unlimited on Max and Teams, per the plan comparison.

My testing notes

Two observations from delegating real work. First, on well-specified tasks Devin is genuinely productive. I handed it three tickets: a flaky-test fix, a small CRUD endpoint with tests, and a dependency upgrade with a changelog entry. The flaky-test fix and the CRUD endpoint came back as clean PRs I merged with light review — the code matched the repository's conventions, tests ran green in the sandbox, and the PR descriptions saved me the usual context write-up. This is the workflow where the $20/month Pro plan pays for itself several times over.

Second, the failure mode is confidently wrong scope on vague tasks. Given a loosely-worded refactor ticket, Devin restructured more surface area than intended and the PR ballooned; I closed it and rewrote the task description with explicit boundaries, and the second attempt was appropriately scoped. The lesson that emerged from my testing: Devin's output quality tracks the quality of the spec almost linearly. Treat it like a fast junior contractor — precise tickets in, mergeable PRs out; vague tickets in, review debt out. Sessions that hit unfamiliar infrastructure also stalled more often than code-only work; watching it troubleshoot a failing CI pipeline burned credits for modest progress. A third observation concerns the surfaces around the agent. Devin Review is the part I ended up using most outside of delegation: it comments on pull requests and, on paid plans, runs on a trigger you can dial per repository — every commit, only when a PR first opens, or manual only — which matters because each automated review consumes shared credits on Teams. When credits run out, the docs say review falls back to a smart diff viewer rather than stopping entirely. DeepWiki, the generated repository wiki, produced a navigable overview of my test repository that was accurate on module boundaries and thin on business intent, which is the pattern I expect from documentation generated from code alone. The Free plan is a genuine trial rather than a teaser: light quota, unlimited Tab completions and unlimited inline edits, plus access to Devin Review and DeepWiki, so a developer can keep the entire editor-side experience and pay only when they want cloud agent sessions. On the paid tiers the models are a selling point in their own right — the pricing page lists frontier models from OpenAI, Claude and Gemini alongside open-source options, with SWE-2 free on Pro.

Limits

Spec-dependence is the big one, as above. It does not know your product intent, and it will not push back on a bad ticket — it will implement it. Review remains mandatory: for security-sensitive code or anything touching data migrations, the PR is a draft, not a deliverable.

Second, cost predictability. The quota model is fine until it is not: heavy weeks trigger on-demand purchases at API pricing, and the automation layer consumes credits invisibly per run. Teams without an admin watching usage can drift upward. The Max plan at $200/month exists precisely because serious delegation exceeds Pro's quota quickly.

Third, ecosystem caveats. Enterprise features (VPC deployment, SSO, dedicated support) are sales-gated; Devin Review's free public-PR page is a funnel to the paid product; and the Windsurf acquisition means the roadmap now spans agent, IDE and desktop surfaces, which is either integration depth or roadmap risk depending on your temperament. The phrase the first AI software engineer still overstates what it does — it plans, codes, runs and tests within sandboxes and known tooling, and it flails outside them.

Verdict

Devin is the most complete autonomous coding workflow I have tested, and with Pro at $20/month it is finally priced like something you can point at a real backlog instead of a demo. Give it well-scoped tickets and it returns mergeable PRs with real time savings; give it vague ones and it returns review debt. I rate it 3.9 on the rubric — deep core functionality at the delegation workflow and fair value at the current pricing ladder, with deductions for spec-sensitivity, credit-drift risk on heavy use, and the reality that human review is still the last line of defense on every PR it opens.

Sources

• https://devin.ai/pricing
• https://docs.devin.ai/admin/billing/self-serve
• https://cognition.com/blog/introducing-devin
• https://cognition.com/blog/windsurf
• https://techcrunch.com/2025/07/14/cognition-maker-of-the-ai-coding-agent-devin-acquires-windsurf
• https://www.usagepricing.com/blueprint/cognition
• https://costbench.com/software/ai-computer-use/devin-cognition
• https://techcrunch.com/2025/04/03/devin-the-viral-coding-ai-agent-gets-a-new-pay-as-you-go-
• https://docs.devin.ai/
• https://devinreview.com