/* very hacky way to be able to scroll to a specific step */
.scroll-anchor {
  position: relative;
  top: calc(-2rem - var(--scroll-mt));
}


.mint-flex {
    display: flex
}
.mint-items-center {
    align-items: center
}
.mint-gap-2 {
    gap: 0.5rem
}

/**
 * Checks that all the links in the docs are valid. Handrolled because the Mintlify link checker has too many false positives. Run `npm run check` or `node check_links.js` to run this script.
 *
 * Right now, we only verify that internal links (links that point to other docs pages) are valid.
 *
 * Including "lint:no-link-check" or "lint:no-link-check-next-line" anywhere in a line will disable link checking for that line or the subsequent line, respetively.
 *
 * We currently don't account for redirects. Our internal links shouldn't need a layer of redirection anyways, and we should instead just update them if we move pages around.
 *
 * Feel free to ping me (Ryan) if this script stops working.
 */

const fs = require("node:fs");
const path = require("node:path");
const process = require("node:process");
const config = require("./mint.json");

const DISABLE_LINK_CHECK = "lint:no-link-check";
const DISABLE_LINK_CHECK_NEXT_LINE = "lint:no-link-check-next-line";

function extractPages(pages) {
  const result = [];
  for (const page of pages) {
    if (typeof page === 'string') {
      result.push(page);
    } else if (page && typeof page === 'object' && page.pages) {
      result.push(...extractPages(page.pages));
    }
  }
  return result;
}

const pages = config.navigation.flatMap((group) => extractPages(group.pages));

function isBadLink(pagePath, link) {
  const url = new URL(link, `https://docs.devin.ai/${pagePath}`);

  if (link.includes("docs.devin.ai")) {
    return { error: "Links shouldn't include docs.devin.ai" };
  }
  if (url.hostname !== "docs.devin.ai") {
    return false;
  }

  return (
    !fs.existsSync(path.join(__dirname, url.pathname)) &&
    !fs.existsSync(path.join(__dirname, url.pathname + ".mdx"))
  );
}

function scrapeLinks(pageMdx) {
  const linkRegex = /\[([^\]]+)\]$([^)]+)$/g;
  const links = [];
  let match;

  const lines = pageMdx.split("\n");
  for (let i = 0; i < lines.length; i++) {
    if (lines[i].includes(DISABLE_LINK_CHECK) || (i && lines[i - 1].includes(DISABLE_LINK_CHECK_NEXT_LINE))) {
      continue;
    }

    while ((match = linkRegex.exec(lines[i])) !== null) {
      links.push(match[2]);
    }
  }

  return links;
}

function readPage(page) {
  return fs.readFileSync(path.join(__dirname, page + ".mdx"), "utf8");
}

let hasErrors = false;

for (const page of pages) {
  const pageMdx = readPage(page);
  const links = scrapeLinks(pageMdx);

  const badLinks = links.map((link) => ({link, error: isBadLink(page, link)})).filter(({error}) => error);

  if (badLinks.length > 0) {
    console.log(page + ".mdx");
    for (const {link, error} of badLinks) {
      if (Object.hasOwn(error, "error")) {
        console.log(`  ${link}: ${error.error}`);
      } else {
        console.log(`  ${link}`);
      }
    }
    console.log();
    hasErrors = true;
  }
}

if (hasErrors) {
  process.exit(1);
}


Overview

Common Use Cases

Example Prompts

Code Coverage Tutorial

Connect4 Code Refactor

Example Sessions

Testing & Refactoring

Devin Docs

Devin is the AI software engineer, built to help ambitious engineering teams crush their backlogs.

Introducing Devin

Start your first session and see what Devin can do

Your First Session

Tutorial Library

When to Use Devin

Instructing Devin Effectively

Good vs. Bad Instructions

Set up Devin's workspace to start building

Repo Setup

Configure VPN access for Devin to connect to your internal network

VPN Configuration

Knowledge is a collection of instructions and advice that Devin can reference in all sessions. Think of it as onboarding a new employee with the relevant organizational context.

Knowledge Onboarding

Work with Devin to create detailed plans before Devin starts coding

Interactive Planning

Make edits and test Devin's code directly in its IDE

