Best Practices

How to structure work for Devin to maximize efficiency and ROI

Identifying the right use case for Devin is key to maximizing efficiency and return on investment (ROI). Below are best practices for selecting a use case that aligns with Devin’s strengths.

Best Enterprise Use Cases

Ideal Use Case Criteria
Large, high-business-value projects that can be broken into isolated & repetitive subtasks.
Tasks that require less than 90 minutes of manual engineering time.
Backwards-compatible tasks that can be independently validated and merged.

Devin’s Ideal Requirements

Requirement
High volume of repetitive subtasks (slices)
Tasks of junior engineer-level complexity
Isolated & incremental tasks
Objective & verifiable subtasks
(Recommended) Minimal project dependencies

If your task meets most or all of these requirements, it is an ideal candidate for Devin.

Crafting Devin’s Work

Selecting the right task type is crucial for maximizing Devin’s reliability.

Scenario	Reliability Concern	Task Type
Asking Devin to build complex, net-new features (even if repetitive)	Lower reliability at scale	Tall & Deep
Assigning Devin simple, well-defined tasks	Highly reliable and effective	Wide & Shallow

Tall & Deep vs. Wide & Shallow

A large backlog of simple, horizontally-scalable tasks (e.g., resolving SonarQube issues) can generate significant ROI when scaled across thousands of iterations.

The simpler the slice, the more reliable the overall project.

What to Slice

Great candidates for Devin:

• Migrations
• Refactors
• Modernizations
• Technical debt backlogs

For instance, when working on a code migration, it must be broken down into isolated slices, each handled by an individual Devin session.

Verification

A slice should be the smallest atomic unit of the project.

Example Slices
File
Notebook
Module

Requirement	Details
Time Limit	Each slice must take under 90 minutes of manual engineering work.
Verification	Must include a way to validate code changes, such as: - Running tests - Building the code - CI checks - A custom verification script

Devin must have a clear success/failure verification mechanism.

Avoid tasks with excessive dependencies or external systems. Devin excels at coding tasks.

Parallel Execution

Requirement	Description
Isolation	Each slice must be independent and backwards-compatible.
Parallel Execution	Utilize Devin’s parallelism to execute slices simultaneously.
Human Review	After each slice is completed, it should undergo human review before merging into main.

Scaling Considerations

Principle	Description
Slice-Level Reliability	Devin is optimized for maximum reliability at the individual slice level.
Scaling Consideration	When scaling across thousands of slices, maintaining high reliability is critical.
Error Impact	Even a small error rate can compound when executing at scale.

Best Practices for Task Definition

Requirement	Description
Clear step details	Provide explicit instructions for each slice.
End-to-end reference	A detailed guide or video helps ensure consistency.
Before/After examples	Offer multiple before/after code examples (input/output pairs).
Dependency access	Ensure Devin has all necessary dependencies for the task.

Devin excels in ongoing technical debt tasks (e.g., PR reviews, QA automation) when they are properly sliced and structured.

Migrations, modernizations, and refactors are strong use cases if they can be tackled incrementally. For example, a full-repository migration requiring all changes at once is not recommended.

Case Study: Nubank Migration Case Study