How Dropbox Uses AI to Make Security Design Part of Code Review

Closing the Gap Between Design and Code

If you've ever been in a code review where a security requirement from a design doc somehow got lost in translation, you know the pain. Dropbox engineers felt it too. They had threat models and security requirements sitting in separate systems, disconnected from the code that was supposed to implement them. So they built a bridge.

The result is a system that uses the Model Context Protocol (MCP) and their internal knowledge tool, Dash, to pull relevant security context directly into the code review workflow. Instead of hunting through wikis and PDFs, engineers see the security intent right next to the code that's supposed to fulfill it.

The Problem: Security Requirements Get Lost in the Shuffle

In many large engineering orgs, security requirements are nailed down during design reviews. But by the time code lands for review, those requirements are often forgotten or filed away. The docs become stale. The code drifts from the original intent. And reviewers are left to manually piece together why a change was made in the first place.

That's not just inefficient—it's risky. Requirements get missed, implementations become inconsistent, and security holes slip through. Dropbox wanted to make sure that didn't happen, without adding extra hoops for developers to jump through.

MCP + Dash: A Standardized Bridge

Dash is Dropbox's internal knowledge system. It indexes design docs, threat models, and other artifacts while respecting existing access controls. MCP, meanwhile, is a standardized protocol that lets AI systems request and use that context in other tools—like code review.

When a pull request is created, the system identifies what code changed and uses MCP to fetch relevant security context from Dash. That context shows up right in the review interface. No more jumping between tabs. No more guessing whether a security requirement applies to this specific change.

Not Just Retrieval—Analysis

But it's not just about pulling up a document. As Ishan Mishra, engineering lead at Dropbox, explains, the system goes further: it compares the retrieved context with the actual code changes. It doesn't just attach a doc; it highlights which security requirements apply and flags potential gaps between the design intent and the implementation.

That's a big step up from a simple keyword search. The system is designed to be conservative—it only surfaces findings that are relevant and backed by evidence. If it can't tie a requirement to a specific line of code, it stays quiet.

Why MCP? Avoiding One-Off Integrations

Dropbox chose MCP rather than building a custom integration with their CI or code review tools. Why? Because they didn't want to reinvent the wheel for every workflow. MCP provides a standard way to plug Dash in as a context provider. The code review agent doesn't need to know where the info lives or how to fetch it—it just asks, and Dash handles the rest.

That makes the whole setup reusable. Security review is just the first use case. The same pattern could apply to privacy checks, compliance validation, API governance, or design reviews. Standardization pays off.

Trust, but Verify: Avoiding False Confidence

One of the biggest concerns with AI-assisted code review is that developers might assume the system has "checked" the code for security. Mishra is keenly aware of this. "We don't treat this system as a source of truth," he says. "It's a tool to help developers gather evidence and reduce manual cross-checking."

Three principles keep that trust intact:

• Traceability: Every finding must link back to a specific security requirement and the code that implements it. If you can't see the chain of evidence, you shouldn't act on it.
• Human judgment stays in the loop: The system is an assistant, not a replacement for security reviewers. It makes it harder to miss agreed-upon requirements, but it doesn't certify code as secure.
• Continuous feedback: Developers can flag inaccurate or irrelevant findings. That feedback loops back into improving retrieval and reasoning over time.

This matters because trust is fragile. If the system cries wolf too often, developers will start ignoring it. Dropbox is betting that a conservative, evidence-based approach will keep the signal high.

The Hardest Part: Finding the Right Context

Mishra admits that the hardest part isn't retrieval—it's relevance. In a large org, design docs and code don't always have obvious links. Keyword search isn't enough. Semantic retrieval helps, but only if the results are actually specific and actionable.

"Developers already get a lot of automated feedback in code review," he says. "Our tolerance for false positives is very low." Even a technically correct finding can erode trust if it's not relevant to the current change. So the system must be cautious: it only surfaces findings that are clearly connected to the code at hand.

That requires constant tuning. Dropbox evaluates review outcomes, collects developer feedback, and iterates on the retrieval and reasoning components. It's not a set-it-and-forget-it system.

Balancing Latency, Depth, and Developer Trust

In a live code review, developers don't want a research paper. They want a few salient points, right when they need them. Dropbox balances this by retrieving enough context to understand the design intent, then presenting concise, evidence-backed findings.

Latency matters because code review is interactive. But trust comes from relevance, traceability, and restraint. "We avoid surfacing every weak signal," Mishra says. "If the system can't clearly connect a requirement to the code, it's better to stay quiet."

That's a refreshing take in an AI world that often feels like a firehose of suggestions.

Lessons for AI-Assisted Engineering Workflows

The biggest lesson, Mishra says, is that AI agents become far more valuable when they build on an organization's past decisions—not just the current task. Many AI coding tools focus on generating or reviewing code in isolation. That's useful, but it misses the bigger question: why is this code being written?

By connecting code to design intent, security requirements, and organizational knowledge, AI can help preserve and apply what the company already knows. That's a shift from "write code faster" to "make sure the code we write is the code we meant to write."

For other teams considering similar workflows, Mishra's advice is clear: think about the decisions your org has already made, and find ways to surface them at the point of action. Whether it's security, privacy, or API conventions, the pattern holds.

Beyond Security: A Template for Governance

Dropbox's MCP + Dash integration isn't just a security tool—it's a template for embedding governance into engineering workflows. The same architecture could be used for compliance checks, design reviews, or any process where context from the past needs to inform the present.

By making that context accessible and actionable, Dropbox is turning passive documentation into an active part of the development process. And that's a lesson that applies far beyond code review.