Devin IDE

Use Ask Devin to explore your codebase, plan tasks, and generate high-context sessions

Ask Devin

Architecture diagrams, documentation, links to sources, and more for all your repos

DeepWiki

How to use the official DeepWiki MCP server

DeepWiki MCP

How to use the official Devin MCP server for private and public repositories

Devin MCP

Share important context and knowledge to help Devin get onboarded

Knowledge

Securely share credentials with Devin so it can access any tool

Secrets & Site Cookies

Interactive Browser

Build a library of reusable prompts for your organization

Creating Playbooks

Using Playbooks

Devin's abilities and limitations in deploying frontend and backend applications.

Deployments

Only available for Team and Enterprise plans

Invite your Team

Use your local settings and extensions while working in Devin's IDE

Importing Code Settings

GitHub Integration Guide

Chat and collaborate with Devin directly in your company Slack

Slack Integration Guide

Work with Devin directly in your GitLab repositories

GitLab Integration

Work with Devin directly in your Azure DevOps repositories

Azure DevOps Integration

Work with Devin directly in your Bitbucket repositories

Bitbucket Integration (Beta)

Assign Linear tickets to Devin and turn them into PRs

Linear Integration Guide

Assign Jira tickets to Devin and turn them into PRs

Jira Integration Guide

We want Devin to be a core contributor in your organization, and have prioritized security, data privacy and compliance to make it possible

Security at Cognition

Billing

Common Issues

Data & Analysis

Web Scraping & Automation

Interactive Applications

Migration & Modernization

Devin can integrate, configure, and test third party APIs in your applications.

API Integration

Devin can analyze your codebase's test suite and write additional tests to increase code coverage for your team.

Code Coverage

In this tutorial, we’ll show you how Devin can configure a Docker container to standardize your team’s dev environment.

Containerization

Devin can work with frontend libraries and share visuals with you during its sessions.

Managing Frontend Components

Learn how to programmatically create and manage Devin sessions using our REST API

Learn how to effectively use structured output and interact with Devin sessions via API

Structured Output

Code examples and common use cases for the Devin API

Usage Examples

List all Devin sessions for your organization.

List all sessions

Create a new Devin session. You can optionally specify parameters like snapshot ID and session visibility.

Create a new session

Retrieve detailed information about an existing Devin session, including its status, output, and metadata.

Retrieve details about an existing session

Send a message to an existing Devin session to provide additional instructions or information.

Send a message to an existing session

Upload files for Devin to work with during sessions. Supports various file types including code, data, and documentation files.

Upload files for Devin

Update the tags associated with a Devin session.

Update session tags

List metadata for all secrets in your organization. Does not return secret values.

List all secrets metadata

Permanently delete a secret by its ID. This action cannot be undone.

Delete a secret

Gets all knowledge and folders in your current organization. This endpoint will not return system knowledge (repo indexes or built-in knowledge) managed by Cognition.


List knowledge

Create knowledge

Update the name, body, or trigger of a piece of knowledge.


Update knowledge

Permanently delete a piece of knowledge by its ID. This action cannot be undone.


Delete knowledge

List all audit logs for your organization.

List all audit logs

Retrieve detailed consumption data for an enterprise organization.

Get enterprise consumption data

Release Notes

Before You Begin

Getting Started with Devin

Enterprise Deployment

Understanding the best enterprise use cases for Devin

Using Enterprise Effectively

Artifacts

Connect Devin with your source code repositories

Git Integrations

Understanding Devin's integration with software development lifecycle workflows

How does Devin fit into my existing SDLC?

Okta SSO Setup

Configure Single Sign-On with Azure AD (Entra ID)

Azure AD SSO Setup

Security practices, compliance certifications, and data privacy commitments

Trust Center

Learn about deploying Devin in your Virtual Private Cloud (VPC)

VPC Deployment Overview

Guide for setting up Devin in your Azure VPC

Azure VPC Setup

Guide for setting up Devin in your AWS VPC

AWS VPC Setup

Learn how to programmatically access enterprise-specific features and reporting using our REST API

Prompts

Tutorials

​Overview

​Common Use Cases

​Example Prompts

​Example Sessions

​Code Coverage Tutorial