Instructing Devin Effectively

Do: Provide Clear Directives

• Why: Devin can get stuck without a clear path or when faced with too many interpretations.
• How:
  • Make important decisions and judgment calls for Devin.
  • Offer specific design choices and implementation strategies.
  • Define clear scope, boundaries, and success criteria.
• Example: “Optimize the getOrderDetails query in orderService.js by adding a composite index on the order_id and product_id columns in the order_items table. Refactor the query to replace the existing correlated subquery with a JOIN to the products table for fetching product details.”

Don’t: Leave Decisions Open-Ended

• Why: Vague instructions can lead Devin to implement solutions that don’t align with your actual needs.
• How:
  • Avoid statements that require Devin to make significant design or implementation decisions without guidance. This can lead to unexpected results.
• Example: Don’t: “Improve our database’s performance.”

Do: Pick tasks that Devin is good at

• Why:
  • Maximize Results: By assigning tasks that align with Devin’s capabilities, you can get the best results for the least amount of effort and ACUs spent. Asking Devin to do tasks that are far outside its current capabilties can often lead to poor results.
• How:
  • Read this guide: When to use Devin
  • Especially for advanced tasks, provide examples, modules, resources, and templates that Devin can follow.
    • Share direct links to docs sites so Devin can read about details like API request bodies and features it might not know about.
    • Share specific filenames that you want Devin to look at and learn from
  • Example: Do: “Refactor state management in the Header component to use React’s useReducer hook for better scalability and maintainability. Ensure that all existing functionality is preserved and add unit tests to cover the new state logic.”
  • Example: Do: “Use authTemplate.rs as a reference to maintain consistency in error handling.”
  • Example: Do: “Check out the official Sequelize docs at https://sequelize.org/docs/v6/getting-started/ for migration steps.”

Don’t: Assign Tasks Outside Devin’s Core Competencies

• Why: Assigning tasks that require advanced domain knowledge or heavy design decisions without adequate guidance can lead to inefficiency and wasted ACUs.
• How:
  • Avoid tasks that demand significant creative or high-level strategic input without clear instructions or references.
  • Avoid tasks that require visual abilities, i.e. UI design since Devin doesn’t see the way people do.
  • Avoid asking Devin to create mobile apps since it doesn’t have access to a phone and can’t easily test its work.
• Example: Don’t: “Create a new authentication system for my website from scratch.”
• Example: Don’t: “Turn this Figma mockup into a React component.”
• Example: Don’t: “Build an AI-powered shopping app.”

Do: Collaborate by Completing Partial Tasks

• Why: Sometimes it’s faster for you to finish the last 20% of a task.
• How:
  • Let Devin handle most of the implementation, then refine.
  • Use Devin to expedite the parts of the workflow that are repetitive, while you focus on more critical aspects.
• Example: Do: “Generate the initial boilerplate code for the new API endpoint, then I will integrate it with the existing authentication system.”

Don’t: Rely Solely on Devin for Entire Complex Projects

• Why: Over-reliance on Devin for tasks that require nuanced understanding or creative problem-solving can cause delays and suboptimal results.
• How:
  • Avoid assigning Devin tasks that you know will require significant human intervention to complete effectively.
• Example: Don’t: “Develop the entire backend infrastructure for our new gen AI feature”

Do: Establish Clear and Frequent Checks

• Why: Frequent feedback (both from you and from tests/checks/linters) ensures Devin corrects mistakes effectively.
• How:
  • Use tests (unit/integration) to confirm correctness.
  • Maintain build validations, lint checks, and static analysis for code quality.
  • Track progress in the Worklog
• Example: Do: “Run npm test after each iteration.”
• Example: Do: “Ensure the pipeline on CircleCI doesn’t fail.”
• Example: Do: “Pass ESLint/Prettier checks before pushing any commits.”

Don’t: Neglect Providing Feedback

• Why: Without feedback, Devin won’t know if its solutions meet your standards.
• How:
  • Avoid assigning tasks without defining how you’ll evaluate them.

Do: Set Clear Checkpoints and Sub-Tasks

• Why: Breaking down complex tasks into smaller checkpoints helps Devin stay focused and reduces errors.
• How:
  • Split tasks into verifiable sub-tasks, and start one Devin session for each sub-task.
  • Define what success looks like for each sub-task and optionally set checkpoints within each sub-task.
  • Ask Devin to report back after completing each checkpoint or sub-task.

Examples:

• Example: Do: “When working with the dataset, verify that it has at least 500 rows and contains columns X, Y, Z.”
• Example: Do: “When modifying the API, confirm the endpoint returns status 200 and includes all required fields.”
• Example: Do: “When updating UI, check that the component renders without console errors and matches the design spec.”

Don’t: Skip Specific Validation Requirements

• Why: Without defined validation steps, Devin cannot confidently complete tasks.
• How:
  • Avoid vague success criteria.
  • Don’t leave verification steps implicit or undefined.
• Example: Don’t: “Make sure it works.”

For repetitive or complex tasks, we suggest using and iterating on Playbooks. Learn more about using playbooks effectively. Playbooks are reusable and shareable prompts that streamline task delegation. For example, if you want Devin to address ongoing CI build failures, create a playbook that includes the general steps Devin should follow each time.