Don't want to set this up manually? Paste a link to this page into a Devin session and ask it to set everything up for you. Devin has built-in access to its own documentation through the [Devin Docs MCP](/work-with-devin/devin-mcp) — no setup or configuration needed. It can search and read the full docs site, API reference, changelog, and best practices on demand. Instead of sending new engineers a list of docs links, have Devin distill exactly what your team needs into a single onboarding guide with prompts, workflows, and examples tailored to your stack. ```txt Generate a team-specific onboarding guide theme={null} Read the Devin documentation and create a getting-started guide for our engineering team. The guide should cover: 1. How to start a session (Slack vs. web app — when to use each) 2. Writing effective prompts (include file paths, error context, scope) 3. Setting up our Linear integration for ticket-driven workflows 4. Creating playbooks for our recurring Express-to-Fastify migrations 5. Adding Knowledge entries for our codebase conventions (e.g., "all API routes live in src/routes/, run npm run test:api") Tailor every example to our stack: Node.js, React, PostgreSQL. Format the output as a Notion page we can paste into #engineering. ``` Devin searches its docs for each topic, reads the relevant pages, and synthesizes a complete onboarding guide matched to your stack and workflow. Here's what the output looks like: ```markdown theme={null} # Getting Started with Devin — Acme Engineering Team ## 1. Starting a Session | Method | When to use | Example | |--------|-------------|--------| | **Slack** — message @Devin | Quick, scoped tasks | "Fix the failing CI in api-service" | | **Web app** — app.devin.ai | Longer tasks needing file attachments or playbooks | Attach a migration playbook + spec file | ## 2. Writing Effective Prompts Devin works best with specific, scoped requests. Always include the file path, what's broken, and when it started. ❌ "Fix the login bug" ✅ "The login form at src/pages/Login.tsx returns a 401 for valid credentials since the JWT key rotation on Friday. Check the auth middleware at src/middleware/auth.ts." ## 3. Linear Integration Go to Settings > Connections > Linear and authorize. Once connected, Devin can: - Pick up tickets assigned to it automatically - Update ticket status as it works - Link PRs to the originating Linear ticket See the full setup guide: docs.devin.ai/integrations/linear ## 4. Playbooks for Recurring Tasks Create reusable prompts at Settings > Playbooks > Create New. For our Express-to-Fastify migration, the playbook should include: - The target module path (e.g., src/services/payments/) - Test commands: npm run test:api && npm run test:integration - Rollback steps if the migration breaks downstream consumers ## 5. Knowledge — Teaching Devin Our Conventions Add team conventions at Settings > Knowledge > Create knowledge. Example entry: Trigger: "working on API routes" Content: "We use Fastify, not Express. All routes live in src/routes/. Run npm run test:api before committing. Error responses must use the ApiError class from src/lib/errors.ts." ``` Keep the same session open — Devin retains context and can extend the guide with additional sections. ```txt Add a prompt templates section theme={null} Add a new section to the guide: "Copy-Paste Prompt Templates." Include 6 templates our team can reuse for common tasks: bug fixes, feature implementation, test coverage, database migrations, dependency upgrades, and CI debugging. Each template should have placeholders like [file path], [error message], and [ticket link]. ``` ```txt Add a "What's New" section from the changelog theme={null} Read the Devin release notes and add a "What's New" section to the guide covering features released in the past month. Highlight anything that changes how we use playbooks, scheduled sessions, or the API. ``` ```txt Add a Knowledge vs. Playbooks decision table theme={null} Add a section to the guide explaining when to use Knowledge vs. Playbooks. Include a comparison table and 3 concrete examples from a Node.js project showing which is better for each scenario. ``` Once the guide looks good, share it and save it as [Knowledge](/product-guides/knowledge) so Devin itself can reference your team's conventions: 1. **Share the guide** — paste the Notion page into your `#engineering` channel or pin it in your team wiki 2. **Save it as Knowledge** — go to **Settings > Knowledge > Create knowledge**, set the trigger to `"onboarding new team members to Devin"`, paste the guide content, and pin it to **all repositories** Now when any team member asks Devin "how should I write prompts?" or "how do I connect Linear?", it pulls from your customized guide — not generic docs. As Devin ships new features, ask it to update the guide in the same session format: *"Read the latest [changelog](/release-notes/overview) and update our onboarding guide with any new features that affect our workflows."*

{title}