Cognition Starts Work at the Pull Request

Key points

• When a ticket gets a label or an error log appears, an agent starts investigating before a person looks.
• Engineers start from a pull request the agent has already opened, not from a blank page.
• Cognition charges for usage, not seats, and gives enterprise customers a guarantee tied to estimated engineer hours.

How does a coding-agent company use its own product?

A software team’s day is long and mostly manual. A customer complaint or an outage alert comes in. An engineer scans system logs, queries the database to find the cause, fixes the code, and runs the tests. Then they open a pull request, a bundle of code changes, and ask a colleague to review it. The bottleneck has always been the people who write and review the code.

Cognition makes Devin, a coding agent that runs in the cloud. Engineering teams hand it tickets, bug reports, and pull request reviews, and it opens pull requests of its own. Devin goes after the daily work of software engineers: fixing bugs, writing tests, migrating old code, updating documentation, and reviewing changes. Its customers include large companies and systems integrators. In September 2026, Cognition said it had passed $1 billion in annualized revenue run rate.

In its first public post, in March 2024, CEO Scott Wu described the company as “an applied AI lab focused on reasoning” and Devin as “the first AI software engineer.” Cognition dates its founding to January 2024. Wikipedia says 2023. The engineers say they have used Devin to build Devin from the start.

One fact needs to be said plainly. Cognition was not founded to run the whole company on agents. Devin’s share of its own engineering grew over time. And the part of the company that works around agents is the engineering team, not everyone. Cognition says it had 44 employees before it bought Windsurf, an AI code editor company, in July 2025. A year later it had 350. The deal brought in Windsurf’s people. The company said Cognition needed a sales organization and Windsurf needed engineering strength. Today, a large share of the staff sells the product and supports customers.

How agents finish the investigation before a person steps in

In a February 2026 post, How Cognition Uses Devin to Build Devin, Cognition described its internal way of working in detail. Its basic rule is “Treat Devin like a team member.” The work falls into four parts.

The first part is assigning work. The key point is that the agent sits right where work begins. Engineers call on Devin through six routes: the web app, Slack, Linear, Jira, a command-line tool, and a dedicated API. They tag Devin in a Slack thread, the everyday messenger, or on a Linear ticket, the work-tracking tool. They attach files and talk back and forth.

Some work starts with no person at all. Tools like Sentry, which tracks system errors, spot a crash log, a bug report, or a failed deploy and start a Devin session right away. For example, when a Linear ticket gets the label Bug, a saved routine called !triage-bug runs on its own. Devin finds the relevant code and checks the git history, which is the version-control record, and the logs in Datadog, the monitoring system. Then it leaves a comment on the ticket with the likely cause, the affected files, and a suggested fix. Cognition calls these saved routines Playbooks. A Playbook is a reusable set of instructions. It lists the goal, the concrete steps, what must be true when the work is done, and what the agent must never do.

For bugs in the live service, Devin goes deeper. It collects logs, queries a read-only copy of the database, and finds which code commit broke the system. Then it writes the fix, together with a regression test that keeps the old mistake from coming back, and opens the pull request itself. Cognition puts it this way: “We review the PR, not the logs.” The agent takes over the root-cause work that engineers used to do first.

The second part is review. An agent reviews the code an agent wrote, and a person makes the final call. Every pull request is set up to go through Devin Review. This system reorders large code changes (diffs), which are hard for a person to take in at a glance, so they read from top to bottom. It also finds spots likely to be bugs and marks them with a confidence score. The company says these marks are information, not a final verdict.

Then a feature called Autofix takes over. It has the agent keep fixing the code until it clears the flagged bugs and passes two kinds of checks. One is continuous integration (CI), which automatically builds and tests code when it is merged to catch defects. The other is lint, which catches code-style problems automatically. A February 2026 post says this fix loop “massively increased our internal token spend on Devin.” As a result, it says, “The human’s job narrows to the decisions that require judgment.” Cognition’s November 2025 performance review says human engineers still review code and read the logic of the tests Devin wrote. The code owner, the person finally responsible for that code, checks the test coverage directly.

Testing follows a similar division of labor. In a May 2026 post, an engineer described a test mode in which Devin writes its own test plan from the source code. It logs into the app with a fixed script, clicks through the screens a user would click, and submits screenshots and a recorded video as results. Each check is marked passed, failed, or untested. This way, engineers ran 10 to 20 Devins at the same time, each with its own dev server. A person steps in only briefly, to supply secrets that the system needs for access, or to type in a one-time login code (OTP).

The third part is auditing code that has already been merged into the product. Every morning, Devin scans all the pull requests merged in the past 24 hours. It looks for colors written directly into the code, odd spacing, and components that were made on the spot when they should have come from the shared design library. When it finds a problem, it creates a Linear ticket and, if needed, opens a pull request with the fix. Another feature, Session Insights, looks back at finished agent sessions and suggests how to write better prompts next time. The engineering team also follows its agent guide. It keeps a list of mistakes developers often make. Instead of writing lint rules one by one, it has an agent check each new pull request against that list.

