How to Leverage Devin — A Practical Guide

Since you're already familiar with concepts like context rot, MCPs, skills, and RPI, this guide skips the basics and focuses on actionable strategies to get the most out of me.

1. Prompt Engineering for Devin

The single biggest lever. My success rate scales directly with prompt specificity.

What works

Be opinionated. Make design decisions for me. Don't say "improve performance" — say "add a composite index on order_id and product_id in the order_items table and refactor the correlated subquery to a JOIN."
Reference existing code. Point me at files and patterns: "Use authTemplate.rs as a reference for error handling."
Link external docs. I can browse the web. Give me direct URLs to API docs, library references, or Figma files.
Define success criteria. "CI green," "all existing tests pass," "matches the style of ComponentX" — explicit pass/fail conditions keep me on track.
Step-by-step instructions for complex work. Break the task into numbered steps, each with a clear deliverable. Think of it like writing a spec for a junior dev who is good at following instructions precisely.

What doesn't work

Vague goals ("make the app look better")
Open-ended design decisions without guidance
Assuming I know your domain-specific conventions unless you've encoded them in Knowledge or Skills

2. Ask Devin (Scope Before You Build)

Use Ask Devin as your first step before any implementation session. This is probably the highest-ROI habit you can develop.

Workflow

Explore — Ask questions about how your code works, trace dependencies, understand architecture
Plan — Collaboratively scope the implementation approach with me
Launch — Start a full session directly from the Ask Devin conversation; I'll carry over all the context

Use cases

Onboarding to an unfamiliar part of the codebase
Scoping a feature before writing a line of code
Investigating how a bug could occur by tracing call paths
Generating a context-rich prompt that leads to a higher-quality session

The key insight: Ask Devin sessions are cheap (no ACU cost for the exploration phase) and dramatically improve the quality of the implementation session that follows.

Docs: https://docs.devin.ai/work-with-devin/ask-devin

3. DeepWiki — Auto-Generated Codebase Documentation

Every indexed repo gets a wiki with architecture diagrams, summaries, and source links. Ask Devin uses DeepWiki under the hood for grounded answers.

Tips

Steer generation with .devin/wiki.json in your repo root — specify repo_notes (priorities, important folders) and optionally pages (exact wiki structure)
Public repos — use deepwiki.com for free, no account needed
Regenerate after major refactors to keep the wiki current

Docs: https://docs.devin.ai/work-with-devin/deepwiki

4. Knowledge Notes — Teaching Me Your Preferences

Knowledge notes are how you permanently teach me things about your repos, workflows, and preferences. They persist across sessions and are auto-retrieved based on triggers.

What to encode

Coding conventions and style preferences
Preferred libraries and patterns
Testing commands and CI quirks
Architecture decisions and rationale
Common gotchas in your codebase

Management

I'll sometimes suggest knowledge after a session — review and approve these in your timeline
You can manually create notes at https://app.devin.ai/settings/knowledge
Notes can be scoped to specific repos or applied org-wide
Use triggers to control when notes activate (e.g., "when working on the auth module")
After I learn something in a session, I may suggest saving it — approve the useful ones

Docs: https://docs.devin.ai/onboard-devin/knowledge-onboarding

5. Skills (`.agents/skills/`) — Reusable Procedures

Skills are step-by-step instructions committed to your repo. They're different from Knowledge in that they live in code and are version-controlled.

Skills vs. Playbooks

	Skills	Playbooks
Where	`.agents/skills/` in your repo	Devin web app
Version controlled	Yes (git)	No
Scope	Repo-specific	Org-wide or personal
Best for	Repo-specific procedures (test setup, deployment, login flows)	Cross-repo workflows, templates for common tasks

High-value skills to create

