Claude Code enters the terminal

An assistant that runs commands, not just completes lines

On 24 February 2025, Anthropic released Claude 3.7 Sonnet and, alongside it, a limited research preview of a command-line tool called Claude Code. The narrow, documented claim is worth stating precisely, because it is easy to inflate. This was not a new base model built only for programming, and it was not a chat window with a code panel bolted on. It was an agent, described in Anthropic's announcement as the company's "first agentic coding tool," that ran inside a developer's terminal and could search and read a repository, edit files, write and run tests, invoke command-line utilities, and commit and push changes to GitHub. The model was the headline; Claude Code was the smaller, quieter accompaniment.

The broader historical question, which should stay separate from that narrow claim, is why a terminal utility deserves an entry in a timeline at all. The answer is not that it introduced a new idea from nothing. It is that it packaged a set of already-emerging capabilities (extended reasoning, tool use, file access, and command execution) into a spare, scriptable interface that treated the whole working directory as the model's context. That packaging turned out to matter more than its modest launch framing suggested.

What "in the terminal" actually meant

The choice of surface was deliberate and, in retrospect, load-bearing. Most AI coding assistants up to that point lived inside an editor, where the unit of interaction was a cursor position and a suggested completion. Claude Code instead adopted the assumptions of the Unix shell: it read and wrote files on disk, ran arbitrary commands, and could be piped, scripted, and chained with other tools. The current Claude Code documentation still describes it as "an agentic coding tool that reads your codebase, edits files, runs commands, and integrates with your development tools," and emphasizes that it is composable and follows the Unix philosophy, so a developer can pipe a log file into it or run it inside continuous integration.

That design decision had a consequence that inline autocomplete could not reach. An editor extension optimizes the next few tokens a human is about to type. A terminal agent operates on the level of tasks: "write tests for the auth module, run them, and fix any failures." The unit of work is a goal plus the freedom to take many steps toward it, not a single keystroke prediction. The interface was minimal on purpose, so that the intelligence sat in the loop and the model rather than in an elaborate application shell.

From autocomplete to an agent that acts

The predecessors clarify what was genuinely new. Inline code assistance was already a mature product category: GitHub Copilot, launched in 2021 as an "AI pair programmer," had normalized the idea of a model suggesting completions as you type. Copilot was useful and widely adopted, but its contract with the user was narrow. It proposed text; the human accepted, edited, or discarded it, then ran and tested the code themselves. The model did not touch the file system, execute the tests, or read the error output and try again.

The constraint Claude Code addressed was that gap between suggestion and action. Real software work is a loop: read the relevant code, form a hypothesis, make a change across several files, run the tests or the program, read what broke, and revise. A pure completion engine sits inside one moment of that loop and leaves the rest to the person. Anthropic's own framing captured the ambition concretely: early testing, the announcement said, showed Claude Code completing in a single pass tasks that "would normally take 45+ minutes of manual work." That is a claim about closing the loop, not about typing faster.

The capabilities the moment had just assembled

Claude Code did not appear in a vacuum; the pieces it needed had shipped over the preceding months. In October 2024, Anthropic introduced computer use and an upgraded Claude 3.5 Sonnet, a public beta in which the model could look at a screen, move a cursor, click, and type. That same release reported a large jump in autonomous coding ability: on the SWE-bench Verified benchmark, the upgraded 3.5 Sonnet rose from 33.4% to 49.0%, and it posted gains on the agentic TAU-bench retail and airline tasks. Computer use established that a model could take real actions in an environment and observe the results; Claude Code applied the same principle to the narrower, more reliable environment of a shell and a codebase.

Claude 3.7 Sonnet then contributed the reasoning half. Anthropic described it as "the first hybrid reasoning model on the market," able to answer immediately or to produce extended, visible step-by-step thinking, with API callers able to set a thinking budget up to 128K tokens. For an agent that must plan a multi-file change and diagnose a failing test, the ability to deliberate before and between actions is not cosmetic; it is what lets the loop recover from its own mistakes rather than compounding them.

How the agent loop actually works

