How to Use Devin DeepWiki for Codebase Docs

Cognition's DeepWiki docs describe automatic repository indexing into architecture diagrams, source-linked summaries, and wiki pages that Ask Devin uses for grounded answers. Public repositories already have a free surface at deepwiki.com. Private work starts only after a Devin AI organization indexes the repo. Steered wikis top out at 30 pages by default, or 80 on enterprise plans. That public-or-private split, plus the page cap, is why teams need a setup path rather than another launch recap.

Devin DeepWiki is Cognition's AI documentation layer that indexes repositories and generates architecture diagrams, source-linked summaries, and chat-ready wiki context for engineering teams. It sits next to Ask Devin: the wiki is the structured map, and Ask Devin is the question layer that pulls context from that map plus advanced code search.

Public surface vs private Devin AI path

There are two entry points that people confuse under the same brand:

• deepwiki.com (public): Free documentation and basic Q&A for public GitHub repositories. You can open popular open-source projects or submit a public repo URL for indexing. This path does not give you the full private Ask Devin experience.
• Devin app wiki (private-capable): After you connect and index repos in a Devin AI organization, DeepWiki appears in the product sidebar. Ask Devin can use that wiki plus advanced search to plan tasks and answer with citations grounded in your code.

Cognition is explicit that public DeepWiki and DeepWiki MCP cover basic documentation and Q&A, while planning, advanced code search, and session creation live in the Devin app.

What you get after a successful index

When indexing finishes, the wiki typically surfaces:

• Architecture-oriented diagrams of how major systems relate
• Page-level summaries that link back to source files
• Hierarchical topics you can browse without grepping the tree
• Context that Ask Devin can consume when you ask "how does auth work?" or "where do we write invoices?"

DeepWiki is not a replacement for human-owned docs (ADRs, runbooks, security playbooks). It is a fast onboarding layer that tracks the repository more closely than a hand-written architecture page that last shipped two quarters ago.

Featured setup path for Devin DeepWiki inside Devin AI:

1. Connect your Git provider (GitHub, GitLab, or another supported source) so Devin AI can see the repository.
2. Open organization repository settings in the Devin AI app and choose Index repo for the repository you care about.
3. Select the branch or branches your team actually ships from.
4. Wait for indexing to finish (minutes for small repos, longer for large monorepos).
5. Open the wiki from the Devin sidebar (app.devin.ai/wiki).
6. Ask questions in Ask Devin so answers can use wiki context plus code search.
7. Optionally connect DeepWiki MCP for public-repo tooling in other MCP clients.

Cognition notes that DeepWiki is also autogenerated when you connect repositories during onboarding. Manual indexing is still the path when a repo was connected earlier without full indexing, or when you need additional branches.

Indexing steps that matter in practice

Official indexing guidance separates repository indexing from environment configuration. Indexing powers Ask Devin and DeepWiki. Environment setup is about Devin's development sandbox. Teams that only configure the environment often wonder why the wiki is empty.

In the Repositories list:

1. Confirm the repo appears and git permissions are valid.
2. Click Index repo.
3. Choose the active development branches, not only a dormant main if your real work lives on release trains.
4. Use Manage later to add branches without redoing the entire connection.

Index the branches people merge into every day. Stale default branches produce confident wiki pages about code that no longer matches production.

First questions to run after the wiki appears

Before you trust the wiki for onboarding, probe it the way a new hire would:

• "What are the main services in this repository and how do they talk to each other?"
• "Where is authentication enforced for the public API?"
• "Which folder owns billing, and which tests cover it?"
• "What would break if we renamed the payments service?"

Good answers cite concrete paths. Vague answers usually mean the automatic planner skipped folders, the wrong branch is indexed, or the monorepo needs steering (next section).

Public-only shortcut

If you only need to understand an open-source dependency, start at deepwiki.com. Submit the public GitHub URL, wait for the wiki, and ask questions there. Move into the Devin app when you need private repositories, planning, or sessions that turn research into implementation work.

Automatic wiki generation is good for mid-size, well-structured repos. Large monorepos hit built-in limits and can drop critical folders. Cognition's answer is a root-level .devin/wiki.json file that steers generation with notes and, optionally, an explicit page list.

When to add steering

Add .devin/wiki.json when:

• Important packages never appear in the wiki
• Generated pages over-focus on boilerplate and miss the domain core
• You need a stable hierarchy for onboarding (overview, then services, then critical flows)
• Enterprise size pushes you toward the higher page ceiling (80 pages) and you still want intentional structure

Configuration shape

Create .devin/wiki.json at the repository root:

{
  "repo_notes": [
    {
      "content": "Prioritize backend/api for request routing, services/billing for invoice state, and packages/auth for session tokens. Frontend is secondary for this wiki cycle.",
      "author": "Platform lead"
    }
  ],
  "pages": [
    {
      "title": "Architecture Overview",
      "purpose": "High-level services, data stores, and request paths",
      "parent": null
    },
    {
      "title": "Billing Service",
      "purpose": "Document services/billing, invoice lifecycle, and related jobs",
      "parent": "Architecture Overview"
    },
    {
      "title": "Auth Boundaries",
      "purpose": "Document packages/auth and API middleware that enforce sessions",
      "parent": "Architecture Overview"
    }
  ]
}

Field behavior from Cognition's docs:

• repo_notes: Guidance only. Content is required (max 10,000 characters per note). Author is optional. Notes improve automatic planning without freezing the page list.
• pages (optional): Explicit page plan. If present, DeepWiki generates exactly those pages, no more and no less. Titles must be unique. Parent titles build hierarchy. Optional page_notes add page-local guidance.

Validation limits that bite in real monorepos:

• Maximum 30 pages by default (80 for enterprise)
• Maximum 100 total notes (repo_notes plus all page_notes)
• Maximum 10,000 characters per note

Practical steering strategy

Start with repo_notes only. Regenerate and check coverage. Only add a full pages array when notes are not enough. When you do define pages, list every page you want in the wiki, including the ones that already looked fine. The array is a complete instruction set, not a patch list of missing topics.

Write page purposes like acceptance criteria:

• Name directories and filenames
• State the reader outcome ("document how retries and dead-letter queues work")
• Avoid vague purposes ("explain the backend")

After you commit .devin/wiki.json, regenerate the wiki and re-run the same probe questions. If a page is still thin, tighten the purpose or split one overloaded page into parent and child pages.

Keep DeepWiki exports where agents and humans can reuse them

Store architecture packets, steered wiki config notes, and onboarding answers in a shared Fast.io workspace with Intelligence Mode, version history, and MCP access. Every organization starts with a 14-day free trial.

Start 14-Day Trial

Once the wiki exists, treat Ask Devin as the primary interface for day-to-day understanding. Official guidance recommends indexing first, exploring and planning in Ask Devin second, then starting an agent session from that conversation so Devin AI inherits the research context.

Ask Devin workflow that holds up

1. Confirm the target repo and branch are indexed.
2. Ask architecture and "where is X?" questions until answers include file paths you recognize.
3. Switch to planning when you have a change in mind. Ask Devin can help scope work and produce a context-rich prompt.
4. Start a Devin session from that thread so session status stays attached to the research conversation.

Answers should feel boring in a good way: named modules, links to sources, and constraints that match the code. If the answer sounds like a generic textbook, the index or wiki steering needs work.

DeepWiki MCP for public repositories

DeepWiki MCP is a free, remote, no-authentication MCP server for public repository documentation and search-style questions. Base URL: https://mcp.deepwiki.com/.

Official tools:

1. read_wiki_structure - list documentation topics for a GitHub repository
2. read_wiki_contents - view wiki documentation for a repository
3. ask_question - ask a question about a public repository and get a context-grounded response

Wire protocols:

• Streamable HTTP (recommended): https://mcp.deepwiki.com/mcp
• SSE (legacy): https://mcp.deepwiki.com/sse (being deprecated)

Cognition documents a silent-failure trap: Devin Desktop expects serverUrl for remote MCP servers, while most other clients use url. Wrong field names cause the server to be ignored with no useful error.

Devin Desktop:

{
  "mcpServers": {
    "deepwiki": {
      "serverUrl": "https://mcp.deepwiki.com/mcp"
    }
  }
}

Cursor and similar clients:

{
  "mcpServers": {
    "deepwiki": {
      "url": "https://mcp.deepwiki.com/mcp"
    }
  }
}

Claude Code:

claude mcp add -s user -t http deepwiki https://mcp.deepwiki.com/mcp

DeepWiki MCP is the right tool for public GitHub context without keys. It is the wrong tool for private monorepos. For private DeepWiki-style access, Cognition points teams to a Devin account and the authenticated Devin MCP server with a Devin API key.

