Flamingo Raises $4.5M Seed Round

Skip to content

Vibe coding security risks: what MSPs inherit from client built apps

Security
Technology
AI
August 20, 2026
953 views
Vibe coding security risks: what MSPs inherit from client built apps

Clients are shipping AI-written apps onto the networks you manage, and the code inside them was never reviewed. Here is what the 2026 research shows, which failure modes reach your helpdesk, what a CISO's vibe coding policy needs, and how to scope and price the cleanup.


Updated: November 2026

A client's ops coordinator builds an internal quoting app over a weekend with an AI coding agent, wires it into the CRM with a live API key, and parks it on a VM inside the network you manage. When it starts throwing errors on Monday, the call comes to you, and no human ever reviewed the code inside it. Vibe coding security risks stopped being a developer topic the moment AI-written software started landing on networks MSPs are paid to protect.

TL;DR

  • The short answer. Vibe coding security risks are the auth gaps, leaked secrets, and injection flaws that ship when an AI writes code nobody reviews.
  • The data. In the SusVibes benchmark from Carnegie Mellon researchers, 57% of agent-written solutions worked and only 11.8% were also secure.
  • The exposure. Clients build these apps without telling IT, so discovery comes before hardening.
  • The policy. A CISO's vibe coding policy needs approved tools, a review gate, secrets scanning, dependency checks and scoped credentials.
  • The move. Put AI-written code in your scope of responsibility in writing, then price the cleanup as work.

What the research says about AI-written code

The numbers have barely moved from one round of testing to the next.

Veracode's 2026 GenAI Code Security Report, released in July 2026, tracked more than 100 models across four testing snapshots and found the average security pass rate stuck at 56%, virtually unchanged from the year before. Pass rates by language ran from 63% for Python down to 30% for Java. The 2025 edition found 45% of code samples failing security tests, with Java failing 72% of the time. Models got faster and more fluent in twelve months. They did not get safer.

Researchers at Carnegie Mellon and partner universities built SusVibes, a benchmark of real feature requests from open-source projects where human programmers had once committed a vulnerable version. In the ICML 2026 version of the paper, built on 186 tasks, SWE-Agent running Claude 4 Sonnet produced functionally correct code 57% of the time, and only 11.8% of its solutions were both correct and secure. That means roughly four in five of the solutions that worked failed the security tests. The first version of the paper, published in December 2025 with 200 tasks, reported 61% and 10.5%. The researchers also tested the obvious mitigation, adding vulnerability hints to the feature request, and it didn't fix the problem.

The downstream effect is already showing up in the CVE feed. Georgia Tech's Vibe Security Radar confirmed 74 AI-linked CVEs through March 2026, 14 of them critical and 25 high. It found about 18 in the second half of 2025, then 56 in the first three months of 2026, with 35 in March alone, more than all of 2025 combined.

Chris Wysopal, Veracode's co-founder and chief security evangelist, put the takeaway plainly in the report's release, carried by SD Times: "AI-generated code needs to be treated like any unreviewed code: scan it, fix it, and never ship it blind." That's the standard to carry into every client conversation below.

The failure modes that reach your helpdesk

A technician on a Tuesday needs to know which flaws repeat, and the aggregate failure rate won't tell them.

Credentials written straight into the code

AI coding agents optimize for working software. A working integration needs a key, and the fastest path to a working integration is pasting the key into a config file. GitGuardian's State of Secrets Sprawl 2026 put the secret-leak rate on Claude Code-assisted commits at 3.2%, against a 1.5% baseline across all public GitHub commits, and counted 28.65 million new hardcoded secrets pushed to public GitHub in 2025, up 34% year over year. When those keys belong to systems you manage, the blast radius of a client's side project is your RMM, your backup platform, or their production CRM.

Endpoints with no authentication at all

In February 2026, a security review posted to Reddit alleged 21 findings in Huntarr 9.4.2, a self-hosted tool that automates media library management for apps like Sonarr and Radarr. The headline finding was a settings endpoint that could return a full configuration dump, API keys and passwords for connected services included, without a proper login check. The maintainer took the subreddit private, the repo vanished, and the advice that circulated was to take the app offline and rotate the key for every connected app.

Whether an agent wrote Huntarr's code was never confirmed, and the lesson holds either way: the audit of vibe-coded apps cited below found their flaws concentrated in broken access control, injection and authentication failures. The app itself may be low value, while the credentials inside it reach everything it connects to, and an unauthenticated endpoint on an internal VM punches a hole through whatever network controls sit around it.

The injection classes models keep getting wrong

Veracode's 2025 testing found AI tools failing to defend against cross-site scripting in 86% of relevant code samples. That's first-year appsec material, and it shows up because a model writing code from a prompt has no reason to imagine a hostile input unless someone tells it to.

Why the same flaws keep coming back