Mechanically, Claude Code is an orchestration around a simple pattern. The model is given the ability to call tools (read a file, edit a file, run a shell command, search the repository), and it runs a loop: decide on an action, take it, observe the result, and decide again, until the task looks done or the user intervenes. The repository itself supplies the context, so the agent can inspect the code it is about to change instead of relying on a description of it. Anthropic's engineering guidance in Claude Code best practices stresses that the tool is intentionally low-level and unopinionated, giving close to raw model access without forcing a particular workflow, which is why it can be scripted and embedded rather than confined to one editor.

Two design details deserve emphasis because they separate a real agent from a demo. First, actions require permission: reading and, especially, running commands or pushing to a remote are gated, because an agent with unfettered execution rights on a developer's machine is a liability, not a feature. Second, the quality of the result depends on the entire harness, not the model alone. The same model behind a weaker tool loop, or with poor repository context, produces worse work. This is the central caveat the launch itself implied: the underlying model and the agent scaffolding around it are distinct ingredients, and the observed capability is a property of their combination.

The evidence, and what the numbers do and do not say

The most-cited figure from the launch was Claude 3.7 Sonnet's score on SWE-bench Verified, a human-validated 500-problem subset that OpenAI released in August 2024 to correct flaws in the original benchmark. Anthropic reported 63.7% on SWE-bench Verified using a standard configuration, rising to 70.3% with a custom agent scaffold and additional test-time compute. Those are task-specific resolution rates on a fixed set of real GitHub issues, not measures of general programming skill and certainly not a fraction of human ability.

It helps to know what the benchmark is. The original SWE-bench paper, from researchers including Carlos Jimenez, John Yang, Ofir Press, and Karthik Narasimhan, poses 2,294 real issues drawn from open-source Python repositories and asks a system to produce a patch that makes the project's hidden tests pass. When it was introduced, the results were sobering: Claude 2 resolved 1.96% of the tasks. Read against that baseline, an early-2025 verified-subset score in the sixties is a striking two-year swing, and the public SWE-bench leaderboards document the broader climb across many systems. Anthropic also reported state-of-the-art results on TAU-bench, described in the τ-bench paper from Shunyu Yao and colleagues at Sierra, which measures an agent conversing with a simulated user while following domain policies and calling tools. TAU-bench matters here because it tests exactly the reliability under multi-step interaction that a coding agent depends on, and its authors found even strong models succeeding on well under half of some domains.

The honest reading of these numbers is comparative, not absolute. They show that a model plus a well-built agent loop could resolve a majority of a curated set of genuine bug-fix and feature tasks, which is a real and measurable capability. They do not show that the agent is correct in general, that it handles unfamiliar codebases, or that a benchmark patch that passes hidden tests is the patch a maintainer would accept.

The competing approaches of its moment

Claude Code entered a crowded and fast-moving field, and placing it fairly requires naming the alternatives. On one side sat the editor-embedded assistants in the Copilot lineage, plus the surging category of AI-native editors such as Cursor, which kept the human in the loop inside a graphical environment. On another side sat fully autonomous "AI software engineer" agents, most visibly Cognition's Devin, which were pitched as taking a ticket and returning a finished pull request with minimal supervision. Between those poles, the SWE-bench leaderboards filled with open-source agent scaffolds competing on the same tasks.

Claude Code occupied a distinct point in that space. It was more autonomous than an autocomplete extension and more supervised than a hands-off autonomous engineer: an interactive agent in the terminal that a developer drives, watches, and interrupts. There was no requirement that this middle position win. It reflected a specific bet, that the productive near-term form was a human directing a capable agent in tight cycles, rather than either a passive suggester or a fire-and-forget worker. The pricing reinforced the pragmatic positioning: Claude 3.7 Sonnet cost $3 per million input tokens and $15 per million output tokens, with thinking tokens billed as output, and it was available across the consumer plans, the developer API, Amazon Bedrock, and Google Cloud's Vertex AI.

The plumbing underneath: Model Context Protocol

