Stack Overflow's 2026 developer survey put adoption of AI coding tools at 84 percent and trust in what they produce at 29 percent, down eleven points in a year. Only 3 percent said they trust the output highly. Forty-six percent said they actively distrust it.
Those two numbers describing the same population is the most useful thing published about this subject all year. It is not a story about resistance, because the same people are using the tools every day. It is a story about calibration, and if you commission software from anyone, it should change what you ask for at the end of a project.
The complaint is specific, and it is not "it does not work"
The frustration developers reported most, at 66 percent, was "AI solutions that are almost right, but not quite". Forty-five percent said debugging generated code eats serious time.
Read those together and the problem stops being about capability. Nobody is complaining that the tools fail. They are complaining about a specific and expensive failure shape: output that is plausible enough to pass a glance and wrong in a way that surfaces later.
That is a worse failure mode than an obvious one. Code that does not compile costs minutes. Code that compiles, runs, passes the tests somebody wrote against the same misunderstanding, and then behaves incorrectly on a case nobody considered costs weeks, and the cost lands on whoever is on call rather than whoever saved the time.
This matches what we see in handover work. The defects that survive into production from generated code are rarely dramatic. They are off-by-one conditions, a currency rounding that is right for one path and wrong for another, an error branch that swallows a failure silently. Every one of them looked correct.
Read More - It Works and Nobody Can Explain Why
Why the trust number fell while usage rose
Trust dropped from around 40 percent to 29 percent in a year while adoption went up. The obvious reading is that the tools got worse, and that is not what happened.
What happened is exposure. In 2023 most developers had opinions about these tools. By 2026 they had a year of production incidents traceable to something that looked fine in review, and opinions formed by consequences are different from opinions formed by demonstrations.
The trajectory is what you would expect from any technology moving from novelty to infrastructure. Early enthusiasm is based on the best case, and settled judgement is based on the distribution. A 29 percent trust figure among heavy daily users is not pessimism. It is an accurate summary of a tool that is right most of the time.
The people who should worry are the ones whose confidence has not moved at all, because that usually means they have not yet been on the receiving end.
What this changes if you are buying software
Most of the commentary about this survey was written for developers. The more useful audience is whoever signs off the work, because the acceptance conversation is where this gap actually bites.
A demonstration proves the happy path works. It has always been a weak acceptance test and it is now a considerably weaker one, because producing something that demonstrates well got dramatically cheaper while producing something that survives contact did not.
So stop accepting on demonstration. Ask what happens on the paths nobody showed you: the malformed input, the duplicate submission, the third party that times out, the customer whose data does not fit the assumption. Those are the areas where "almost right" lives.
We now run acceptance against the failure paths first and the happy path last, which is the reverse of how most sign-offs are structured. It reliably finds things, and it finds them before rather than after the invoice.
Ask who can explain it, not who wrote it
The question of whether code was generated is close to useless now, because the honest answer for almost every project is partly, and the answer tells you nothing about quality.
The question that does discriminate is whether somebody on the delivering team can explain a given piece of it without opening a tool. What it does, why it is shaped that way rather than the obvious alternative, and where it would break.
Someone who can answer that has understood the code regardless of how it was produced. Someone who cannot has moved an artefact into your production environment, and you now own something nobody comprehends. That is the same second-year problem we went through in what happens when nobody understands the system.
Make it a clause. Pick three non-trivial sections at random on delivery and ask for the explanation. It takes twenty minutes and it is a far better predictor of your maintenance costs than any code quality metric you could commission.
Budget for the review, not the writing
The commercial mistake this survey exposes is assuming that faster production means a cheaper project.
Writing got faster. Reviewing, understanding, testing and being accountable for the result did not, and those were always the larger share of a serious build. A quote that has fallen in proportion to typing speed has been priced on the wrong activity.
That is worth knowing when you compare bids. A supplier quoting substantially below the others may have priced the generation and not the verification, and the difference does not appear until the second month.
It is also the answer to the build-versus-buy arithmetic, which we worked through in why a third of companies skipped a purchase. Our custom software development work prices verification explicitly as its own line, because hiding it inside a day rate is how it quietly gets cut.
The gap is a healthy signal
It is worth ending on the optimistic reading, because the headline invites a gloomier one.
A profession that adopted a tool at 84 percent while keeping its scepticism at 46 percent is behaving exactly as you would want. Enthusiastic adoption with uncritical trust would be the alarming combination, and it is what a lot of executive commentary has been quietly encouraging.
The teams producing good work with these tools are, almost without exception, the ones treating output as a draft from a capable but unaccountable contributor. That posture is what the 29 percent figure actually describes, and it is the one to hire for.
Frequently Asked Questions
Should we avoid suppliers who use AI tools?
No, and you would struggle to find one. Adoption is at 84 percent, so the question is not whether they use these tools but what verification they run afterwards. Ask about their review process rather than their tooling.
How do we test for "almost right" in acceptance?
Exercise the paths nobody demonstrated. Malformed input, duplicate submissions, a dependency timing out, boundary values on anything involving money or dates. Near-miss defects cluster in exactly the cases a demonstration skips.
Is generated code lower quality than handwritten?
Not reliably, and that framing misses the issue. The code is often fine; what is missing is the understanding that used to be produced alongside it. The gap is in context rather than in syntax.
Our supplier's quote dropped a lot. Is that good?
Ask what it covers. If the reduction reflects faster writing, check that review, testing and support were priced separately, because those did not get faster. A quote that fell in proportion to typing speed is priced on the wrong activity.
Why did trust fall while usage rose?
Exposure. Developers now have production experience of the specific way these tools fail, which is different from having an opinion about them. Settled judgement based on consequences reads as lower confidence and is more accurate.
What single clause should we add to a contract?
That the delivering team can explain any part of the system on request, without preparation. It is cheap to include, uncomfortable to fail, and it predicts your maintenance cost better than anything else you can specify.
Does this apply to small internal tools too?
In proportion. A script one person runs occasionally does not need this. Anything touching money, customer data, or that other people depend on, needs it regardless of how quickly it was produced.
Talk to our team if you are about to accept a build and a demonstration is the only test anyone has run.

