How Cognition Uses Devin to Build Devin

Cloud Agents are hitting escape velocity, and the teams that figure this out first are going to pull away fast. This is how it actually looks inside a team that runs on cloud agents.

Originally posted on X.

Hi I’m Nader and I recently joined @cognition, the creators of @DevinAI.

Devin is a cloud agent platform for engineering teams. You work with Devin like a teammate - give it tasks in places like Slack or Linear, review its PRs, and let it handle your backlog.

After joining I wanted to understand how power-users were using Devin to accomplish real software engineering work.

Here’s what I learned:

Core Experience

The setup is this: add any of the codebases you’d like Devin to manage.

You’re then given a unified interface where you can work across all of your repos using natural language.

It’s designed as a conversational interface, so we can chat with it the same way we’d message a teammate - from Slack, the CLI, a Linear or Jira ticket, or the web app.

Tag @ Devin in any channel. Include attachments if needed. Communicate back and forth as you would in the regular chat interface.

A powerful result is that anyone is able to contribute regardless of their technical expertise or role in the company, they don’t need to understand and set up Git or any command line tools to start contributing to our codebases.

Tag @ Devin with a request and we get a PR we can review and test out.

If someone notices out of date documentation or a bug for example, they send a short message in Slack to get it fixed and move on with their day.

This removes friction and barriers for rapid iteration + polish. It also results in less context switching.

And when engineers see what their teammates are accomplishing with Devin, on the same codebase they work on every day, they have the “Oh, really? Devin can do that?” moment, so it spreads organically.

Devin Workspace

Devin has access to three core tools via the Devin Workspace:

Shell. Devin’s terminal where you can watch commands execute and view output logs. You can copy shell output for debugging or, when you take over, run commands directly.

IDE. An embedded VSCode environment with your repos loaded. You can watch Devin make edits in real-time, use all your favorite shortcuts, jump to definition, open files in tabs, etc…

Browser. Watch Devin browse documentation, test web applications it builds, or download information. You can jump in via the Interactive Browser to help with CAPTCHAs, multi-factor auth, or complex navigation.

The Progress tab brings all three together in one unified view. Click any step in a session to see exactly what Devin did.

Devin Review

As we ship more code with agents, the bottleneck shifted from writing code to reviewing it.

Devin Review turns large, complex GitHub PRs into intuitively organized diffs and precise explanations. We use it for every PR now.

Every time Devin posts a PR in Slack, it includes a Devin Review link, so the organized diff is always one click away.

What makes Devin Review useful:

• Autofix. If Devin Review or a GitHub bot flags bugs, Devin automatically fixes the PR. Devin also tackles CI/lint issues until all checks pass, closing the agent loop.

• Smart diff organization. Groups changes logically, putting related edits together instead of alphabetical order.

• Copy and move detection. Detects when code has been copied or moved and displays changes cleanly, instead of full deletes and inserts.

• Bug Catcher. Automatically analyzes PRs for potential issues and labels them by confidence level. Severe bugs require immediate attention. Non-severe bugs should still be reviewed. Flags are informational annotations.

• Codebase-aware chat. Ask questions about the PR and get answers with relevant context from the rest of the codebase.

For any GitHub PR link, you can replace github.com with devinreview.com in the URL.

Once Auto-Review is configured, Devin starts automatically reviewing PRs when they’re opened, when new commits are pushed, or when someone is added as a reviewer.

Ask Devin (Codebase Q&A)

Once you add a repository to Devin, it’s automatically indexed. Ask Devin becomes a window into that codebase.

We use this constantly for scoping work before starting sessions. The workflow: use Ask Devin to explore the code and clarify your goal, then start a session directly from the search interface.

Devin starts with clear context from your exploration, and the prompt is automatically tailored to your task.

This same workflow applies with Jira or Linear integrations.

Tag Devin on a ticket. Devin analyzes the task, searches the codebase, and plans its approach. It generates a high-quality session prompt automatically.

DeepWiki

With DeepWiki, Devin automatically indexes all repos and produces wikis with architecture diagrams, links to sources, and summaries of the codebase.

We use it to get up to speed on unfamiliar parts of the codebase. Ask Devin uses information in the Wiki to better understand and find relevant context.

For public repos ,deepwiki.com automatically generates architecture diagrams, source links, and documentation, no setup required.

We also maintain a free DeepWiki MCP.

DANA (Data Analyst Agent)

DANA is a specialized version of Devin optimized for querying databases, analyzing data, and creating visualizations.

