Google Code Wiki vs ShipDocs: What's the Difference?

Google launched CodeWiki in May 2026, and the developer community immediately started asking the same question we hear every day: "How is this different from ShipDocs?"

The honest answer: they look similar on the surface, but they're built for different jobs. CodeWiki is a public-repo documentation viewer. ShipDocs is a complete codebase documentation and AI chat platform. Understanding the difference matters because the tool you choose determines whether you get a polished README or a living documentation system.

This post breaks down every meaningful difference — from repo support to encryption to the AI chat experience — so you can decide which one fits your actual workflow.

The 30-second summary

If you need documentation for a public open-source project, CodeWiki might be enough. If you need documentation for your team's actual codebase — which is almost certainly private — ShipDocs is the only option on this list.

What Google CodeWiki actually does

CodeWiki is a browser-based documentation tool that ingests a public GitHub repository and generates:

1. A project summary
2. An architecture overview
3. Module-level descriptions
4. Code examples extracted from the source

It renders these in a clean, navigable interface with a dark theme that developers will recognize from Google's other recent product launches. The AI-generated content is readable, structured, and significantly better than an empty README.

What CodeWiki does well:

• Zero setup for public repos. Paste a URL, get docs. No account, no auth, no configuration.
• Good architecture summaries. For well-organized repos, CodeWiki produces accurate high-level descriptions.
• Fast indexing. Google's infrastructure means large public repos are processed quickly.
• Clean UI. The documentation viewer is polished and consistent with Google's design language.

What CodeWiki does not do:

• Private repositories of any kind
• Interactive codebase chat
• Editable documentation output
• CLI integration
• Encrypted storage (not needed for public repos, but relevant for teams evaluating tools)

What ShipDocs does

ShipDocs is a full-stack documentation platform. You connect a repo (public or private via OAuth), upload a zip, or push from the CLI. ShipDocs then:

1. Scans the entire file tree
2. Detects components from manifest files, directory structure, and import graphs
3. Generates an Overview document covering architecture, tech stack, and key concepts
4. Generates one Markdown document per component — backend, frontend, workers, CLI, migrations, webhooks, whatever your repo actually contains
5. Hosts the docs in a navigable sidebar interface
6. Provides an AI chat grounded in those docs, where every answer cites a file path

What ShipDocs does well:

• Private repo support with OAuth. Connect GitHub, GitLab, or Bitbucket. Import private repos with the same flow as public ones.
• Per-component breakdown. CodeWiki gives you one summary. ShipDocs gives you an Overview plus individual docs for each architectural component.
• File-citing AI chat. Ask "how does the queue retry policy work?" and get an answer that cites workers/src/runner.ts:48 and workers/src/queue.ts:14.
• Editable Markdown. Every generated doc can be edited in a WYSIWYG editor. Your edits persist across regenerations.
• AES-256-GCM encryption. Source files and docs are encrypted with per-project keys.
• Explicit no-training policy. Your code is never used to train AI models.
• CLI. shipdocs upload from your working directory. Auth via browser, push in seconds.
• Public showcase. Flip any project public and get a permanent URL. Browse real examples at shipdocs.sh/showcase.

Deep comparison: how the docs are actually generated

CodeWiki: single-summary approach

CodeWiki appears to generate one unified document per repository. It reads the file tree, extracts key files, and produces a linear narrative that covers the project. This works well for smaller, well-organized repos where the architecture is already clean.

The limitation is scale. A 200k-line monorepo with 15 services doesn't fit into one summary in a useful way. A developer looking for the payment service's retry logic doesn't want to scroll through a 40-page overview that covers the frontend build system, the ML pipeline, and the iOS app.

ShipDocs: per-component modular approach

ShipDocs reads the repo, detects boundaries between components, and generates a separate doc for each one. The detection is based on:

• Manifest files (package.json, Cargo.toml, go.mod, pyproject.toml, etc.)
• Directory structure (separate /backend, /frontend, /workers folders)
• Import graphs (which files depend on which)
• Configuration files (docker-compose.yml, terraform/, Kubernetes manifests)

The result is a documentation tree that mirrors your architecture:

Overview
├── Backend
│   ├── API layer (Elysia, port 3000)
│   ├── Auth system (Better-Auth)
│   └── Database layer (Drizzle ORM + Postgres)
├── Frontend
│   ├── Routing (TanStack Router)
│   └── UI system (shadcn/ui + Tailwind v4)
├── Workers
│   ├── Indexer pipeline
│   └── Purge cron
└── CLI
    └── Ink-based TUI

