Devin AI Demo: What to Watch and How to Try It

Cognition's public Nubank case study reports an 8x engineering-time efficiency gain and over 20x cost savings when engineers delegated a multi-million-line ETL migration to Devin instead of spreading the same refactor across a thousand-person manual effort. Official intro docs still describe Devin as a prompt-to-PR agent with shell, IDE, and browser tools. That gap between headline results and a short demo video is where most evaluation mistakes happen.

A Devin AI demo typically shows an autonomous session that plans work, edits code in a cloud environment, and opens a pull request for human review. Per Cognition's docs, Devin can write, run, and test code. The product rule of thumb is practical: if a human engineer can finish a task in about three hours, Devin can usually handle it. Harder work needs clearer prompts, smaller slices, or more human steering.

That framing separates a real demo from a polished trailer. You are not watching autocomplete. You are watching a session that:

• Accepts a task from the web app, a ticket system, or a team chat thread
• Plans in Ask mode or jumps into Agent mode when the scope is already clear
• Uses shell, embedded IDE, and browser tools inside Devin's workspace
• Commits changes and opens a PR for a human to approve, reject, or extend

When a walkthrough skips those steps, treat it as marketing footage. When it shows plan quality, tool use, CI feedback, and PR review, treat it as product evidence you can try to reproduce.

Official materials live in a few places, and each serves a different purpose.

Official starting points

Intro docs at docs.devin.ai/get-started/devin-intro: product overview, strengths, interface tools, and embedded demo media including a Slack issue workflow example

• First session guide at docs.devin.ai/get-started/first-run: Ask vs Agent modes, repository selection, agent types, and first-time prompt ideas
• Product site at devin.ai: use cases, customer stories, and signup entry points
• App signup at app.devin.ai: the place you actually run sessions after access is provisioned

Cognition also links broader customer write-ups and general availability notes from the docs. Prefer primary docs and current product pages over third-party recaps when you need accurate mode names or setup steps.

Evaluation checklist for any Devin walkthrough

Use the same checklist whether you are watching Cognition's media or a conference stage demo:

1. Task selection: Is the task scoped, verifiable, and close to real backlog work (bug, endpoint, tests, small refactor)?
2. Planning quality: Does the session show Ask mode or an explicit plan before large edits?
3. Environment honesty: Does the agent work in a cloud session with shell, IDE, and browser, not just a chat window?
4. Verification: Does Devin run tests, check logs, or wait on CI before claiming done?
5. PR shape: Is the output a reviewable pull request with a clear diff, not a pile of uncommitted files?
6. Human handoff: Can a teammate understand the change without replaying the whole session?

Demos that only show a confident plan and a green checkmark are incomplete. The PR and the review path are the product.

Entry points that change what you see

Official docs describe several ways to start work:

• Web app for most cloud sessions and interactive supervision
• Linear or Jira tickets for backlog-style assignment
• Slack or Microsoft Teams threads for bug reports and discussion-to-task handoffs
• Devin CLI for terminal-first work, with handoff to cloud Devin for longer tasks

A Slack-thread demo teaches triage and conversation context. A web-app demo teaches plan construction and live IDE takeover. A CLI demo teaches local-to-cloud handoff. Match the demo surface to the workflow you plan to adopt.

Official first-run guidance recommends a simple path: plan in Ask mode, then execute in Agent mode, unless the task is already fully scoped. Use this script when watching a walkthrough or reproducing one on your own repo.

1. Pick a three-hour task

Choose work with clear success criteria. Good first tasks from Cognition's own prompt gallery include:

• Add a small API endpoint and tests
• Add a focused frontend control that reuses existing styles
• Write unit tests for a known service with a coverage target
• Migrate a single module from JavaScript to TypeScript with compile and test checks

Avoid "redesign the architecture" as a first demo. Start with a task a teammate could finish in a short afternoon.

2. Plan in Ask mode

Ask mode explores the codebase and builds a plan without changing production code. Official docs describe two uses:

• Questions about how the code works, with advanced search and cited answers
• Planning that turns a vague request into a context-rich Agent prompt

What to watch: does the plan name files, acceptance checks, and edge cases, or does it stay abstract?

3. Move to Agent mode

When the plan is good enough, send it to Agent mode. Agent mode is the full autonomous path: write code, run commands, browse docs, and complete multi-step work. You can also start Agent mode directly for tightly scoped tasks.

When starting an Agent session, official docs say you configure at least:

• Repository selection so Devin has the right code and PR target
• Agent type, with default Devin for general engineering, Fast Mode for quick well-scoped work, and Dana for data-analysis style tasks

What to watch: repository choice, branch base, and whether the session stays inside the planned scope.

4. Follow tool use, not just chat

In Devin's workspace you should see shell activity, IDE edits, and browser use as needed. The demo is stronger when the agent:

• Inspects failing tests or logs instead of guessing
• Opens docs for unfamiliar APIs
• Avoids drive-by refactors outside the request
• Uses @ mentions or explicit file references when the human supplies them

Official first-run docs support @ mentions for repos, files, macros, playbooks, skills, secrets, and prior sessions. Good demos reduce ambiguity with those anchors.

5. Review the PR and complete the human handoff

The session should end with something a human can merge or reject:

• A pull request against the correct repository
• A readable description of what changed
• Evidence that tests or CI were considered
• Room for a human to take over in the embedded IDE if the draft is close but incomplete

Cognition's own workflow notes highlight successful patterns such as tagging Devin on a bug thread, delegating complex work in the web app and taking over for polish, using the CLI with cloud handoff for longer jobs, and batching morning backlog tasks into draft PRs waiting for review.

Keep Devin session outputs in one shared workspace

Store plans, review notes, and non-code deliverables where agents and humans can search, version, and hand off ownership. Fast.io exposes MCP over Streamable HTTP at /mcp, with a 14-day free trial on every org plan.

Start 14-Day Trial

Watching a Devin demo is useful. Running one against a repo you own is the only way to judge fit.

Before the first session Official first-run docs say to index repositories and set up Devin's environment before the first real task. That foundation is what lets Ask mode answer questions accurately and Agent mode edit the right tree.

Practical setup checklist:

1. Sign up or join an existing org at app.devin.ai
2. Connect the repository or repositories you want Devin to touch
3. Index the repos so codebase Q&A and planning have a real map
4. Confirm the cloud environment has the packages, secrets, and branch conventions your team uses
5. Optional: install the CLI with Cognition's install script if you prefer terminal workflows

The documented CLI install command is:

curl -fsSL https://cli.devin.ai/install.sh | bash

Use the official CLI docs for auth, local folder workflows, and /handoff to cloud Devin. Do not invent config keys or environment variables that Cognition does not document.

Prompt patterns that make demos succeed

Cognition's guidance is consistent across intro and first-run pages:

• Write clear prompts with explicit completion criteria
• Prefer tasks that are easy to verify (tests, CI, deploy checks)
• Break harder work into focused sessions
• Provide examples from your codebase instead of abstract requirements

Example shape for a first Agent prompt:

Create endpoint /users/stats that returns user count and average signup age.

Use the existing users table. Mirror response structure from /orders/stats
in statsController.js. Cover the new endpoint in StatsController.test.js
and report the test command you ran.

That prompt names the change, the reference implementation, and the verification step. Weak prompts like "improve the stats API" produce weak demos.

What "trying Devin" should prove in one afternoon

After one or two sessions on your own code, you should know:

• Whether Ask mode's plan matches how your team would scope the work
• Whether Agent mode stays inside the requested files
• How often you need mid-session steering
• Whether PR quality is close enough that review is cheaper than rewriting
• Whether ticket or chat entry points fit your team's habit better than the web app alone

If the first demo fails, inspect the prompt and the environment before concluding the product is a poor fit. Many poor results come from vague tasks, missing repo context, or success criteria the agent cannot check.

A Devin session produces more than a PR. You often get plans, logs, screenshots, notes, regenerated docs, and review comments that other people still need later. Git is the right home for code. It is a weak home for mixed session artifacts and cross-team handoffs.

Many teams keep those extras in local disks, object storage such as Amazon S3, or general file products like Google Drive or Dropbox. Those options work for raw storage. They break down when agents and humans need the same folder, semantic search, permission boundaries, and a clean ownership path after the agent finishes.

For that layer, an intelligent workspace such as Fast.io is a better fit than commodity storage alone. Fast.io is not built into Devin. It sits beside the coding agent as the place where session outputs become team assets:

• Shared org-owned workspaces so agents and humans open the same files
• Per-file version history when concurrent agent writes need auditability
• Intelligence Mode for auto-indexing and RAG-style questions with citations
• Metadata Views at /product/document-data-extraction/ when you need structured fields from PDFs, images, or docs rather than free-text search alone
• Branded shares (Send, Receive, Exchange) for durable or expiring access when product or client stakeholders need the deliverable without a git client
• Ownership transfer so an agent-built workspace can move to a human while admin access stays intentional
• Consolidated MCP tools over Streamable HTTP at /mcp (and legacy SSE at /sse) when other agents need to read or write the same workspace

A practical pattern after a Devin demo or first real session:

1. Keep the code change in the PR and the repository
2. Export or save the plan, test notes, and any non-code deliverables into a shared workspace
3. Index the workspace so teammates can ask "what did the agent change and why?"
4. Share a review folder with the right people instead of mailing zip files
5. Transfer ownership to the human owner of the project when the agent-built setup is ready for production use

That pattern keeps Devin focused on software engineering while the workspace layer handles persistence, search, and handoff. Plans start at Starter $29/mo, Business $99/mo, and Growth $299/mo, each with a 14-day free trial that requires a credit card.