84% Use It, 29% Trust It: Welcome to the Trust Recession

84 percent of developers use AI to write code. 29 percent trust what it produces. Sit with that gap for a second, because most CEOs I talk to think it's a rounding error that fixes itself with the next model release. It's not. It's the operating condition we're going to live in for the next decade, and the sooner you build for it instead of waiting for it to disappear, the sooner you stop shipping garbage at scale.

I run a tech company in Jönköping, and every week someone asks me if AI coding tools are "ready yet." Wrong question. The tools were never the bottleneck. Trust is the bottleneck, and trust doesn't scale the way adoption does. Adoption is a download button. Trust is earned through every single deploy that didn't blow up production. Those two curves are not the same shape, and 2026 is the year that finally became undeniable.

The Numbers Nobody Wants to Say Out Loud

SQ Magazine's 2026 developer survey puts adoption at 84 percent and trust at 29 percent. That's a 55-point gap. Meanwhile a fresh security study out this month found that 43 percent of AI-generated code ships with exploitable flaws. Not stylistic nitpicks. Actual security holes. SQL injection patterns, broken auth checks, secrets left in plaintext, the greatest hits of "we'll fix it later" except now a model wrote it in four seconds and a tired engineer approved the pull request in six.

CodeRabbit, one of the more honest voices in this space right now, is calling this "AI-generated code overload." Their argument, which I agree with completely: the problem isn't that AI writes bad code sometimes. The problem is volume. When one engineer can generate the output of five engineers before lunch, your review process, built for a world where humans wrote code at human speed, collapses. You don't have a code quality problem. You have a change management problem, and almost nobody built the infrastructure for it.

This is exactly the gap we've been building against at HEIMLANDR since day one. When we do AI agent development for clients, the agent writing code is the easy 20 percent. The verification layer, the thing that checks the agent's output against real constraints before it touches production, that's the actual product. Everyone racing to ship skips this part because it's slow and unglamorous. It's also the only part that determines whether you're still in business in 18 months.

The Swedish Voice That Said the Quiet Thing Out Loud

Here's what I find genuinely refreshing about the Nordic tech scene right now. Spotify veterans in Stockholm are publicly calling Lovable "so much hype." Not privately grumbling in Slack. Publicly. On the record. That kind of directness doesn't happen in Silicon Valley boardrooms, where the incentive is to talk your portfolio up regardless of what you actually believe. In Sweden we still have a cultural allergy to bullshit, and right now that allergy is doing useful work.

The trust numbers I quoted above are global. But I'd argue Sweden is ahead of the curve in one specific way: we're saying the skepticism out loud before it becomes a scandal. American boardrooms tend to discover the trust gap after the breach, after the outage, after the postmortem that makes the front page of a trade publication. Swedish engineers, culturally wired to ask "does this actually work" before "does this look impressive in a demo," are catching the same 55-point gap earlier and cheaper.

That said, I don't want to oversell Nordic virtue here. Software development in Sweden has the same underlying incentive problems as everywhere else. Investors want AI-native growth stories. Boards want faster roadmaps. The pressure to ship AI-generated code at volume exists in Kista just as much as it does in the Mission District. The difference is smaller, more transparent teams here tend to notice the smell faster. That's a cultural advantage, not a technical one, and it won't last if we get complacent about it.

Where EU Policy Is Behind, Again

The EU AI Act covers a lot of ground, but it was written for a world of discrete AI "systems" with defined risk categories. It was not written for agentic development pipelines where an AI writes code, another AI reviews that code, and a third AI deploys it, all before a human has read a single line. Sweden's regulators, through Dagens Industri's coverage of the compliance scramble this year, are honest that nobody has clean answers yet on liability when agentic code causes damage. Who's responsible when an autonomous coding agent ships the vulnerability that gets exploited? The company that deployed it? The model vendor? Right now, legally, it's a mess, and the mess isn't getting cleaned up before more of this code hits production.

Where This Actually Goes

Here's my honest read on the next two to five years, and it's not the "AI will just get better and trust will catch up" story you'll hear from vendors selling you the next model.

