「なんとなくの性能差」にサヨナラ。GitHub Copilot、Claude Code、Cursor の裏側の仕組みを調べてみた。 Explores the internal architectures of GitHub Copilot, Claude Code, and Cursor—covering co…

Developers increasingly choose between GitHub Copilot, Claude Code, and Cursor based on a vague sense of which one "feels" smarter, but the more useful question is how each tool is actually built. Understanding their internal architectures—particularly how they gather context and route work to language models—turns a subjective preference into an informed engineering decision, and it explains why the same underlying model can produce noticeably different results across these products.

GitHub Copilot began as an inline completion tool powered by OpenAI's Codex, and that heritage still shapes its design. Its core strength is low-latency suggestion: as you type, it assembles a prompt from the current file, nearby open tabs, and recently edited code, then asks a model to predict what comes next. Over time Copilot has grown well beyond autocomplete to include Copilot Chat, an agent mode, and the ability to select among multiple frontier models from OpenAI, Anthropic, and Google. Because it lives inside editors like VS Code and JetBrains IDEs, it tends to favor tight integration and responsiveness, relying heavily on locally available signals rather than a deep precomputed index of the whole repository.

Claude Code takes a markedly different approach. It is a terminal-based, agentic tool from Anthropic that runs as a command-line process rather than an editor extension. Instead of building an embedding index of your codebase ahead of time, it appears to rely on agentic exploration: the model issues commands such as listing directories, grepping for symbols, and reading files on demand, accumulating context as it works toward a goal. This loop—read, reason, act, observe—lets it execute multi-step tasks like refactors, test runs, and bug fixes with relatively little upfront setup. Projects can supply a CLAUDE.md file to give the agent persistent instructions and conventions. The tradeoff is that this style is closely tied to Anthropic's own Claude models, and its effectiveness depends on the model's ability to plan and navigate efficiently.

Cursor, by contrast, is a fork of VS Code rebuilt around AI as a first-class feature. A defining characteristic is its codebase indexing: Cursor computes embeddings for files so it can perform semantic retrieval, pulling in relevant snippets from across a large project even when they are not currently open. This retrieval-augmented approach feeds the model context the user did not explicitly point to, which is useful in unfamiliar or sprawling codebases. Cursor also pairs frontier models with its own specialized models for features like fast tab completion, and its agent and composer modes can edit multiple files at once. The product effectively layers proprietary tooling on top of third-party models rather than depending on a single provider.

The clearest axis of comparison is context handling. Copilot leans on immediate editor state and open files for speed; Cursor invests in precomputed semantic indexing and retrieval; Claude Code gathers context dynamically through agentic file and command exploration. None of these is strictly superior. Indexing can surface distant but relevant code at the cost of maintaining and refreshing that index, while agentic search avoids stale indexes but can spend more tokens and time navigating. These design choices help explain why one tool may shine on a small, well-organized project and another on a large monorepo.

It helps to place these tools in a broader landscape. They sit alongside alternatives such as Windsurf, Aider, Cline, and JetBrains' own AI Assistant, and many of them draw on the same pool of models, including Claude Sonnet and Opus, GPT-class models, and Gemini. Standards like the Model Context Protocol are emerging to let agents connect to external data sources and services in a more uniform way, which could further blur the lines between these products. Because models, pricing, and features change frequently, any snapshot of capabilities is provisional.

The practical takeaway is that perceived performance differences usually trace back to architecture rather than raw model quality alone. A tool's context strategy, its degree of agentic autonomy, and how tightly it couples to a specific model provider all shape the day-to-day experience. Evaluating these products against your own repository size, workflow, and willingness to trust autonomous edits is likely to yield a better decision than relying on a general impression of which one is smartest.