// Why not just…?

Your tools are good.
Context makes them great.

dovetell isn't a replacement for Cursor, Claude Code, or your wiki. It's the layer that makes them work better for your specific team — because great tools still need to know what your team actually decided.

// The patterns
Cursor

Why not just Cursor?

What Cursor does well
  • Writes, edits, and refactors code inline with full file context
  • Understands your codebase structure through indexing
  • Applies rules from .cursorrules or AGENTS.md
  • Executes tasks fast — it's the runtime
What dovetell adds
  • The decisions behind the code — why things are the way they are
  • Team-vetted prompts that encode your standards, not just file structure
  • Context that stays current when team decisions change
  • The shared layer that makes Cursor consistent across every developer on the team
Cursor executes. dovetell is what it executes against.
Claude Code

Why not just Claude Code?

What Claude Code does well
  • Agentic, multi-step coding tasks from the terminal
  • Reads, writes, and runs files across your whole repo
  • Handles complex refactors with minimal hand-holding
  • Picks up project context from CLAUDE.md
What dovetell adds
  • Structured prompt blocks that go into CLAUDE.md — written once, reused everywhere
  • Team decisions surfaced at session start, not re-explained every time
  • A versioned record of what context was active when decisions were made
  • The governance layer so CLAUDE.md doesn't drift into everyone's personal preferences
Claude Code is the agent. dovetell is what the agent needs to know about your team.
Notion / Wiki

Why not just a shared wiki?

What wikis do well
  • Long-form documentation that people actively go looking for
  • Onboarding materials, runbooks, policy docs
  • A home for things that rarely change
What dovetell adds
  • Context that travels into the AI's flow — you don't have to go look for it
  • A review gate so AI-captured decisions get human sign-off before becoming truth
  • Drift detection — docs don't silently go stale while the codebase moves
  • Machine-readable structure, not just readable prose
A wiki is pull. dovetell is push — it puts context where the model already is.
AGENTS.md / CLAUDE.md

Why not just write a good AGENTS.md?

What a hand-crafted context file does well
  • Gives a single model session strong project-specific grounding
  • Works immediately, no tooling required
  • Versioned with the code — easy to inspect and diff
What dovetell adds
  • A structured process for keeping it current as the team evolves
  • Separation of personal, team, and project-level context — so it doesn't become one person's preferences
  • The prompt library that feeds it — so you're not writing from scratch every project
  • Cross-project consistency when you have more than one repo
A single AGENTS.md is a great start. dovetell is what keeps it from becoming tribal knowledge in a different file.
ChatGPT / Claude.ai

Why not just paste context into the chat?

What chat-first AI does well
  • Fast answers, low friction, no setup
  • Good for one-off questions and exploration
  • Flexible — you can shape the context however you want per session
What dovetell adds
  • Context that doesn't have to be re-pasted every session — it's assembled, not remembered
  • Consistency across teammates who would otherwise paste different things
  • A record of what was decided, not just what was asked
  • The layer that makes ad-hoc AI use into a repeatable team practice
Chat AI is powerful. dovetell is what stops every session from starting from zero.
Claude Cowork Dispatch

Why not just dispatch tasks from my phone?

What Cowork Dispatch does well
  • Assign a task from your phone, Claude Code executes it on your desktop while you're away
  • Push notification when work is done — come back to finished output
  • Remembers your preferences and working style across sessions
  • Schedules recurring tasks automatically — no re-prompting needed
What dovetell adds
  • The team context Dispatch doesn't carry — vetted decisions, definitions, and standards travel into every task without re-explaining
  • A queue you own — tasks live in your repo, not in someone else's infrastructure
  • The audit trail — what was dispatched, what completed, when, committed to git
  • When the dovetell MCP server exists, @dovetell becomes a connector Dispatch can call natively — context on demand, every task
Cowork Dispatch handles execution. dovetell is what the execution needs to know about your team.
// The honest answer

Use all of it.
dovetell is the layer between.

None of these tools are wrong choices. The gap they all share is the same: they're powerful at execution, but they don't carry your team's specific decisions, standards, and context forward automatically. That's the job dovetell does — not instead of the tools you already use, but underneath them.

See where your team stands → See the framework