The fourth part is the change in developers’ roles. The center of gravity has moved from typing code to reviewing it. The February 2026 post says: “As we ship more code with agents, the bottleneck shifted from writing code to reviewing it.” The guide says plainly: “On our team today, engineers are expected to oversee multiple systems.” People outside engineering can now ask Devin for code changes without learning Git commands. DANA, a version of Devin that acts as a data analyst, answers questions about metrics in Slack through a /dana command. It replies with a chart and the SQL query behind it.

Hiring changed too. In August 2025 on the Cheeky Pint podcast, Scott Wu said that developer candidates are asked to “build their own Devin in eight hours.”

Over time, Cognition has shared several numbers on how much Devin works inside the company. Each number measures something different:

• May 2025: According to the show notes for an interview with Lenny’s Newsletter, the engineering team had 15 people. Each engineer worked with about five Devins. Devin made 25% of the company’s pull requests.
• November 2025: Devin wrote and pushed about a third of the commits that went into Cognition’s web application.
• February 2026: In a single week, Cognition merged 659 pull requests made by Devin. Its highest weekly count in 2025 was 154.
• May 2026: “89% of code committed by our engineers is committed by Devin.” The rest was written by the local agent in Devin Desktop, the revamped version of the Windsurf code editor.
• July 2026: In an interview recapped by Sourcery, Scott Wu said the share was about 95%.

Devin use inside Cognition

The company is open about what Devin still cannot do well. It does best on tasks with a clear scope and a clear way to check success. Big jobs must be broken into small pieces first. It cannot do mobile testing, which means trying the app on a real phone screen. Visual design has clear limits too. Cognition says: “Devin excels at building interfaces that work; styling them beautifully is still a human strength.”

Work starts at the pull request, and billing follows usage

The biggest difference between the usual way of building software and Cognition’s way is where a person stands in the pipeline.

In a typical team, an engineer opens a ticket, watches the monitoring screen, and writes the code line by line. Near the end, they ask a colleague to review it. People stand at the front of every step, and machines are helpers. At Cognition, by the company’s own account, an agent sometimes opens the ticket before any person has looked at it, and a second agent reviews and fixes the result. A person first joins the work at the pull request, when the root-cause analysis and the first draft of the code are already in place. The engineer’s attention goes to defining the problem, judging whether the change is right, and deciding what to ship. Cognition says the same thing from a product point of view: “code review—not code generation—is now the bottleneck.”

The second difference is that checking does not stop once code is merged. In many organizations, busy colleagues miss design-rule and coding-style violations during review, and technical debt builds up. Every morning, Cognition has an agent inspect everything merged the day before and turn what it finds into work tickets. Review is no longer a favor asked of a colleague. It is a standing daily job done by an agent.

The third difference is how repeated work gets started. When a bug label is added, a deploy fails, or a crash is reported, an agent session starts at once under a predefined Playbook, with no person touching anything. Repeated work does not rely on someone’s memory. It is written down once as a good manual and runs mechanically.

The same philosophy shows up in billing. Cognition charges by actual usage, not by seats, which are priced per user. Self-serve plans include a base amount of usage, and anything over is billed in dollars at the cost of the underlying model. Enterprise plans are billed in Agent Compute Units (ACU), a unit of work compute.

Since June 2026, Cognition has also offered a productivity guarantee to enterprise customers. For each Devin session that produced useful results, its own system estimates the engineering time a person would have needed. If, near the end of the annual contract, the value of that saved time is less than what the customer paid, the pledge is: “Cognition will fund your usage up to $10M.” The time-saved estimate is Cognition’s own method. It was checked against 258 customer sessions that real users had labeled by hand.

What a review-centered team teaches other companies

If most organizations that build software adopt agents, the industry could change in two big ways.

First, the structure of software teams could be rebuilt around review, not code writing. Once agents produce most of the code, the most valuable skill is no longer typing code fast. It is the judgment to find errors in the agent’s changes quickly and sharply. Cognition itself could not read all the incoming pull requests, so it had to bring in Devin Review. Any organization that takes on coding agents in earnest may face a flood of pull requests too large for people to read carefully. In an interview reported by TechCrunch, Scott Wu stressed that “it should always be up to the human what to do.” However much code machines write, the final responsibility for choosing what goes into the service stays with people.

Second, the traditional seat-based pricing of software, charged by number of users, could come under serious challenge. For a long time, developer tools were sold as a flat fee per developer. Cognition sells by usage. For large companies, it also compares the value of the human engineers’ time the agent saved against the bill. If buyers start to ask that software costs be tied to the work actually produced, software companies that have simply charged per head could find themselves having to prove exactly how much value their tool creates for each seat.

