@gabriel1 This is a native feature of @DevinAI and ships (optionally) with every PR!

https://t.co/90lV4AbiWg

Testing & Video Recordings - Devin Docs

Source: https://docs.devin.ai/work-with-devin/testing-and-recordings 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 entertesting 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. ClickTest the appto have Devin start the testing workflow.

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 codebaseto understand what needs testing
• Checks for relevant skillsin the repo (under\.agents/skills/) and follows them if found
• Logs into required servicesand resolves access issues
• Checks available environments(staging, dev, local) and verifies connectivity
• Requests missing secretsfrom you if needed — Devin will ask for credentials up front and save them for future sessions

Phase 2: Test planning

Once setup is complete, Devin writes a short test plan:

• Identifies thesingle most important end-to-end flowthat 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 — aquick sanity checkwith 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 aSkillvia 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 theSkills guidefor 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:

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 usingsecrets, use theInteractive Browserto complete authentication steps manually, or completeenvironment configurationto pre-configure access so Devin doesn’t run into these issues.