JetBrains 2026: 90% of Developers Use AI Agents Weekly, Claude Code at 39%, What Singapore Employers Must Change Now

Every year, JetBrains publishes the largest independent developer survey on the planet. Every year, it moves the needle on hiring conversations across the industry. This year, the needle did not move. It broke off. The 2026 edition, fielded between May and July across more than 15,000 professional developers in over 70 countries, documents the moment when AI coding agents stopped being a productivity supplement and became the way most software is actually produced. For anyone running engineering in Singapore, the findings require changes to job descriptions, interview loops, team ratios and compensation structures, not next quarter, but now.

The Numbers That Matter: What JetBrains Actually Found

The headline figures are stark enough that they deserve to be laid out without interpretation first, so you can form your own view before reading ours.

Code generation split (averages across all respondents):

• 47% of production code is fully written by AI agents, the developer describes the intent, the agent produces the implementation end-to-end.
• 38% is AI-assisted, the developer writes with an autocomplete or copilot-style tool providing suggestions they accept, reject or modify.
• 27% is written manually, no AI involvement at any stage.

These are not aspirational percentages from a vendor’s marketing deck. They come from 15,000 working developers describing their actual daily practice. Twelve months ago, the agentic share was in the teens. The shift from “AI helps me write code” to “AI writes the code and I review it” is the defining change of the 2026 survey.

Agent usage frequency:

• 90% of professional developers use AI coding agents at least weekly.
• 68% use them daily.
• The remaining 10% who never use agents are concentrated in embedded systems, security-cleared government work and a few legacy enterprise stacks.

Tool adoption (among those using agents):

• Claude Code: 39% global adoption, 47% in the United States.
• GitHub Copilot: 21%.
• OpenAI Codex: 16%.
• Other tools (Cursor, Windsurf, Cody, local models): combined 24%.

Language-level variation: Go, JavaScript and TypeScript show the highest agentic code share at 54-55%, more than half of all production code in those languages is now agent-written. C and C++ sit at the bottom, reflecting the deeper hardware-level reasoning required. Python falls in the middle.

Regional variation: East Asian developers (Japan, South Korea, Taiwan, mainland China) report the heaviest agentic usage at roughly double the rate of European and UK developers. US developers sit between the two. Singapore’s developer population, heavily influenced by both East Asian talent flows and US-headquartered companies, likely trends toward the higher end.

The Tool Landscape: Why Claude Code Is at 39% and What That Means for Hiring

A year ago, the AI coding tool conversation was about Copilot. The JetBrains 2026 survey has ended that conversation. Claude Code’s 39% global share, nearly double Copilot’s 21%, reflects a fundamental shift in what developers want from an AI tool. Copilot was built for autocomplete: you type, it suggests the next line. Claude Code was built for agency: you describe a task, it plans an approach, writes the implementation across multiple files, runs the tests, reads the errors, and iterates until it works.

That distinction is not academic. It determines what a “productive developer” looks like:

• An autocomplete user is still fundamentally writing code. The tool accelerates their typing. Their skill is the same skill it always was: translating requirements into implementations, one line at a time.
• An agentic user is directing a system. Their skill is decomposing problems into tasks an agent can execute, writing clear specifications, reviewing the output for correctness and security, and knowing when to intervene. The actual keystrokes-per-feature ratio drops by an order of magnitude.

When you hire a TypeScript developer in Singapore today, you need to know which kind of developer you are getting. Both can be excellent. They work differently, and the team around them needs to be structured differently. A team of five agentic coders without a senior reviewer is a factory that produces plausible code nobody has read. A team of five careful reviewers who cannot direct an agent is a team shipping at half the speed of their competitors.

What This Means for Singapore Employers: 5 Concrete Changes

Singapore sits at the intersection of the trends in this survey. The developer population here is a blend of East Asian engineers (the heaviest agentic users globally), US-trained engineers from FAANG Singapore offices, and local graduates from NUS, NTU and SUTD who have been trained on AI-augmented curricula since 2024. The practical question is not whether your developers use agents, they do, but whether your hiring process, team structure and management practices have caught up.

1. Rewrite your job descriptions

Most Singapore developer job postings still list “proficiency in TypeScript” or “experience with React” as primary requirements. Those are table stakes that an agent handles fluently. The differentiating skills are now: ability to direct an AI agent through a complex multi-file task; ability to review agent-generated code for correctness, security and performance; ability to debug subtle errors that agents introduce systematically (off-by-one, timezone handling, race conditions in async code); and ability to make architectural decisions that agents cannot yet make reliably.

We now recommend every Singapore job posting for a mid-level or senior developer include a line like: “You will use AI coding agents daily. We evaluate your ability to direct, review and debug agent output, not your typing speed.” That single sentence changes who applies and who self-selects out.

2. Add an agentic workflow round to your interviews

