Claude Code: Anthropic's agent coding tool, seen from the outside

Claude Code may be the most talked-about agent coding tool of the year — and the hardest repo to read in the harness group. On GitHub it is public with 144,420 stars (per GitHub API on 2026-09-08), yet the repository contains none of the tool’s code: you install via an official installer, not by building from source. GitHub’s license field returns none, and the LICENSE.md file is exactly one line long. So what do a hundred thousand people following a code-less repo actually read there? This post tries an Outside View approach: treat the changelog, the plugins, and the ops scripts as windows, and see how much of the internal architecture shows through.

TL;DR:

• The repo public on GitHub contains none of the tool’s code — it is a control tower: changelog, 13 plugins, an issue-triage machine.
• Shipping cadence of ~1 release/day: 30 releases in the last 30 days (Aug 7 → Sep 6, per GitHub API on 2026-09-08); CHANGELOG.md has reached 387 version entries.
• The changelog is a form of architecture disclosure: output budgets for agents, a command that measures skill context costs, even the prompt-cache mechanics of agent teams surface through fix lines.
• plugins/ is the only place you can read real “code”: a six-agent review team and a three-layer security review.
• Grading for Wakii: ADOPT confidence-scoring for review findings · DIRECTION mechanism-disclosing changelogs · WATCH the license model · N/A the large-scale issue triage machine.

A public repo that contains none of the tool

The first surprise is the repo structure itself. At the commit read on 2026-09-08 (ab9b2cf), the repo root consists of these main parts:

