A SemiAnalysis report published this month contains a number that should make any engineering leader pay attention: 4% of all public GitHub commits are now being authored by Claude Code. At current growth rates, SemiAnalysis projects that figure crosses 20% by the end of 2026.
That is not a gradual transition. That is an industry absorbing a new primitive faster than it absorbed cloud computing.
Before you schedule a company all-hands or order everyone to install the CLI, this post is a decision memo -- the specific questions you should answer before committing your team's workflow to a tool that bills by the token.
What the 4% number actually means
SemiAnalysis is not saying Claude Code handles 4% of easy commits. Public GitHub commit authorship skews heavily toward open-source contributors, side projects, and developer tooling -- the exact workflows where agentic coding shines.
The article frames Claude Code as the first genuine inflection point for AI agents: a system that does not just respond to prompts but executes multi-step plans, reads your codebase, runs tests, and iterates without hand-holding. Their analogy is Web 1.0 (ChatGPT API = TCP/IP + static pages) versus Web 2.0 (Claude Code = dynamic applications on top of the protocol).
That is a useful frame. It means the productivity gains are not evenly distributed across task types.
Where Claude Code earns its cost
Greenfield feature work in an established codebase. Give Claude Code a well-defined task, a clear file structure, and passing tests to run against. It will iterate through implementation, catch its own type errors, and hand you working code faster than most senior engineers can orient to the task. For a small team running a TypeScript monorepo or a Python service with decent test coverage, this is where the tool pays for itself.
Boilerplate-heavy migrations. Upgrading an API client library, converting a codebase from one pattern to another (say, React class components to hooks, or raw SQL to an ORM), or adding input validation across 40 endpoints. These are tasks that require careful repetition but not original thinking. Claude Code handles them reliably and does not get bored at hour three.
Internal tooling with low ambiguity. Dashboards, admin panels, data pipelines with well-specified schemas, test suite generation. The narrower the requirements, the better the output quality.
Exploratory spikes with throwaway intent. Need to know if a third-party API works the way the docs claim before investing real hours? Claude Code can stub, call, log, and summarize in the time it takes to read the authentication section.
Where it burns your budget without delivering
Ambiguous requirements. Claude Code is not a requirements analyst. If your spec is vague, it will confidently generate something that passes its own interpretation of the tests while missing what you actually wanted. You pay for all those tokens, then rewrite anyway.
Legacy systems with undocumented side effects. Large codebases with implicit dependencies, shared mutable state, and no tests create a trap. Claude Code can make locally reasonable changes that break something three layers away. Without a robust test suite as a safety net, you are paying for debugging, not development.
Tasks requiring domain judgment. Architecture decisions, security model design, performance tradeoff analysis -- these require someone who understands your production context. Claude Code can generate options but cannot evaluate them against constraints it cannot see.
Code review as a quality gate. Teams that route Claude Code output directly to production without human review are optimizing for speed at the expense of correctness. The tool is confident and fluent. Confident and fluent is not the same as correct.
The cost model before you scale up
Claude Code pricing runs on Anthropic's standard API rates, and a non-trivial agentic session -- one where it reads files, writes code, runs tests, and iterates -- can consume millions of tokens. At Sonnet-level pricing, a focused four-hour session on a complex feature can run $15-40 in API costs.
That number is defensible if the session replaces two engineer-hours on a task that would otherwise take longer. It is not defensible if you are using it for tasks a junior developer could handle in 20 minutes or, worse, running it on tasks where you will spend two hours reviewing and correcting output.
Before team rollout: track cost per merged PR for one month. If the figure is under your fully-loaded hourly developer cost for the time saved, expand. If it is not, adjust which task types you target.
Practical adoption path for a small dev team
- Identify three task categories from the "earns its cost" list above that match your current backlog.
- Set a monthly cap in Anthropic's console before anyone starts. $200-500 is a reasonable ceiling for a team of two to four developers in the first month.
- Require a test gate. Claude Code sessions should not end without a passing test run. If your codebase lacks tests, fix that problem first -- Claude Code can actually help you write them.
- Run a four-week pilot log. Track time saved, cost per session, and error rate versus hand-written code. Use actual numbers, not intuition.
- Review Boris Cherny's workflow tips (written by the tool's creator) before your team develops bad habits that amplify cost without improving output.
The honest call
The SemiAnalysis data is not hype. Claude Code represents a genuine shift in how software gets written -- fast enough that not evaluating it is a business risk in 2026. But the teams getting real value are the ones treating it as a precision instrument, not a replacement for engineering judgment.
The 4% that is already in the number? They are not using it on everything. They are using it on the right things.
Figure out your right things first.