Claude Code Just Overtook Copilot: What JetBrains' 15,000-Developer Survey Means for Your AI Stack

In late August 2026, JetBrains published the AI coding agent section of its 2026 Developer Ecosystem Survey, based on more than 15,000 professional developers worldwide between May and July. The headline number: Claude Code usage at work rose from 18% in January 2026 to 39%, and 47% in the United States, overtaking GitHub Copilot, which fell from 29% a year ago to 21%. OpenAI Codex grew roughly fivefold, from 3% to 16%, in six months. Just as important, about 90% of developers now use AI coding agents at work at least weekly and 68% daily. The market leader changed, and agentic workflows are officially routine. This post skips the hype and talks decisions: how to pick a primary agent, why review pipelines are the new bottleneck, and how to measure whether an agent earns its tokens.

1. What the Survey Actually Says

According to the JetBrains blog, about 39% of professional developers worldwide used Claude Code at work in May through July 2026, up from 18% in the January 2026 survey, and 47% in the United States. Claude Code is also the most-used AI coding tool for 31% of developers, an almost 80% conversion rate from regular use to primary tool. GitHub Copilot fell from 29% to 21% year over year but still holds 79% mind share. Codex is the fastest riser, from 3% in January to 16%. Cursor sits near 12%. The read is straightforward: developers are no longer paying for autocomplete; they are paying for agentic workflows that plan, execute, and debug.

# Track adoption honestly: usage per week is the signal, not seats.
SELECT
  date_trunc('week', event_at) AS week,
  tool,
  COUNT(DISTINCT developer_id) AS active_devs,
  COUNT(DISTINCT CASE WHEN days_used >= 5 THEN developer_id END) AS daily_devs
FROM agent_usage_events
GROUP BY 1, 2
ORDER BY 1;

2. Why Copilot Lost and Agents Won

Copilot defined phase one of AI-assisted coding: inline completion with a human in the loop. Agents define phase two: give a task, and the tool reads the repo, edits files, runs tests, and opens a pull request. The JetBrains data says phase two is no longer a niche choice but the mainstream way of working, with 68% of developers using agents daily. For teams, the selection criteria shift from whose completions feel smoothest to who manages context best, who recovers from failure with the fewest tokens, and who fits your existing review workflow. Independent evaluations keep reaching the same conclusion: developers care about net productivity, first-pass correctness, token efficiency, and fitting naturally into the workflow, not isolated moments of assistance.

# A minimal CLAUDE.md-style contract that makes agents cheaper to run.
# The more project truth lives here, the fewer tokens agents waste guessing.
# File: CLAUDE.md (or AGENTS.md) at the repository root.
# checkout-service
# - stack: TypeScript, Fastify, Postgres
# - run tests: npm test (unit) | npm run test:integration
# - style: strict TS, no any, arrow functions
# - do NOT modify: src/generated/**, migrations/*_done.sql
# - commit format: conventional commits

3. Do Not Pick One: Layered Usage Beats Taking Sides

Most developers in the survey use several tools, and that is the answer: instead of forcing the whole company onto one agent, layer them. Use lightweight completion and inline tools for small edits and code explanation; hand long-horizon work such as cross-file refactors and flaky-test debugging to a CLI agent; and run an independent AI reviewer over what any generator produced. Layering also hedges vendor lock-in: models turn over every six months in 2026, and betting your primary tool on a single model means betting productivity on someone else's release cadence. Repository-level convention files such as CLAUDE.md make switching cheaper by storing project truth once.

# Review-pipeline capacity is the new bottleneck. Watch it before agents scale.
# Alert when human review coverage drops below 80% or review lag spikes.
WITH pr_stats AS (
  SELECT
    date_trunc('day', created_at) AS day,
    COUNT(*) AS prs,
    COUNT(*) FILTER (WHERE first_review_at IS NOT NULL) AS reviewed
  FROM pull_requests
  GROUP BY 1
)
SELECT day, prs, reviewed,
       ROUND(100.0 * reviewed / NULLIF(prs, 0), 1) AS review_coverage_pct
FROM pr_stats
WHERE review_coverage_pct < 80
ORDER BY day DESC
LIMIT 14;

4. The New Bottleneck Is the Review Pipeline, Not Code Generation

Microsoft's July study already warned that coding agents merge about 24% more pull requests while human review coverage falls and reviewer workload doubles. The JetBrains survey pushes the same trend wider: when 68% of developers use agents daily, generated code volume will outrun human review capacity. Three countermeasures work: put automated review first so an AI reviewer passes over every diff before a human looks; enforce CI gates that reject oversized pull requests; and alert on review capacity so coverage drops below a threshold pause agent work instead of grinding through.

5. Measure Whether the Agent Earns Its Tokens

Adoption is a process metric; the real outcomes are cost and quality per merged pull request. Teams should track three numbers: tokens consumed per merged PR by joining agent logs with merge records, rework rate for AI-generated code, and median review latency. The JetBrains finding that 90% of developers are weekly users and 68% daily proves habits have formed, but if token spend doubles while PR throughput stays flat, the agent is doing busywork. Look at these three numbers weekly; they will tell you whether to switch tools more honestly than any vendor launch.

# Gate merges on automated checks that do not trust the agent.
name: agent-pr-gate
on: pull_request
jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: AI review pass
        run: evergreen-review --diff origin/main...HEAD --min-score 8
      - name: Unit tests
        run: npm test
      - name: Diff size guard
        run: |
          CHANGED=$(git diff --name-only origin/main...HEAD | wc -l)
          test "$CHANGED" -le 40 || (echo "PR too large to review safely" && exit 1)

6. Your Action List

First, record your team's real tool usage this week instead of picking sides by impression. Second, write a project convention file for every repository that states the stack, test commands, and do-not-touch directories; it is the cheapest way to cut agent token waste. Third, make quality gates model-agnostic: AI review, unit tests, and diff inspection should never be self-assessed by the generating agent. Fourth, instrument the review pipeline with alerts so coverage drops trigger a pause rather than a grind. Finally, review the three cost and quality numbers monthly with the whole team, and treat any vendor benchmark claim as a hypothesis to test against them. The winners in the survey will keep changing, but teams that own their context, gates, and metrics will not swing with the market.

# Measure tokens per merged PR so agent ROI is a number, not a feeling.
def tokens_per_merged_pr(agent_logs, merged_prs):
    spent = sum(e.tokens for e in agent_logs if e.pr in merged_prs)
    return {
        "merged_prs": len(merged_prs),
        "tokens_spent": spent,
        "tokens_per_pr": round(spent / max(len(merged_prs), 1))
    }

print(tokens_per_merged_pr(load_logs(), load_merged_prs()))