Claude Code Origin Story: From Safety Alignment to Agentic Coding

Introduction

Claude Code is often described as an agentic coding tool, but its origin story is more unusual than a typical developer product launch. The story starts inside Anthropic’s early safety and alignment work, passes through an experimental VS Code assistant and an internal command-line tool called clide, and eventually becomes Claude Code, a terminal-first coding agent used for large-scale software work.

The original Chinese article on BAAI/Zhiyuan Community was based on a Xinzhiyuan report and points readers to Anthropic’s official page, The Making of Claude Code. This publish-ready English version keeps the same core sequence and meaning, while rewriting the article in a cleaner blog style. It avoids promotional QR codes, platform decorations, and unrelated social-media calls to action.

Claude Code Is Only “1% Done”

One of the most striking parts of the Claude Code story is not that it became popular. It is that the people behind it still describe it as extremely early.

Boris Cherny, a core developer and leader behind Claude Code, framed the product’s origin in a way that surprised many readers: Claude Code did not begin as a polished coding product. It grew out of Anthropic’s internal safety and alignment research. The same research environment that explored how models could reason, call tools, and operate safely also produced the building blocks for an AI coding agent.

That background matters. Claude Code is not just a smarter autocomplete system. Its core idea is closer to an agent that can read a project, reason through a task, edit files, run commands, and ask for permission when an action changes the environment. Anthropic’s current documentation describes Claude Code as an agentic coding tool that can work in the terminal, IDE, desktop app, and browser.

The phrase “1% done” is powerful because it suggests that the current product is only an early version of a much larger shift. If the first wave of AI coding tools focused on suggestions and snippets, the next wave is about longer-running work, safer tool use, and deeper delegation.

Anthropic’s Official Origin Story Goes Public

Around the same time, Anthropic published The Making of Claude Code, giving a more detailed official account of how the product came together. The article frames Claude Code as a time capsule: part product history, part oral history, and part record of how quickly AI software engineering has changed.

The story begins in 2021, when Anthropic was still figuring out what kind of product it might build. According to the official account, one of the first product experiments was a coding assistant. That is a surprisingly early bet. At the time, today’s agentic coding workflows were not yet mainstream, and the infrastructure for safe model-driven development was still immature.

The early motivation was straightforward but ambitious: if AI was going to become transformative, software engineering would likely be one of the key paths. Code has clear feedback loops. A model can propose a function, run tests, inspect failures, and revise its output. That makes coding a natural proving ground for AI systems that do more than answer questions.

Claude Code Was Almost Forgotten

The early work did not immediately become Claude Code. In 2021 and 2022, Anthropic’s teams explored coding assistants from several angles.

Ben Mann, Anthropic co-founder and Labs team lead, recalled that the first product direction included a VS Code extension. It allowed users to chat with the assistant and receive multiple suggestions for what to do next. By spring 2022, the tool reportedly had a small group of external users, but it was still far from the agentic product people know today.

At the same time, researchers were asking a bigger question: could models move from writing small functions to doing autonomous software engineering work? That meant not only generating code, but also running it, checking results, using tools, and handling messy real-world development environments.

This is where the difficulty became clear. A coding agent needs more than a model. It needs a controlled environment where it can execute commands, read and write files, stream input and output, handle timeouts, recover from failures, and keep state across a task. Those infrastructure problems are still central to modern agent systems.

The original Chinese article emphasizes how easy it was for the coding assistant idea to fade into the background. The research work continued, but the product direction had not yet found its final shape.

The Infrastructure Problem Behind Agentic Coding

A reliable coding agent needs to interact with the outside world. That makes it more powerful, but also much harder to build safely.

A simple chatbot can stay inside a conversation. A coding agent cannot. It must inspect files, search a repository, run shell commands, apply diffs, and sometimes call external services. Each of those actions introduces risk. A wrong command can break a local environment. A careless permission design can create security issues. A poor execution loop can leave the agent stuck, slow, or unreliable.