Leaders in other industries can take five practical lessons from Cognition’s operating model:

• Place agents where work first comes in. If an agent sits in a messenger thread, a work ticket, or a monitoring alert system, a person can hand off a task with one tag or one label.
• Write repeated work down as clear instructions. If you sort triage and response procedures into goal, steps, completion conditions, and prohibitions, and keep them as Playbooks, the quality of the work stays at the same level every time.
• Do not replace human review with agents. Put an agent just before the human review. Let agents fix grammar errors and mechanical defects among themselves, so people can focus on final approval and strategic judgment.
• Run regular audits after the work is done. A daily check agent can find the mistakes that reviewers overlooked and turn them back into a task list.
• Draw a clear line around what stays with people. Visual design quality, final business judgment, and tests that need real physical devices should be left in human hands.

What is still unproven

Cognition’s results and way of working are impressive. But there are some limits to keep in mind before applying them to ordinary companies.

Above all, Cognition was not founded to run purely on an agent system. It raised its reliance on agents step by step while building Devin. Most of its 350 employees today came on in the process of acquiring and merging with Windsurf in the summer of 2025. A large share of them are not developers who write code. They are traditional staff who sell the product and support customers.

Also, the details of the published workflow and the productivity numbers all rest on Cognition’s own announcements and the CEO’s press interviews. Behind the claim that Devin handles 89% or 95% of engineer-committed code, the actual number of internal engineers has not been disclosed. The numbers from the Lenny’s Newsletter and Sourcery interviews also come from summaries, not full transcripts. And the published numbers measure different things in different contexts: the number of pull requests, the commits to one particular web app, and the total amount of committed code. That makes them hard to join into one consistent growth trend.

Finally, Cognition is a company that packages its own way of working as a software product and sells it. Tech blog posts about how useful its own team finds Devin are reports that show how the company works. At the same time, they are marketing content meant to encourage enterprise customers to buy.

---

Sources

1. Cognition — How Cognition Uses Devin to Build Devin — https://cognition.com/blog/how-cognition-uses-devin-to-build-devin — 2026-02-27
2. Cognition — Closing the Agent Loop: Devin Autofixes Review Comments — https://cognition.com/blog/closing-the-agent-loop-devin-autofixes-review-comments — 2026-02-10
3. Cognition — Verifying Agentic Development at Scale — https://cognition.com/blog/testing-development — 2026-05-29
4. Cognition — Devin’s 2025 Performance Review: Learnings From 18 Months of Agents At Work — https://cognition.com/blog/devin-annual-performance-review-2025 — 2025-11-14
5. Cognition — More Devins in More Places — https://cognition.com/blog/series-d — 2026-05-27
6. Cognition — One Year of Building Together — https://cognition.com/blog/one-year-of-building-together — 2026-07-14
7. Cognition — Cognition Crosses $1B in Annualized Revenue Run Rate — https://cognition.com/blog/1b-run-rate — 2026-09-25
8. Cognition — Introducing Devin, the first AI software engineer — https://cognition.com/blog/introducing-devin — 2024-03-12
9. Cognition — Devin Review: AI to Stop Slop — https://cognition.com/blog/devin-review — 2026-01-21
10. Cognition — AI should earn its keep: Introducing the AI Productivity Guarantee — https://cognition.com/blog/ai-guarantee — 2026-06-04
11. Cognition — Estimating the Productivity of an Autonomous AI Software Engineer — https://cognition.com/blog/ai-productivity — 2026-06-04
12. Cognition — New self-serve plans for Devin — https://cognition.com/blog/new-self-serve-plans-for-devin — 2026-04-14
13. Cognition — Coding Agents 101 (guide) — https://devin.ai/agents101 — accessed 2026-10-22
14. Lenny’s Newsletter — Inside Devin (Scott Wu interview, show notes) — https://www.lennysnewsletter.com/p/inside-devin-scott-wu — 2025-05-04
15. Cheeky Pint — Cognition CEO Scott Wu on acquiring Windsurf, AI replacing engineers, and the Moneyball-ification of everything — https://cheekypint.substack.com/p/cognition-ceo-scott-wu-on-acquiring — 2025-08-27
16. TechCrunch — Cognition’s Scott Wu says AI coding agents shouldn’t replace humans — https://techcrunch.com/2026/05/29/cognitions-scott-wu-says-ai-coding-agents-shouldnt-replace-humans/ — 2026-05-29
17. Sourcery — BREAKING: “Devin Writes 95% of Our Code” Scott Wu, CEO of Cognition (interview recap) — https://www.sourcery.vc/p/breaking-devin-writes-95-of-our-code — 2026-07-28
18. Wikipedia — Cognition AI — https://en.wikipedia.org/wiki/Cognition_AI — accessed 2026-10-22