Dev environment setup — how to install, build, and run your project
Testing procedures — which commands, which test accounts, what to verify
Login/auth flows — Playwright scripts for SSO/OAuth that I can replay via CDP (http://localhost:29229)
Deployment procedures — how to deploy, what to verify post-deploy

Docs: https://docs.devin.ai/product-guides/skills

6. Playbooks — Templated Workflows

Playbooks are reusable prompt templates stored in the Devin app. Select one when starting a session to pre-fill instructions.

Good playbook candidates

Bug triage and fix workflows
PR review checklists
Migration patterns (e.g., "migrate file X from framework A to B, follow this pattern")
Onboarding new services or modules

Creating playbooks

Create via the Devin web app or API
Can include dynamic variables that get filled in per-session
Especially powerful when combined with scheduled sessions or the API for automation

Docs: https://docs.devin.ai/product-guides/using-playbooks

7. Devin Review — AI Code Review + Auto-Fix

This closes the loop on PRs. Enable it and I will:

Auto-review PRs when they're opened, pushed to, or marked ready
Catch bugs with confidence-level labels
Auto-fix review comments and CI failures without you in the loop

Setup

Go to Settings > Review in the Devin app
Self-enroll — any user with a connected GitHub account can enroll
Configure per-repo or per-user trigger modes (auto review on all events, or on PR creation only)

Pro tips

Use the URL shortcut: replace github.com with devinreview.com in any PR URL
You can leave comments, approve, request changes, merge, and toggle auto-merge — all from within Devin Review
The codebase-aware chat in Devin Review lets you ask questions about a PR with full repo context

Docs: https://docs.devin.ai/work-with-devin/devin-review

8. Parallelization — Multiple Devins at Once

This is where Devin really shines for large-scale work.

Managed Devins (child sessions)

You can ask me to spawn child sessions that run in parallel on separate machines. Each child gets its own VM, shell, and browser.

Example: "Migrate these 50 files from Jest to Vitest. Spin up a managed Devin for each batch of 5 files."

Manual parallelism

Open multiple Devin sessions from the web app, each tackling an independent task
Use Ask Devin to plan the decomposition, then launch parallel sessions

Best practices for parallelism

Each slice must be independent and backwards-compatible
Keep slices small (under 90 min of equivalent manual work)
Use a playbook to ensure consistency across parallel sessions
Plan for human review of each PR before merging to main

Docs: https://docs.devin.ai/work-with-devin/advanced-capabilities

9. Scheduled Sessions — Automate Recurring Work

Set up sessions that run on a cron schedule. Pre-built automation templates include:

Template	What it does
Daily Sentry Error Fixes	Triages and fixes Sentry errors automatically
Weekly Dependency Updates	Updates dependencies and opens PRs
Dependency Vulnerability Scanner	Scans for security vulnerabilities
Secret Scanner	Checks for leaked secrets
Stale PR Cleanup	Closes or updates stale PRs
Nightly QA Smoke Tests	Runs E2E tests nightly
Weekly Changelog	Generates changelogs from merged PRs
Code Pattern Enforcer	Enforces coding patterns across the codebase
Figma Design Review on PR	Compares PR screenshots against Figma designs
Jira Ticket to PR	Picks up Jira tickets and implements them
`/devin` Issue Fix	Responds to GitHub issues tagged with `/devin`

You can also create custom scheduled sessions with your own playbooks.

Docs: https://docs.devin.ai/product-guides/scheduled-sessions

10. Integrations & MCP Marketplace

Native integrations

Slack / Teams — Tag me in a thread to start a session. I'll respond in-thread with updates.
Jira / Linear — I can pick up tickets directly and create PRs linked to them.
GitHub / GitLab — Full PR lifecycle, code review, CI monitoring.

MCP integrations (extend my reach)

Connect me to external tools via the MCP Marketplace:

Monitoring: Datadog, Sentry — I can investigate production issues
Design: Figma — I can read designs and implement from them
Databases: Query and modify data during development
Docs: Notion, Confluence — I can read and reference your documentation
Payments: Stripe — I can work with payment APIs
Hundreds more available

Setup: Go to Settings > Integrations in the Devin app or manage via the MCP settings page.

Docs: https://docs.devin.ai/integrations/overview

11. Environment Configuration — Set It Up Once

Configure your dev environment so every future session starts ready to go.

What to configure

Repo-level config — dependencies, build steps, env vars, VPN, database setup
Org-level config — shared tooling (Node version, Rust toolchain, CLI tools) that applies across all repos
Secrets — store API keys, tokens, and credentials (org-scoped, user-scoped, or repo-scoped) so I never have to ask for them again
Browser profiles — save logged-in browser state so I don't need to re-authenticate

How

Ask me to "set up the environment" and I'll read your README, install everything, and suggest a config
Manage configs at https://app.devin.ai/settings/environment
Secrets at https://app.devin.ai/settings/secrets

Docs: https://docs.devin.ai/onboard-devin/repo-setup

12. Testing & Video Recordings

I have a full desktop environment. I can:

Spin up your app locally and interact with it in a real browser
Click through UI flows, fill out forms, verify behavior
Record screen recordings of my testing with annotated test results
Take screenshots to include in PR descriptions

How to use this

After I create a PR, you can ask me to test it
Say "Record yourself testing the checkout flow end-to-end"
I'll produce a video with pass/fail annotations you can review

Docs: https://docs.devin.ai/work-with-devin/testing-and-recordings

13. Session Insights — Learn from Every Session

After each session, Session Insights provides:

Timeline analysis of what happened and where I got stuck
Improved prompt suggestions — a better version of your original prompt for next time
ACU usage breakdown
Actionable feedback for future sessions

Use this to iterate. If a session didn't go perfectly, the insights will tell you what to change.

Docs: https://docs.devin.ai/product-guides/session-insights

14. The Devin API — Programmatic Orchestration

For power users, the API lets you:

Create sessions programmatically
Attach playbooks and structured output schemas
Poll session status and retrieve results
Build custom CI/CD integrations
Orchestrate large-scale migrations with hundreds of parallel sessions

Docs: https://docs.devin.ai/api-reference/overview

15. Slash Commands

Quick actions you can use in GitHub:

Command	What it does
`/devin`	Triggers Devin on a GitHub issue to investigate and fix
`/review`	Triggers a Devin code review on a PR

Docs: https://docs.devin.ai/work-with-devin/slash-commands

Quick-Start Checklist

Here's a prioritized list of things to set up roughly in order of impact:

Index your repos — enables Ask Devin and DeepWiki
Configure your environment — so every session starts ready to build/test
Store your secrets — API keys, tokens, test credentials
Enable Devin Review + Auto-Fix — closes the PR feedback loop
Create 2-3 Knowledge notes — coding conventions, preferred patterns, common gotchas
Write one Skill — dev setup + testing procedure for your main repo
Create one Playbook — for your most common task type (e.g., "fix a bug in repo X")
Set up a Scheduled Session — dependency updates or Sentry triage
Connect Slack/Teams — so you can tag me from conversations
Install relevant MCPs — Figma, Datadog, Sentry, etc. as needed

High-Value Use Cases to Try First

Use Case	Why it works well
Bug fixes with reproduction steps	Clear success criteria, testable
Test coverage gaps	I can analyze what's untested and write tests
Dependency upgrades	Mechanical, parallelizable, CI-verifiable
Code migrations/refactors	Repetitive, pattern-following, sliceable
Documentation generation	I can read your code and produce docs
CI/CD improvements	Well-defined, testable outcomes
API integrations	I can read docs, implement, and test
Clearing engineering backlogs	Jira/Linear integration + parallel sessions
Prototyping	Fast iteration on new ideas
Learning unfamiliar codebases	Ask Devin + DeepWiki

Key Links

Resource	URL
Devin App	https://app.devin.ai
Docs	https://docs.devin.ai
When to Use Devin	https://docs.devin.ai/essential-guidelines/when-to-use-devin
Effective Prompts Guide	https://docs.devin.ai/essential-guidelines/instructing-devin-effectively
Environment Settings	https://app.devin.ai/settings/environment
Secrets	https://app.devin.ai/settings/secrets
Knowledge	https://app.devin.ai/settings/knowledge
MCP Marketplace	https://app.devin.ai/settings/integrations
Devin Review	https://app.devin.ai/review
DeepWiki (public)	https://deepwiki.com
API Reference	https://docs.devin.ai/api-reference/overview
Automation Templates	https://docs.devin.ai/automation-templates/index

nickytonline/devin-cheat-sheet.md