Anthropic’s Claude Code documentation shows how seriously this architecture is treated. Claude Code uses read-only permissions by default. When it needs to edit files, run tests, or execute commands, it asks for explicit approval unless the user or organization has configured a safe allowlist. The docs also describe sandboxing, write-scope restrictions, prompt-injection protections, MCP security considerations, and best practices for working with sensitive code.

This is why the product’s safety origin is not a side detail. The same questions that matter in AI alignment also matter in agentic software tools: what can the model do, when should it ask, how should permissions work, and how do users stay in control?

Anthropic Was Early, Maybe Too Early

Between late 2022 and 2023, the research direction started to become more concrete. The teams worked on capabilities that now feel obvious in AI coding tools: function calling, file search, bash access, and diff generation.

One internal tool, called clide, became an important bridge between research and product. It was a command-line environment that let people chat with Claude to edit code and complete development tasks. People who saw it understood the promise, but the tool still had major limitations. It could be slow, fragile, and difficult to use.

This is a common pattern in early AI products. The core idea is right, but the timing, interface, model capability, and reliability are not yet aligned. Anthropic had many of the pieces, but not yet the final product experience.

That changed when Boris Cherny joined Anthropic Labs in 2024.

Boris Cherny and the CLI Prototype

In September 2024, Boris Cherny joined Anthropic Labs and began exploring agentic coding. The direction he received was not to design only for the models available that day, but to build for where models might be in several months.

Instead of starting with a large product plan, Boris built a small CLI prototype while learning the Anthropic API. It was rough, but it had the right shape: a terminal-native interface, tool use, file access, shell execution, and a developer workflow that felt close to the environment engineers already used.

The reaction at first was not dramatic. A demo shared internally did not immediately convince everyone. But the prototype kept pulling Boris back in. The decisive moment came when he used the earlier clide system on a real pull request problem. The tool generated the small pull request he needed, and the experience felt like a glimpse of the future.

That moment showed that the research pieces were already there. What was missing was the right integration layer: a focused product that made those pieces usable in the daily workflow of a software engineer.

The Final Sprint Toward Claude Code

By late 2024, the project had enough momentum to become a real product push. A small team expanded, and the last stretch of development moved quickly.

The team focused on the practical details that turn a prototype into something people can actually use: bug reporting, login flow, updates, usage metrics, command behavior, and the feel of the terminal experience. The pace was intense. The original report describes a short sprint where fixes could ship within minutes, without the heavy process that might slow down a fragile early product.

In February 2025, Claude CLI was released publicly and became Claude Code.

At launch, the feedback was mixed. Many people understood the idea, but bugs and rough edges were still visible. The larger shift came as Claude models improved. As the underlying model became stronger at planning, tool use, and code reasoning, the product experience improved with it.

From 10% to 100%, and the Remaining 99%

The original article highlights a dramatic change in how Boris described his own coding workflow. In early 2025, Claude Code was writing a portion of his code. Months later, that portion had risen sharply. By winter 2025, the claim was that his coding work was being handled through Claude Code rather than manually typed line by line.

Whether every team or developer will work this way is still an open question. What is clear is that the role of the engineer is changing. The work is less about typing every line and more about setting direction, reviewing plans, granting permissions, validating results, and deciding when the agent should continue or stop.

Anthropic’s security documentation makes this point indirectly. Claude Code only has the permissions the user grants. That means the human remains responsible for reviewing proposed changes and commands, especially in sensitive repositories. The better the tool becomes, the more important it is to design trust, review, audit, and permission flows carefully.

This is why the “1% done” message matters. The next 99% is not only about better code generation. It is about long-running autonomous work, persistent memory, safer context management, open-world planning, multi-agent workflows, and stronger human oversight.

What Claude Code Changes About Software Engineering

Claude Code represents a shift from assistant-style coding to agentic coding. In the assistant model, the user asks for help and then manually performs most of the work. In the agentic model, the tool can act across files, tools, and commands while the user supervises.