Each leaf is a full Markdown document with exported functions, key files, dependencies, and how it connects to the rest of the system.

This is the difference between a book's back-cover summary (CodeWiki) and the book's full table of contents with chapter summaries (ShipDocs).

Deep comparison: the AI chat experience

CodeWiki: no chat

As of launch, CodeWiki does not include an interactive chat interface. You read the generated docs. If you have a question that's not covered, you go back to the source code.

ShipDocs: grounded codebase chat

The chat is the reason most teams adopt ShipDocs. After the docs are generated, you can ask anything:

• "Where do we validate webhook signatures?"
• "How does the auth flow work from login to JWT?"
• "What's the database schema for the billing table?"
• "Which files handle the queue retry logic?"

Every answer is grounded in the structured docs generated from your actual source. The model doesn't hallucinate APIs because it's constrained to the documented surface. If the answer isn't in the docs, the chat says "I don't see that in the generated documentation" rather than inventing something.

Here's what a real response looks like:

Workers pull from the indexQueue (Redis stream). Retries use exponential backoff with a cap of 5 attempts before moving to the dead-letter stream indexDlq.

Sources: workers/src/runner.ts:48 · workers/src/queue.ts:14

This isn't a general-knowledge answer. It's a specific answer extracted from the code, with exact line references.

Deep comparison: security and privacy

CodeWiki: public repos, minimal trust required

Because CodeWiki only works on public repos, the security model is simple: Google reads what anyone can already read. No OAuth tokens, no encrypted storage layer, no training-policy concerns for the repo owner (the code is already public).

This is fine for open-source. It's completely insufficient for professional development.

ShipDocs: private repos, zero-trust architecture

ShipDocs was designed around the assumption that your most valuable code is private. The security stack includes:

• OAuth2 with explicit scopes. You grant repo-read access to ShipDocs. You can revoke it anytime from your Git provider's app settings.
• AES-256-GCM encryption. Every project's source files and generated docs are encrypted with a unique key before storage.
• KMS-backed key wrapping. Project encryption keys are wrapped by a master key stored in a hardware-backed vault.
• No AI training. ShipDocs does not train models on customer data. Third-party providers (via OpenRouter) use zero-retention endpoints.
• 90-day purge. Deleted projects enter a soft-delete window, then are permanently erased by a background job.
• Audit logging. Admin access to decrypted project data is logged with timestamp, administrator, and reason.

This is the security posture you need when your codebase contains customer PII, payment logic, or proprietary algorithms.

Deep comparison: workflow integration

CodeWiki: browser-only, URL-based

CodeWiki's workflow is: find a public repo URL, paste it into CodeWiki, read the docs. There's no account, no persistence, no API. It's a read-only documentation viewer.

This is useful for exploring unfamiliar open-source libraries. It's not a documentation system for a team.

ShipDocs: dashboard, CLI, and integrations

ShipDocs' workflow is:

1. Dashboard: Sign in, connect a Git provider, import repos from a searchable list. Or upload a zip. Or use the CLI.
2. CLI: curl -fsSL shipdocs.sh | sh to install. shipdocs login for OAuth. shipdocs upload to push your cwd. The CLI is a React-based TUI built with Ink.
3. Docs viewer: Browse generated docs in a sidebar. Click between components. Edit any doc inline.
4. Chat: Ask questions and get file-cited answers.
5. Showcase: Flip a project public for a permanent URL you can share.
6. Regenerate: Update docs when the code changes.

This is a documentation lifecycle, not a one-time document generation.

Which one should you use?

Use CodeWiki if:

• You're exploring an open-source library and want a quick architecture summary
• You don't need private repo support
• You don't need interactive chat or editable docs
• You want zero setup (no account)

Use ShipDocs if:

• You need documentation for private repositories
• You want per-component breakdowns, not one summary
• You want a codebase chat that cites file paths
• You need encryption and a no-training policy
• You want a CLI for uploading from your working directory
• You want editable, regenerable docs that stay current

The bottom line

CodeWiki is a good tool for its intended use case. It's Google's take on "AI-generated documentation for public repos," and it does that job competently.

ShipDocs is a different category of product. It's a complete codebase documentation platform — generation, hosting, editing, chat, encryption, CLI, and showcase — built for the repos developers actually work on. The ones with authentication. The ones with customer data. The ones that would benefit most from an AI that has read every file.

If your codebase is public and you just want a quick overview, CodeWiki might save you a few minutes. If your codebase is private and you need a documentation system, ShipDocs is the tool built for that reality.

Try ShipDocs on your private repo: shipdocs.sh — free tier includes 2 private repos, full docs, and AI chat. Get started →