Trust and adoption are going to stay permanently separated, because they measure different things. Adoption measures convenience. Trust measures consequence. As models get more capable, they get more convenient, so adoption keeps climbing. But capability doesn't reduce consequence, it increases the blast radius of a mistake, because now the AI is writing more consequential code, faster, with less human review per line. The 55-point gap doesn't close. It might actually widen before it stabilizes.

What changes is who wins. The companies treating this gap as a temporary bug will keep shipping AI slop at scale, occasionally getting burned publicly, and lurching from incident to incident. The companies treating the gap as a permanent feature of the terrain will build the verification infrastructure now, while it's still a competitive advantage instead of table stakes. That's automated security scanning that actually understands context, not pattern matching. That's agentic change management, the thing CodeRabbit is pushing, where the review process itself becomes an AI-assisted pipeline instead of a human bottleneck. That's staged deployment with real rollback discipline instead of "ship and pray."

On the AGI trajectory specifically: if we're heading toward systems with genuinely general reasoning, the trust question doesn't get easier, it gets existential. A model that can write code is a tool with guardrails. A model that can architect systems, write the code, test the code, and decide what "correct" means without human framing is something else entirely. The verification layer we're talking about today, for basic code review, is the training ground for the verification layer we'll desperately need when the systems making decisions are smarter than the humans reviewing them. Build the muscle now. You will need it more, not less.

What Happens to MVP Development in This World

This matters a lot for anyone doing MVP development, including us. The old MVP philosophy was "ship fast, fix later." That philosophy assumed the cost of a bug was roughly constant regardless of how it got written. That assumption is dead. AI-generated MVPs ship faster than ever, but the 43 percent security flaw rate means "fix later" now frequently means "fix after the breach." When we run rapid MVP projects at HEIMLANDR, speed is still the point, but speed without a verification pass baked into the pipeline isn't an MVP, it's a liability with a landing page.

What to Look At

If you're a founder or CTO trying to actually operationalize this instead of just nodding along, here's where I'd point you this week:

• opencode: the open source coding agent picking up serious traction right now. Worth studying not for the code generation, but for how the harness around it is structured. That harness is the verification layer conversation in code form.
• ECC: an agent harness performance optimization system built specifically around skills, memory, security, and research-first development for tools like Claude Code and Cursor. This is exactly the kind of infrastructure I mean when I say "build the verification layer." Someone already started.
• system-prompts-and-models-of-ai-tools: a leaked and collected archive of system prompts from Cursor, Devin, Lovable, Replit, and a dozen others. If you want to understand why these tools produce what they produce, and where their blind spots are, read their actual instructions. It's the fastest education in AI coding tool behavior you'll find anywhere.
• n8n: not a coding tool, but if you're building the agentic change management pipeline CodeRabbit is calling for, workflow orchestration with real human-in-the-loop checkpoints is where you start. Don't skip the checkpoints.

What to Actually Do About It

Stop measuring AI coding success by lines shipped or velocity metrics. Start measuring it by defect rate per AI-generated commit versus human-written commit, tracked separately, forever. If you don't have that split visible on a dashboard right now, you don't actually know what your AI tools are costing you.

Build or buy a verification layer before you scale AI code generation further, not after. This is the exact work we do in AI solutions and fullstack development at HEIMLANDR: pairing AI-accelerated build speed with review pipelines that catch the 43 percent before it reaches a customer, not after a postmortem.

Talk to your board about the gap honestly. If your adoption numbers are impressive and your trust numbers aren't part of the conversation, someone in the room is going to get blindsided. Be the one who brought the data first.

Sweden's Edge, If We Use It

We have a real shot at Nordic advantage here, but only if we act on the skepticism instead of just voicing it. Breakit covers this scene closely, and the pattern I see across Stockholm, Gothenburg, and here in Jönköping is teams that are smaller, less funded, and forced to be more careful with every deploy because they can't absorb a bad incident the way a Series D company with runway can. That constraint, historically seen as a weakness, is becoming an advantage. Careful teams that build verification early are going to out-survive flush teams that shipped fast and skipped it.

The trust recession isn't a phase we're passing through. It's the weather now. Build your house for it.

Fredrik Brunnberg is the CEO of HEIMLANDR.IO, building AI and software solutions from Jönköping, Sweden. This is the daily HEIMLANDR briefing. If you found this valuable, share it with someone who builds things.