Yuval Avidani
Author
Stack Overflow's 2026 Developer Survey puts one number on every VP R&D's desk: 66% of respondents are already working with coding assistants or coding agents, but only 20% let AI touch deployment, operations, or debugging of production systems. The survey was published on October 6th, with over 30,000 respondents from 169 countries, and this gap is exactly where organizations either win or get stuck.
Let's take one example and stick with it to the end. Dana (a fictional character, not a real person) is a VP R&D at a fintech company in New York, with 120 engineers and three product managers. Half her team is already using coding agents "under the radar," management is asking where the ROI is, and the CISO is asking who approves what. In this article, we'll build her a 90-day rollout plan that you can copy and start tomorrow morning.
What is a coding agent, really, and why is it different from autocomplete
A coding agent is an AI tool that receives a task in plain words, reads the repo, runs commands, edits files, and checks its own work — built for developers who want to hand it a whole task, not just a single line. Think of it like the difference between a spell-checker and a research assistant: the spell-checker suggests a word, the assistant goes to the library, comes back with a draft, and asks you to review it.
And developers' choice is clear. According to Stack Overflow's official blog, among those working with agents, the leading tools are Claude Code at 66% and GitHub Copilot at 59%. And here's another number worth sitting with: 73% of those using coding assistants or agents do it every single day. In other words, this isn't a hobby experiment anymore — it's a daily work tool.
What the data actually says: high usage, low trust
Let's break down the numbers, because they tell a much more interesting story than "everyone's using AI":
Turns out developers mainly use AI for writing code in domains they already know well (67%) and for debugging (61%) — in other words, places where they can verify the result themselves. The moment you get to production, to deployment, and to debugging live incidents, usage drops to 20%. And in Stack Overflow's press release, the sharpest number of all shows up: only 6.6% are willing to trust AI when it comes to important decisions.
So what builds trust? According to the official blog, 93% say that to trust what AI gives them, they need source attribution — meaning knowing where the answer came from. The press release frames it slightly differently: 78.7% define source attribution as important or very important. Whichever way you phrase it, the message is the same: developers trust what they can verify.
Bottom line for Dana: her problem isn't adoption. The developers are already there. Her problem is that there's no framework turning unmonitored, private usage into an organizational process that can be measured and defended.
The obstacle: the J-curve and the review tax
This is where DORA comes in — Google Cloud's research team that's been measuring software team performance for over a decade. In May 2026 they published the "ROI of AI-assisted Software Development" report, modeling an organization with 500 engineers.
Their model shows a J-curve: a temporary dip in productivity before the gains kick in. Think of it like moving apartments: for the first couple of weeks you're less efficient, you're digging through boxes looking for the cups, and only afterward does the new place actually start working for you. According to DORA, there are three reasons for the dip: teams are learning a new way of working, there's a "review tax" (the time it takes to go over code the AI wrote), and downstream processes, like testing, need to adapt to a larger volume of code. They call this period "the tuition of transformation" and warn leadership not to cut the budget halfway through.
Still, the numbers at the end are positive: in their scenario, first-year ROI is 39%, with payback in about eight months. But there's a built-in cost: Change Failure Rate (the percentage of deployments that cause an incident) rises in the model from 5% to 6%. That sounds small, but for Dana, with dozens of deployments a week, that's exactly the difference between a quiet week and a sleepless night.
DORA's core message is that AI is an amplifier: it magnifies whatever already exists in the organization — the strengths, and also the problems. And according to the report, the big returns don't come from the tools themselves but from the system around them: the quality of the internal platform, clarity of processes, and coordination between teams.
McKinsey arrives at the same conclusion from a different angle. According to coverage of their "The state of AI in 2026" report (a survey of 1,719 respondents across 97 countries), only 37% of respondents attribute any measurable impact from AI on operating profit (EBIT), and only about 6% are considered "high performers." The interesting part is that nearly three-quarters of those high performers are rebuilding workflows around AI, compared to about a quarter of everyone else. In other words, the difference isn't how much AI you bought — it's how much you changed the way you work.
The 30/60/90 plan: how Dana rolls it out
So what do you actually do? Here's the plan I'd build with Dana, step by step:
Days 1 through 30: pick one pilot team, establish a baseline (a measurement of the current state before the change) across four metrics, and write a clear usage policy. At the same time, define agent permissions at the repo level, so the rules are code and not a document nobody reads. Here's what that looks like in Claude Code's shared settings file, stored in the repo and shared across the whole team:
This file lets the agent run lint and tests without asking, requires human approval before any git push, and forbids it from reading secrets files like .env. And here's something important to know: according to the official documentation, deny and ask rules take effect immediately, even before anyone on the team has approved the folder. In a larger organization, you can push the same rules up to managed settings, which override any other configuration.
Beyond permissions, there are three more guardrails I'd recommend Dana set up in month one. First: every change an agent writes goes through human review, exactly like code from a new developer on the team, no shortcuts. Second: the agent works on a separate branch and opens a PR, never pushing directly to the main branch. Third: a written list of what's off-limits to feed the agent — customer data or access keys, for example — signed off by the CISO. Think of it like a new driver in a fleet of vehicles: he gets a car, but also a defined route, a speed limit, and someone checking the logbook at the end of the week.
Days 31 through 60: expand to three teams and build what DORA recommends — automated testing, continuous integration (CI, automatically running tests on every change), and working in small changes. At this stage, also appoint an "agent champion" on each team — someone who collects prompts, project instructions, and patterns that work.
Days 61 through 90: compare against the baseline, decide where to expand across the organization, and only then consider letting agents touch work closer to production, like log debugging — always with a human approving.
What to measure: four numbers, not twenty
The common mistake is measuring "how many lines of code the AI wrote." That's like judging a restaurant by how much salt went into the kitchen. What matters to us is what ends up on the plate:
Change Failure Rate is the first metric Dana should check every week, because it's the early signal that speed is coming at the expense of stability. Alongside it, we'll measure review load (how long a PR waits for review, and how big the PRs are), Cycle Time (the time from the first commit to code in production), and developer experience through a short pulse survey. If cycle time drops but review load spikes, we're exactly in the J-curve DORA described: code is being written faster, and the bottleneck has simply moved to the reviewers.
And what about the product managers?
This is where most plans fail, because they treat PMs as bystanders. In my view, that's a mistake. Dana's three product managers can use agents themselves, in three places:
First is prototyping: instead of a slide deck with screenshots, a PM can build a working demo on a separate branch and bring it into the customer conversation. Second is understanding existing code: asking the agent "how does our bank transfer approval process work" and getting an answer with references to actual files — which is exactly the source attribution the survey says builds trust. Third is writing requirement docs with precise acceptance criteria, which the developers' agent can then read and build against.
The rule for product people is simple: their agent builds prototypes and documents, not features that ship to production. Code that goes out to customers goes through the team, review, and CI, exactly like any other code.
In my view: the tool is the easy part
In my view, this year's data tells one clear story: developers already solved the adoption question on their own. What's left for leadership is the hard, boring part: policy, permissions, measurement, and process change. And the research, both DORA's and McKinsey's, says that's exactly where the difference lies between an organization that profits and one that just pays for licenses.
And it's important to be fair about the limitations. The Stack Overflow survey is based on self-selected respondents, not a representative sample of all developers. DORA's ROI scenario is a model built on assumptions (for example, an employee cost of $176,000 a year), not a measurement of a real organization, and the McKinsey numbers I quoted came from coverage of the report, not the raw data itself. Every organization needs to measure itself, and that's exactly why establishing a baseline in month one isn't a suggestion — it's mandatory.
So if 66% are already working with agents and only 20% let them anywhere near production, the real question for every VP R&D is: which single metric are we starting to measure this week, so that in 90 days we can show leadership a number instead of a feeling?
Want to take this further?
Everything I described here, from permission settings to daily work with agents on a real repo, I break down in depth in the Claude Code Mastery course (in English).
For product managers who want to start working with Claude themselves, with MCP, Skills, agents, and automations, there's Practical AI with Claude in Hebrew. And for anyone who needs the basics first, without a technical background, there's AI Fundamentals.
I post demos, rollout plans, and breakdowns like this every week on YouTube and LinkedIn, and also on X, Instagram, TikTok, and GitHub.