A coding agent is only as useful as the systems it can reach, and Claude Code inherited a piece of infrastructure released three months earlier. In November 2024, Anthropic published the Model Context Protocol, an open standard for connecting AI assistants to external data sources and tools through a common interface, shipping with SDKs, local server support in Claude Desktop, and prebuilt servers for systems like Google Drive, Slack, and GitHub. MCP mattered to Claude Code because it generalized the tool-use idea: instead of hard-coding each integration, an agent could speak one protocol and reach many services, from issue trackers to design documents. This is the "single source of truth for tool interoperability" idea in practice, and it meant the terminal agent could grow beyond the file system without a bespoke connector for every new capability.

The documented downstream influence

The clearest evidence that the research preview succeeded is what Anthropic did next. When it announced Claude Opus 4 and Claude Sonnet 4 on 22 May 2025, the company stated plainly that Claude Code was "now generally available," having graduated from preview, and it expanded the surface area with native VS Code and JetBrains integrations and background tasks via GitHub Actions. The accompanying benchmark story continued the climb: Claude Opus 4 scored 72.5% and Claude Sonnet 4 scored 72.7% on SWE-bench Verified, with Opus 4 described as able to work continuously for several hours on long-running agent tasks.

Beyond Anthropic's own trajectory, the terminal-agent pattern spread. The broader industry moved toward command-line and IDE agents that operate on whole repositories, run tests, and open pull requests, and the MCP standard that underpinned Claude Code's tool access was adopted by a range of development tools. The influence is best described narrowly and verifiably: the specific product matured into a general-availability tool with a widening set of surfaces, and the design choices it embodied (an agent loop over a codebase, gated command execution, and a protocol for external tools) became common vocabulary for agentic coding.

The honest limits

Several caveats belong in any sober account. Autonomy is not correctness: an agent that can edit files and run commands can also introduce subtle regressions, and a passing test suite is a weak proxy for a correct or maintainable change. Repository access and command execution are genuine risks, which is why permissions and human review are structural parts of the tool rather than optional add-ons. Benchmark scores describe curated tasks under a particular harness; the same model behind a different scaffold, or facing an unfamiliar codebase with sparse tests, can perform very differently, and the Claude Code documentation itself frames the tool as an assistant a developer supervises, not a replacement for engineering judgment. Finally, the launch was a research preview: it was explicitly incomplete, and treating its early results as a settled capability would overstate what 24 February 2025 actually demonstrated.

How to place the event in AI history

The right frame is modest about the day and clear about the direction. What happened on 24 February 2025 was a limited preview of a terminal-based coding agent, released as a companion to a model, backed by task-specific benchmark results and an explicit warning that autonomy is not the same as reliability. That is the narrow, documented claim, and it should not be dressed up as a revolution.

The wider judgment is that Claude Code marked a legible step in a longer shift: from AI that suggests code a human then acts on, toward AI that takes the actions itself inside a loop the human directs. Its significance came less from novelty than from composition. It fused extended reasoning, tool use, computer-use-style action, and an interoperability protocol into a spare, scriptable interface, and it did so at a point where the benchmark evidence had moved from single-digit resolution rates to a majority of a curated set. A useful way to navigate outward from this entry is to ask three questions of each neighbor in the timeline: which earlier capability (reasoning, tool use, or action in an environment) it supplied, which later product reused the agent loop while changing the surface or the autonomy level, and which limitation (correctness, permissions, or evaluation under a full harness) the next step still had to confront. Answered that way, Claude Code reads not as the invention of agentic coding but as the moment the pattern arrived, plainly and usably, at the command line.

References

• Anthropic (2025). Claude 3.7 Sonnet and Claude Code.
• Anthropic (2025). Claude Code overview.
• Anthropic (2025). Claude Code best practices.
• Anthropic (2024). Introducing computer use, a new Claude 3.5 Sonnet, and Claude 3.5 Haiku.
• Anthropic (2024). Introducing the Model Context Protocol.
• Anthropic (2025). Introducing Claude 4.
• Jimenez et al. (2023). SWE-bench: Can Language Models Resolve Real-World GitHub Issues?.
• Yao et al. (2024). τ-bench: A Benchmark for Tool-Agent-User Interaction in Real-World Domains.
• OpenAI (2024). Introducing SWE-bench Verified.
• SWE-bench (2024). SWE-bench Leaderboards.
• GitHub (2021). GitHub Copilot.