A study of vibe-coded applications, last revised in September 2026, audited 200 publicly deployed apps built with Claude Code and Lovable and found 1,186 vulnerabilities. Of those apps, 91% had at least one, and about two-thirds of the flaws were rated Critical or High. The researchers traced them to eight recurring failure modes rooted in three limits of AI agents, which they call memory, objective and knowledge defects. Better agent harnesses and prompting lowered the rate without removing the underlying risk, and that's the part worth carrying into a client conversation. A promise to be more careful next time doesn't change a failure mode baked into how the tool works, so the control has to sit outside the prompt: review, scanning, and a hard limit on what the app can reach.

Dependencies that nobody vetted

Coding agents pull packages with confidence, including packages that don't exist until an attacker registers the name a model likes to invent. A client app assembled in an afternoon can carry dozens of transitive dependencies that never passed through any review, any license check, or any software bill of materials. If you're already running vendor risk management on the tools in your own stack, this is the same problem arriving through a side door.

Watch the same failure modes get found and fixed in a real app:

Why this lands on the MSP

The people building these apps don't consider themselves developers, and they don't tell anyone what they've built.

Help Net Security's coverage of Lenovo's Work Reborn research, a survey of 6,000 full-time employees at enterprise organizations, reported that between one-fifth and one-third of workers use AI outside IT's governance, and 31% get no AI training from their employer. Lenovo's CIO Playbook adds that 61% of IT leaders say AI is increasing cybersecurity risk, and only 31% are confident they can address it.

An r/msp thread from January 2026 asks the same question from the MSP side: are clients pasting customer data into ChatGPT, or is the risk still theoretical?

So the app gets built, it works well enough for the team that wanted it, and it runs quietly until something breaks or someone finds it. When that happens, the call comes to you, never to the coordinator who built it or the model that wrote it.

There's a compliance edge to this as well. A client in a regulated vertical who quietly stands up an app handling patient records or card data has changed the scope of their own audit without telling anyone, and the assessor will ask the service provider what controls covered it. Cyber insurance applications ask a version of the same question: does the applicant maintain an inventory of software and enforce change control. A truthful yes gets harder when a chunk of the estate was written by an agent over a weekend. Neither of those conversations goes better six months later, which is the argument for finding the apps now rather than after a claim.

Petri's coverage of AI shared responsibility gets the boundary right: an MSP can't own every prompt or business decision a client makes, but it can own the environment around the tool, policy, permissions, identity, training, and governance. That distinction is worth writing down before an incident forces the conversation, because the default assumption from a client after a breach is that anything on the network was covered by the contract.

Who owns what when a vibe coded app breaks

Developer-focused coverage of vibe coding tells people to scan their code and stops there. This table is for the service provider who inherits the code without ever seeing the repo.

AreaClient ownsYou ownContract language to add
Deciding to build with AIYes, it's their business processNoAcceptable use policy naming AI coding tools
Discovering what existsNo, they forget what they builtYes, via asset and network discoveryQuarterly AI app inventory as a billable deliverable
Where the app runsShared, they pick, you place itYes, segmentation and accessHosting standards for client-built software
Secrets and API keysNoYes, issuance and rotationKey issuance policy, no shared admin credentials
Code review before deployShared, they pay for itOnly if scoped and paidNamed add-on service, not implied coverage
Runtime monitoringNoYes, if the asset is in scopeEndpoints and workloads covered, per asset
Incident responseNoYesIR retainer that names client-built apps explicitly
Liability for a flaw in their codeYesNo, unless you reviewed and approved itLimitation clause carving out unreviewed code

Law365's guidance on AI provisions in MSP contracts asks the question this table answers: if an AI tool suggests code with a security vulnerability, who is responsible? Its answer is human oversight, with the client as the final judge of AI output. A standard agreement covering uptime, helpdesk, and device management leaves that open. A shared responsibility annex settles it, and it turns an argument into a line item.

The discovery pass to run this quarter

Hardening comes second. You can't harden what nobody has found yet. This pass takes a couple of hours per client and surfaces what's hiding:

  1. Sweep internal subnets for web services on non-standard ports, then match every listener to a known asset. Anything unmatched is a candidate.
  2. Pull the software inventory for AI coding tools and IDE agents on client endpoints. Those installs mark which teams are building.
  3. Check egress logs for API calls from workstations to production systems. A user machine talking to the CRM API on a schedule is a script somebody wrote until proven otherwise.
  4. Ask each department head one question: what did your team build this year that IT doesn't manage? People answer it openly when it isn't framed as an audit.
  5. Scan any repo or shared drive the client gives you access to for committed keys, then rotate everything you find rather than reporting it and waiting.
  6. Put every discovered app into the asset register with an owner name attached, so the next incident has a person to call.

Do this once and the inventory stops being a guess. Do it quarterly and you have a service line, plus a defensible record of what was in scope when.

Triaging one after you find it