The traditional coding interview (whiteboard, HackerRank, timed algorithm puzzle) tests a skill that 47% of production code no longer requires. We have introduced a new round: the candidate is given a real but scoped task (add a feature to a small codebase, fix a bug that spans three files, refactor a module for testability) and a Claude Code session. The interviewer watches how they work. The scoring criteria are:

• Task decomposition: Does the candidate break the problem into agent-sized pieces or paste the entire requirement and hope?
• Prompt quality: Are the instructions specific, contextual and constrained, or vague and open-ended?
• Review rigour: Does the candidate read every line of agent output, or rubber-stamp it?
• Recovery: When the agent produces something wrong, does the candidate diagnose the root cause or just re-prompt with “that is wrong, try again”?
• Security awareness: Does the candidate catch the injection risk, the hardcoded credential, the missing authorization check?

This round takes 60 minutes and tells you more about a candidate’s production capability than any whiteboard exercise we have ever run. Our guide to evaluating AI agent skills in interviews has the full rubric.

3. Restructure your teams around review capacity

If 47% of your code is agent-written, then code review is not a courtesy, it is the primary quality gate. The JetBrains data, combined with the BairesDev survey we covered last month, converges on the same conclusion: teams need more review capacity than production capacity. Our recommendation for Singapore engineering teams in Q4 2026:

A year ago, the standard ratio was three to four producers per reviewer. The agent multiplier has inverted it. Each agentic coder produces two to three times the volume of code, which means each reviewer has two to three times the review load. If you do not hire for review capacity, your team will ship faster and break more.

4. Differentiate between agentic coders and AI-assisted coders

The survey identifies three archetypes. They are not good/better/best; they are different modes of work. An agentic coder (~31% of devs) delegates entire features to an agent and spends their time on architecture, review and debugging. An AI-assisted coder (~47%) writes code with copilot-style tools providing inline suggestions. A manual coder (~23%) works without AI tools. All three can be productive. The problem is when you hire one and manage them as another.

A team of five agentic coders needs a different standup, different metrics and different code ownership rules than a team of five AI-assisted coders. The agentic team’s bottleneck is review throughput. The assisted team’s bottleneck is the same as it always was: specification clarity and feature complexity. Mixing the two without acknowledging the difference creates friction, the agentic coder ships six PRs a day and wonders why no one is reviewing them; the assisted coder ships one PR a day and wonders why the codebase keeps changing under them.

5. Update compensation to reflect the new value chain

When an agent writes 47% of the code, the value of a developer shifts from “volume of code produced” to “quality of decisions made about code”. In Singapore, this is already showing up in salary data. Developers who can demonstrate strong agentic workflow skills (directing, reviewing, debugging agent output) are commanding a 15-20% premium over developers with the same years of experience who use only autocomplete-level tools. The 25% AI premium we reported in May is holding and widening.

For Employment Pass salary benchmarks, this means the COMPASS points calculation needs to account for AI agent proficiency as a differentiator. A Go developer in Singapore who can direct Claude Code through a complex microservices refactor is not the same hire as a Go developer who cannot, even if they have the same years of experience. Price accordingly.

How to Redesign Your Singapore Interview Loop This Month

The traditional five-stage engineering interview loop (resume screen, phone screen, take-home, onsite coding, onsite system design) was designed for a world where the developer wrote every line. Here is the updated version we now run for Singapore clients, informed by both the JetBrains survey and our own placement data:

The total candidate time is 3.5 hours, shorter than many Singapore loops. The key difference is Stage 2: watching the candidate work with an agent in real time. You learn more from watching someone direct Claude Code for 60 minutes than from watching them solve a LeetCode problem for 90. The candidate who decomposes the problem well, writes crisp prompts, reads every line of output, catches the subtle error, and explains their reasoning is the candidate you want.

For detailed rubrics, our guides on assessing AI engineering candidates and evaluating agentic skills have the scoring sheets.

What Comes Next: The 2027 Forecast

If you extrapolate from the JetBrains trajectory, agentic code share went from the teens to 47% in twelve months, the 2027 survey will likely show the agentic share crossing 60%. At that point, “developer” as a job title becomes as accurate as “typist”, it describes one part of the work, not the work itself. The roles that emerge are:

• AI system architect: designs the systems that agents build, makes the decisions agents cannot.
• Agent operator: the production coder who directs agents through implementation, tests the output, ships it.
• Code reviewer / quality engineer: the person who reads everything before it goes to production.
• Security engineer: the person who catches what the agent and the reviewer both missed.

Singapore employers who start hiring for these roles now, rather than waiting for them to become standard titles, will have a 12-month head start on the market. The AI/ML engineers, security engineers and full-stack developers you hire this quarter should already be evaluated against these future roles.

FAQ: JetBrains 2026 Survey and Singapore Hiring