Skip to main content
Devin can test your application end-to-end after creating a PR — running the app locally, interacting with it through the browser, and recording a video of the entire process. The recording is sent directly to you as an attachment so you can verify the changes work without pulling the branch yourself.

​
How It Works

After Devin creates a PR, it can enter testing mode — a structured workflow where Devin:
  1. Sets up the environment — installs dependencies, starts services, logs into required accounts
  2. Plans the test — reads the diff and codebase to create a minimal, focused test plan
  3. Records a video — starts a screen recording, executes the test plan in the desktop, and annotates key moments
  4. Sends you the result — stops the recording, processes the video, and sends it to you as a message attachment
The goal is a short recording that a code reviewer watches and immediately thinks “yep, it works” — then merges the PR.

​
Triggering a Test

After creating a PR, Devin will offer to test the app for you. Click Test the app to have Devin start the testing workflow.
Test the app button
A setting to automatically run testing after PR creation — without needing to click the button — is coming soon.
You can also ask Devin to test at any point during a session — for example, “test the changes you just made and send me a recording” or “verify the login page works and send me a video.”

​
The Testing Workflow

When Devin enters testing mode, it follows a structured three-phase process:

​
Phase 1: Setup

Before any testing begins, Devin prepares the environment:
  • Reads the PR and codebase to understand what needs testing
  • Checks for relevant skills in the repo (under .agents/skills/) and follows them if found
  • Logs into required services and resolves access issues
  • Checks available environments (staging, dev, local) and verifies connectivity
  • Requests missing secrets from you if needed — Devin will ask for credentials up front and save them for future sessions
Completing Repo Setup ahead of time makes testing much faster — Devin can skip installing dependencies, configuring services, and logging in at the start of each session.
When Devin asks for credentials during testing, it saves them as secrets for future sessions so you only need to provide them once.

​
Phase 2: Test planning

Once setup is complete, Devin writes a short test plan:
  • Identifies the single most important end-to-end flow that proves the feature works
  • Writes concrete, unambiguous steps (e.g., “click the button labeled Save at the top right” — not “find the save option”)
  • Grounds the plan in actual code — traces through the frontend to find the exact UI path to the feature
  • Only adds additional test flows if there’s a genuinely critical edge case
Devin sends you the plan as a short message before executing, so you can course-correct if needed.

​
Phase 3: Recording and execution

After CI is green and any review comments are addressed, Devin executes the test:
  1. Starts recording — captures the full screen
  2. Annotates key moments — adds text labels at important points (e.g., “Testing login flow”, “Feature confirmed working”) that appear in the final video
  3. Executes the test plan — interacts with the app through the browser, following each step
  4. Stops recording — the video is automatically processed with annotations and speed adjustments around key moments
  5. Sends the video — attaches the recording to a message so you can watch it directly

​
Video Recording Details

Devin’s screen recordings have several features that make them useful for review:
  • Annotations — Text labels appear at key moments in the video, marking what Devin is testing. The video slows down around annotated points so you can see the details.
  • Auto-zoom — The video automatically zooms into where Devin clicks and interacts, smoothly panning to follow the cursor and easing back out during idle moments.
  • Automatic processing — Raw recordings are processed to highlight important actions and compress idle time
  • Sent as attachments — Videos are attached to messages in your session, viewable directly in the Devin webapp or Slack
Recordings are designed to be short and focused — a quick sanity check with one primary end-to-end flow that proves the feature works. If you need more exhaustive coverage, use your existing test suites and CI rather than visual recording.

​
Skill Suggestions

After testing your app, Devin writes down what it tried and what worked — setup steps, environment configuration, how to start the app — and proposes creating or updating a Skill via PR. You can merge the PR as-is or tweak it to refine the instructions. Over time, this means Devin gets better at testing your project — each session’s learnings build on the last. You can also prompt Devin to do this at any time (e.g., “create a skill for how to test this app”). See the Skills guide for full details on creating and managing skills. Here’s an example of a testing skill: 
---
name: test-before-pr
description: Run the local dev server and verify pages before opening any PR that touches frontend code.
---

## Setup

1. Install dependencies: `npm install`
2. Start the database: `docker-compose up -d postgres`
3. Run migrations: `npx prisma migrate dev`
4. Start the dev server: `npm run dev`
5. Wait for "Ready on http://localhost:3000"

## Verify

1. Read the git diff to identify which pages changed
2. Open each affected page in the browser
3. Check for: console errors, layout issues, broken links
4. Screenshot each page at desktop (1280px) and mobile (375px) widths

## Before Opening the PR

1. Run `npm run lint` and fix any issues
2. Run `npm test` and confirm all tests pass
3. Include screenshots in the PR description
When writing or refining skills, be specific about what to verify:

Good instructions

  • “Test the checkout flow: add an item to cart, go to checkout, fill in the form, and verify the order confirmation page shows the correct total”
  • “Verify the dark mode toggle works on the settings page — text should be readable and no elements should disappear”
  • “Test that the CSV export downloads a file with the correct headers”

Vague instructions

  • “Test everything”
  • “Make sure the app works”
  • “Check that nothing is broken”

​
Troubleshooting

​
Devin didn’t offer to test

Testing mode is available on sessions where Devin creates a PR with code changes. If Devin didn’t offer, you can always ask directly: “Can you test these changes and record a video?”

​
Recording failed

If the recording fails to process, Devin will let you know. Common causes include the app crashing during testing or the video processing timing out. Devin can retry — just ask “Try recording again.” Recording files are stored on Devin’s machine, and Devin can send them to you at any time if you ask.

​
Devin can’t access the app

If Devin can’t reach your app during testing (e.g., login walls, VPN requirements), it will ask you for help. Provide credentials using secrets, use the Interactive Browser to complete authentication steps manually, or complete Repo Setup to pre-configure access so Devin doesn’t run into these issues.