That does not remove the need for engineering judgment. It changes where that judgment is applied. Engineers still need to understand architecture, correctness, security, tradeoffs, and product intent. But instead of spending all their time writing boilerplate or moving between files manually, they may spend more time giving high-quality instructions, reviewing generated changes, and designing safe workflows for AI agents.

The original article ends with a broader claim: programming may become less of a narrow specialist activity and more of a managed collaboration between humans and AI agents. That future is not complete yet. Claude Code’s own origin story suggests the opposite: the field is still early, unstable, and full of unsolved infrastructure problems.

Still, the direction is hard to ignore. Claude Code started as a safety-alignment-adjacent research thread, nearly disappeared as an early coding assistant, returned through internal agent experiments, and finally became a product that changed how many developers think about software work.

FAQ

What is Claude Code?

Claude Code is Anthropic’s agentic coding tool. It can understand a codebase, edit files, run commands, and help with development tasks through natural language instructions.

Did Claude Code really come from safety and alignment research?

According to the public origin story discussed in the source article, Claude Code grew from research work inside Anthropic that involved coding, tool use, and agentic systems. The product did not begin as a conventional IDE feature. It emerged from experiments around how models could safely act in software environments.

What was clide?

clide was an internal Anthropic command-line tool used before Claude Code. It allowed people to chat with Claude for code editing and development tasks, but it was still too slow, fragile, and research-oriented to become the final product experience.

Why is Claude Code considered agentic?

Claude Code is agentic because it can work across files, tools, and shell commands rather than only suggesting code snippets. It can inspect a project, make changes, run tests, and continue iterating while asking for permission when needed.

Is Claude Code safe to use on real repositories?

Claude Code is designed with permission controls, read-only defaults, scoped write access, and other safeguards. Even so, users should review proposed commands and code changes before approval, especially when working with sensitive projects.

What does “Claude Code is only 1% done” mean?

The phrase means that the current product is still seen as an early step toward more capable coding agents. The remaining progress likely involves longer-running autonomy, stronger memory, better context handling, safer permissions, and more reliable planning.

Does Claude Code replace software engineers?

Claude Code changes the workflow, but it does not remove the need for engineering judgment. Developers still need to define goals, review outputs, understand systems, test behavior, and make architectural decisions.

Related Tools

• Claude Code: Anthropic’s agentic coding tool for terminal, IDE, desktop, and browser workflows.
• Claude Code GitHub Repository: The official public repository for Claude Code resources, plugins, examples, and issue tracking.
• Anthropic Console: The developer platform for accessing Anthropic models and API tools.
• Visual Studio Code: A widely used code editor that supports Claude Code integration workflows.
• Git: The version control system used in most modern software development workflows.
• Model Context Protocol: A protocol for connecting AI assistants to tools, systems, and external context.

Related Links

• The Making of Claude Code: Anthropic’s official origin story for Claude Code.
• Claude Code Overview: Official documentation explaining what Claude Code is and how it can be used.
• Claude Code Quickstart: Official setup guide for getting started with Claude Code.
• Claude Code Security: Anthropic’s guidance on permissions, prompt injection, cloud execution, and safe usage.
• Claude Code Permissions: Official documentation for configuring permissions and approval behavior.
• Claude Code in VS Code: Official guide for using Claude Code with Visual Studio Code and supported IDE workflows.

Summary

Claude Code’s origin story is not a simple product-launch story. It began with Anthropic’s early research into coding, alignment, tool use, and autonomous software engineering. Early experiments included a VS Code assistant and the internal clide tool, both of which showed promise before the final product shape was clear.

Boris Cherny’s CLI prototype helped connect those research pieces into a practical developer workflow. Once the product shipped and the underlying Claude models improved, Claude Code became a clear example of how AI coding tools are moving from autocomplete toward agentic software work.

The most important lesson is not that Claude Code is finished. It is that agentic coding is still early. Permission systems, long-running tasks, memory, context management, and human supervision will define the next stage.

Claude Code may feel like a major leap already, but its own builders frame it as the beginning, not the endpoint.