Where Fast.io fits beside Devin AI MCP surfaces

Devin AI sessions and DeepWiki answers are excellent while you are researching. They are not a team file system for long-lived exports, architecture PDFs, decision notes, or agent-produced patches that humans must review. Many teams dump those artifacts into local disks, S3 buckets, or Google Drive folders that agents cannot search by meaning.

Fast.io sits beside that workflow as a shared intelligent workspace: humans use the UI, agents use the Fast.io MCP server over Streamable HTTP at /mcp (legacy SSE at /sse). Enable Intelligence Mode so exports become full-text and semantic search targets with citations. Per-file version history keeps concurrent agent writes auditable. Ownership transfer lets an agent assemble the workspace, then hand it to a human while keeping admin access. See the storage for agents guide for MCP onboarding details.

DeepWiki pages live inside Cognition's product surfaces. That is fine for exploration. It is weaker when legal, platform, or support teammates need a stable packet of "how this system works" that survives a re-index, a branch change, or a vendor UI refresh.

What to export on purpose

After a good wiki cycle, capture durable artifacts outside the chat:

• Architecture overview pages that match production branches
• Service maps and auth boundary notes
• Onboarding Q&A transcripts that already include correct file paths
• .devin/wiki.json itself (it is configuration and should live in git)
• Any diagrams or summaries you want non-engineers to read without a Devin seat

Store those files where the team already collaborates. Local folders work for a solo spike. Object storage (S3 or similar) works for automated pipelines. Google Drive or Dropbox work for human review chains. For agentic teams that need one place both people and agents can query, put the packet in a shared workspace with search and permissions.

A practical handoff pattern

1. Generate or refresh DeepWiki for the active branch.
2. Probe Ask Devin until answers cite the right modules.
3. Save the wiki pages, notes, and session summaries you care about as files (Markdown is usually enough).
4. Commit .devin/wiki.json so the next regeneration stays steered.
5. Upload the durable packet to team storage with a clear path, for example docs/generated/deepwiki/<repo>/<date>/.
6. If agents continue the work, give them MCP access to that workspace rather than re-pasting long context into every prompt.

On Fast.io, that handoff looks like a workspace with Intelligence Mode on, branded shares when external reviewers need limited access, and an append-only audit log when you need to see who changed the architecture packet. Plans start with a 14-day free trial (credit card required) on Starter ($29/mo), Business ($99/mo), or Growth ($299/mo). Real workspace use requires a paid organization subscription after the trial. For agent-facing MCP setup and workspace patterns, start at /storage-for-agents/ and pricing.

DeepWiki vs human docs vs intelligent workspaces

Keep the layers distinct:

• DeepWiki: fast, source-linked map of a repository at index time
• Human docs: policies, incidents, product intent, and decisions the code cannot state
• Intelligent workspace: durable files, permissions, version history, and RAG over the packet your team agrees is true

Teams that skip the third layer often re-ask the same Ask Devin questions every sprint because nothing durable was saved after the first good answer.

Most DeepWiki complaints fall into a short list. Fix the root cause before you blame the model.

Wiki is empty or missing the repo

• Confirm the repository is connected with valid git permissions.
• Index the repo explicitly from organization repository settings if onboarding did not complete indexing.
• Check that you opened the wiki for the same organization that owns the index.
• Remember that environment setup is not indexing.

Only some folders appear

Large repositories routinely under-document deep packages. Add repo_notes that name the missing folders, regenerate, and only then freeze a full pages list. When using pages, include the entire desired wiki, not just the missing titles.

Answers feel generic

• Re-index the branch people actually develop on.
• Ask narrower questions that force path citations.
• Steer the wiki toward domain packages instead of generated client stubs.
• For public MCP clients, confirm you are not accidentally querying a different public repo with a similar name.

MCP server never shows tools

• Prefer https://mcp.deepwiki.com/mcp over legacy SSE.
• Use serverUrl in Devin Desktop and url in most other clients.
• Remember DeepWiki MCP is public-only. Private repos need Devin account access and the authenticated Devin MCP path.

Humans still cannot find last week's architecture packet

That is a storage problem, not a wiki problem. Save the exports, put them in shared storage with version history, and let agents read the same files humans review. DeepWiki gets you to understanding quickly. Durable workspaces keep that understanding usable after the browser tab closes.