We use it for questions about our data warehouse, building dashboards, and answering data questions without pulling an engineer off their work. It’s become a go-to for non-engineering tasks too - the kind of “click a bunch of buttons to fill out a report” work that used to eat up time.

We’re able to access DANA from the web app by clicking the agent picker dropdown, or from Slack using /dana or @Devin !dana followed by our question.

We’ve learned to be specific about metrics, include time periods, and ask for visualizations when they’d help.

DANA connects to your data warehouse through MCP - Redshift, PostgreSQL, Snowflake, BigQuery, whatever you’re running, and maintains its own database knowledge so it already understands your schema before you ask anything.

It’s optimized for concise, metrics-focused answers with built-in seaborn visualizations, so you get charts and insights back fast instead of waiting for an engineer to context-switch into a SQL client.

We’ve found it especially useful for the kind of ad-hoc questions that used to sit in someone’s queue for days - ‘why did signups drop Tuesday?’ or ‘break down consumption by enterprise vs self-serve’ - anyone on the team can just ask in Slack and get an answer with the SQL included so you can validate the logic.

Playbooks

A Playbook is like a custom system prompt for a repeated task.

If you find yourself repeating the same instructions across multiple Devin sessions, you want a Playbook.

Once anyone succeeds with Devin, others can replicate that success.

A good Playbook includes:

• The outcome we want Devin to achieve

• The steps required to get there

• Specifications describing postconditions

• Advice to correct Devin’s priors

• Forbidden actions

• Any required input or context from the person kicking it off

Playbooks unlock Devin’s ability to independently tackle complex work, from ingesting data into Redshift and performing database migrations to using diverse APIs like Stripe, Plaid, Modal, and Storybook.

MCP Marketplace

MCP enables Devin to use hundreds of external tools and data sources.

We use MCPs to dig through Sentry, Datadog, and Vercel logs. Connect database MCPs for data analysis in Slack. Pull context from tools like Notion, Airtable, and Linear.

Many can be enabled with a single click - Vercel, Atlassian, Notion, Sentry, Neon, Asana, Jam, and more.

Session Insights

Session Insights analyzes completed Devin sessions and provides actionable recommendations for improvement.

After Devin completes a task, Session Insights examines:

• Issues and challenges (technical problems, communication gaps, scope creep)

• Session timeline with key milestones and efficiency metrics

• Action items including immediate improvements and process optimizations

• Improved prompt suggestions with enhanced instructions

We use insights from one session to inform the next. You can spin up new sessions directly from the insights using the improved prompts. Over time, sessions get more efficient.

API Access

Devin exposes a full REST API, so agents don’t need a human in the loop to start working. Connect Devin to your existing systems and trigger sessions programmatically:

• A crash log lands from Sentry → Devin investigates and opens a PR

• A bug report is filed → Devin reproduces, diagnoses, and patches

• A deployment fails → Devin analyzes logs and suggests a fix

• A code review is requested → Devin reviews and leaves comments

Where Devin Excels

The most successful Devin tasks are quick for us to verify - checking that CI passes, testing an automatic deployment.

Tasks we consistently use Devin for:

• Targeted refactors

• Small frontend features

• Bug fixes and edge cases

• Improving test coverage

• Investigating CI failures

• Lint errors and CVE remediation

• Language migrations and framework upgrades

• PR review

• Codebase Q&A

• Writing unit tests

• Maintaining documentation

• Modernizations and migrations

• Remediating security vulnerabilities from static analysis

Our rule of thumb: if a junior engineer could figure it out with sufficient instructions, it’s a good Devin task.

What We Avoid

Large-scale challenges need to be broken into smaller, isolated tasks across separate sessions.

UI aesthetics require human help. Devin can build functional frontends but doesn’t have great eyesight for design polish.

Mobile development works, but Devin doesn’t have a phone to test with.

For anything requiring extensive testing and validation, we make sure verification mechanisms are in place.

Getting Started

Minimum Setup

1. Sign up at app.devin.ai

2. Connect your GitHub, GitLab, or Bitbucket

3. Add your first repository

4. Start a session with a simple task

Scaling Up

As you get comfortable:

• Add Knowledge to teach Devin your codebase conventions

• Create Playbooks for repeated tasks

• Connect Slack for inline collaboration

• Enable MCPs for your tools

• Use Ask Devin to scope complex work before starting sessions

Treat Devin like a team member. Give it context. Teach it your conventions. Let it handle the backlog while you focus on the work that requires senior judgment.

An AI software engineer with clear context, working autonomously on well-scoped tasks, is a force multiplier.

Built by the team at @cognition. If you’re building with @DevinAI, we’d love to hear about it.