github.com/anthropics/claude-code @ ab9b2cf
├── CHANGELOG.md   387 version entries, 6,362 lines
├── LICENSE.md     1 line — points to the Commercial Terms of Service
├── README.md      install + plugins + data usage
├── SECURITY.md
├── examples/      gateway · hooks · mdm · settings
├── plugins/       13 official plugins (markdown + hooks)
├── scripts/       8 issue-triage scripts (auto-close-duplicates.ts…)
└── (none of the tool's code — the tool ships as a packaged installer)

No source directory, none of the tool’s machine code. The README directs you to a curl script or Homebrew/Winget; npm install is marked deprecated — the tool ships as a finished package, and the repo keeps only the parts around it: docs, version history, the plugin system. The entire content of LICENSE.md is:

”© Anthropic PBC. All rights reserved. Use is subject to Anthropic’s Commercial Terms of Service.” — LICENSE.md, anthropics/claude-code @ ab9b2cf

That is why GitHub displays “no license”: not an oversight but a decision — use of the tool follows commercial terms, not a standard license. When you cannot read the code, the only way to understand the tool is to read what the team chooses to disclose. And they disclose more than you would expect: in September’s map of 50 agentic coding projects, claude-code is noted as the “fastest shipper” of the harness group.

One release a day, the changelog as an architecture disclosure

The shipping cadence defines this repo. The API returns exactly the 30 most recent releases spanning v2.1.224 (Aug 7) to v2.1.263 (Sep 6) — 30 releases in 30 days, with two on some days (v2.1.257 and v2.1.258 both on Sep 1), per GitHub API on 2026-09-08:

Tag	Published (UTC)
v2.1.263	2026-09-06
v2.1.261	2026-09-04
v2.1.260	2026-09-03
v2.1.259	2026-09-02
v2.1.258	2026-09-01
v2.1.257	2026-09-01

The full history is much larger: CHANGELOG.md at ab9b2cf holds 387 version entries across 6,362 lines, from 0.2.x to 2.1.263. What stands out is not the count but the mechanism density per entry. Release v2.1.263 is exactly one line — “Bug fixes and reliability improvements”; v2.1.261 just before it runs a hundred lines long, touching each mechanism it modified:

• New bashOutputMaxChars / taskOutputMaxChars settings raise how much output Claude receives inline for shell commands and background tasks — up to 128K characters before it gets written to a file. The agent context-budget problem, stated plainly in a changelog.
• The new /skill-doctor command — “to show which loaded skills go unused and what they cost in context, so you can prune them” — CHANGELOG v2.1.261, entry 2.1.261. A tool that measures the context cost of skills, shipped as a feature.
• One fix line reveals how agent teams operate: teammates re-sent their tool/skill announcements on the second turn, which changed the request prefix and missed the prompt cache. Without reading any code, you now know the system has a prompt cache, teammates, and announcements — because the fix line describes the mechanism.
• Guardrails travel through the changelog too: the dangerous-rm safety prompt widened to catch rm -rf in positional parameters and inside double-quoted sh -c strings; auto mode stopped auto-approving a link that packs content into a public diagram renderer, because that equals an upload. Agent safety policy, published as changelog lines.

plugins/: the only place you can read real code

13 official plugins sit right in the repo at ab9b2cf — each plugin is a folder of markdown: commands/, agents/, hooks/, and a plugin.json. This is real source, readable in full, and it shows how Anthropic uses its own plugin system.

The most instructive is pr-review-toolkit with six specialized review agents: code-reviewer, code-simplifier, comment-analyzer, pr-test-analyzer, type-design-analyzer, and silent-failure-hunter. The first principle in its system prompt reads:

“Silent failures are unacceptable - Any error that occurs without proper logging and user feedback is a critical defect” — silent-failure-hunter, plugins/pr-review-toolkit @ ab9b2cf

The code-review plugin runs 5 parallel agents — CLAUDE.md compliance, bug detection, historical context, PR history, code comments — then scores each finding’s confidence to filter false positives, exactly as described in plugins/README.md @ ab9b2cf. And security-guidance builds security review in three layers:

security-guidance — security review in 3 layers
Layer 1  PreToolUse hook   regex on ~25 dangerous patterns across Edit/Write
Layer 2  end of each turn  the diff goes to one fast LLM call;
                           high-severity findings are fed back to the agent
Layer 3  at git commit     an SDK-driven reviewer reads related files
                           (Read/Grep/Glob) to trace multi-file data flow

(diagrammed from the plugin’s README @ ab9b2cf)

Those three layers are defense-in-depth — the kind of thing you cannot see in the closed core, but here it sits outside, readable, copyable.

12,654 issues and a public triage machine

The last window is smaller but telling: 12,654 open issues and 23,069 forks (per GitHub API on 2026-09-08). The repo ships 8 issue-ops scripts — auto-close-duplicates.ts, sweep.ts, issue-lifecycle.ts… — showing that feedback at that scale is handled by tooling kept in the repo, with the ops itself public. The README even offers the shortest path: the /bug command inside Claude Code files an issue for you.

All 8 of them, at scripts/ @ ab9b2cf:

scripts/
├── auto-close-duplicates.ts
├── backfill-duplicate-comments.ts
├── comment-on-duplicates.sh
├── edit-issue-labels.sh
├── gh.sh
├── issue-lifecycle.ts
├── lifecycle-comment.ts
└── sweep.ts

(source: scripts/ @ ab9b2cf)

Wakii takes the opposite direction: the entire 9-agent team and 20 skills are described publicly in agents & kit. Side by side, these two disclosure styles are two poles of the same question: how much of the machinery behind an agent should its users get to see?

What Wakii learns

• ADOPT — Confidence-based scoring for review findings. claude-code’s code-review plugin scores each finding’s confidence to filter false positives (plugins/README @ ab9b2cf); Wakii already separates code-reviewer from verifier, but findings reach the human at nearly uniform weight. Proposal: attach a confidence to every finding; gates block only on high confidence, the rest become NOTEs — cutting both noise and review cost.
• DIRECTION — A changelog that discloses mechanisms. Release v2.1.261 explains the prompt-cache mechanics of agent teams in a single fix line; Wakii release notes currently describe features at the user level. With 24 story-* CLIs in the kit, “1-2 mechanism lines per release” would be the cheapest living documentation available.
• WATCH — The “ToS instead of a license” model: a closed core with an open markdown-plugin rim. Watch whether the plugin marketplace becomes the industry’s distribution layer — Wakii has 20 readable skills but no marketplace layer yet.
• N/A — The issue-triage machine for 12,654 open issues. claude-code’s scripts/ exists because of that community scale; at Wakii’s current scale, an auto-close-duplicates rig is needless cost.

If you are building agents and want to see a team of agents with gates and separated review roles actually run, download Wakii and read the story workflow. Claude Code teaches through what it withholds — Wakii chooses to teach through what it opens.