Discovery produces a list, and the list needs an order. Sort by what the app can reach rather than by how important the client says it is. An app holding a read-only copy of last quarter's numbers matters less than the one with write access to the CRM, however proud its author is of it.

Start with credentials, because they're the fastest thing to fix and the costliest to leave. Pull every key the app uses, rotate it, and reissue scoped credentials that can only touch what the app needs. If the app was using a shared admin account, that account was a problem before the app existed.

Then check exposure. Confirm whether the thing is reachable from outside the network, from the guest VLAN, or from any segment its users don't sit in. A client-built app needs to be reachable by a handful of people, and constraining that takes a firewall rule and a DNS entry rather than a project.

Only then look at the code, and only if the client is paying for it. Scanning is where the hours go, and hours given away become the expectation. Report findings against the app's owner name in the asset register, with a remediation quote attached. One client will pay to fix it. Another will decide the app wasn't worth what it costs to run safely and switch it off, which is a fine outcome and a fast one.

Price the cleanup instead of absorbing it

AI-written code speeds up a security debt problem that was already there before agents arrived. The commercial question for a service provider is whether that acceleration shows up as unbilled hours or as revenue.

Three packages work well here, and they don't require new tooling to start. A discovery and inventory engagement, run quarterly, priced per site. A code review add-on for any client-built app that touches production data, priced per app with a named turnaround. An AI acceptable use policy build, delivered once with an annual review, that names which tools are allowed, where output can be deployed, and who signs off before anything reaches a live system.

That third one pays back fastest. A written policy converts a vague expectation into an agreed boundary, and it gives the technician on the call something to point at when a client asks why their weekend project needs a review before it goes live.

The rest is enforcement, and enforcement is where the shape of your own stack starts to matter. If asset discovery lives in the RMM, the ticket lives in the PSA, the policy lives in a document nobody opens, and the security alert lives in a fourth console, the AI app a client stood up in March gets found in November. Consolidation is how the inventory stays current between quarterly passes. That is the same argument behind the MSP security stack discussion, applied to a category of risk that didn't exist two years ago.

What a CISO should put in a vibe coding policy

The policy build in that third package is where a client's CISO, or you as their virtual CISO, sets the rules for software people build with AI. An AI governance framework covers AI use across the business, and the vibe coding policy is the part that governs code. It needs five controls:

  1. Approved tools. Name the AI coding tools staff may use, on business accounts with the vendor's data controls switched on, and keep company code out of personal accounts.
  2. A review gate before production. No AI-written code touches production data or a production network until a named person reviews it. Enforce it with branch protection or a required approval in the code host, or a sign-off in the change ticket where there's no repo.
  3. Secrets scanning at commit time. Run a scanner as a pre-commit hook and again in the pipeline, so a key is caught before it reaches a repo, and send every key it finds to rotation. GitGuardian's 3.2% leak rate on Claude Code-assisted commits is the number to quote when someone asks why.
  4. Dependency checks before merge. Every package the agent adds goes through software composition analysis or an allowlist, which catches invented package names and known-vulnerable versions.
  5. Scoped credentials and an inventory. Each app gets its own least-privilege keys, never a shared admin account, and goes into the asset register with an owner.

Add an exception path with an expiry date on every exception, because a policy with no way to say yes pushes the building back out of sight. Review the policy once a year alongside the AI acceptable use policy, with the same people signing off.

What to tell clients who ask if they should stop

They shouldn't, and telling them to stop won't work anyway. The study of vibe-coded apps above found that better agent setups and prompting lower the vulnerability rate without removing it, so the risk sits in shipping without review.

Give the client three rules and they'll follow them, because they're cheap: nothing built with AI touches production data before a review, no credentials live in code, and every app has a named owner in the asset register. Everything else is refinement.

For MSPs weighing where AI belongs in their own delivery, the same logic holds. Output gets reviewed, credentials stay out of prompts, and the tool is judged on what it produces under scrutiny. That's the standard worth applying to the AI tools MSPs adopt internally too.

The other side of the same wave: practitioners now build and open-source MSP tooling with the same AI agents. Ed Mozley runs infrastructure for a London law firm by day and built FreeITSM at their kitchen table in months - a 20-module, free-forever open-source ITSM platform already running in production. Built with review and shipped with discipline, the same workflow that produces the liabilities above produces real tools. They tell the story on the OpenMSP podcast:

Vibe coded apps aren't going back in the box. Clients will keep building them, faster every quarter. Communities like OpenMSP share more info about such cases. If you'd like, join OpenMSP here. It's peer-driven and vendor-neutral.

Kristina Shkriabina

Content Marketing Lead

Ohayo! I run content, SEO, social, and community at Flamingo. Before IT, I worked as a correspondent for Ukraine's Public Broadcasting Company and have a Master's in journalism.

Related Content

Frequently Asked Questions

/blog/vibe-coding-security-risks

Still deciding?

Ask Mingo answers from our docs and customer stories.

Loading related content and questions