AI writes the code. Who is responsible for it? Why an experienced developer is worth more in 2026, not less
TL;DR
Difficulty: Beginner
AI can produce a working demo in an afternoon, but a demo is not a product. Research finds 45% of AI generated code samples introduce an OWASP Top 10 flaw, and a scan of 5,600 live vibe coded apps found over 2,000 serious vulnerabilities and 400 exposed secrets. The nine dangers run from invisible security flaws through agents with production keys, accidental breaks on critical paths, architecture debt, compliance and new insurance exclusions to lock in and misleading measurement. The answer is not to avoid AI. Let it build where mistakes are harmless, draft where a person edits, and only advise where a named, accountable person decides and tests.
Somewhere in the first conversation it comes up: "Can't we just do this with AI?" In 2026 it is a fair question, and the honest answer is more useful than yes or no. Here is the complete picture: what the research measured in AI generated code, the nine dangers in the order they get expensive, what "experienced" means now that the typing is the easy part, exactly how I use AI by risk tier and why that lowers my prices, the evidence you get in writing, and twelve questions to ask anyone who wants to build your software.
The question every client is entitled to ask
Somewhere in the first conversation it comes up, politely or not: "Can't we just do this with AI?" It is a fair question. In 2026 a founder can describe a web app to a tool, watch it appear in an afternoon and deploy it before dinner. Simple websites, dashboards, internal tools, even a shop with a checkout: all of it can be produced without a developer in the room. So why pay an experienced one, and why pay the rates that experience commands?
This article is my honest answer. It is not an argument against AI. I use AI every working day and I will show you exactly where, because that is part of why my packages cost what they cost and not more. It is an argument about responsibility. AI has changed who writes the code. It has not changed who answers for it when it is wrong. The companies that understand that distinction are the ones that will still have a working product, a clean audit trail and valid insurance in two years, and I will quote the research and the incident reports rather than ask you to take my word for it.
Why the demo is not the product
"Vibe coding" describes building software by prompting an AI in plain language, accepting what it produces, running it and prompting again, without really reading the code. Andrej Karpathy coined the phrase in February 2025, and by November Collins had made it the Word of the Year1. It is enormously productive for prototypes. The problem is that a prototype and a product look identical on a screen.
A working demo proves that the happy path works once, on the author's machine, with the author's data, with the author logged in as an administrator. A product has to work for the thousandth user on a slow phone with a half finished session, under a payment provider's retry, after a dependency update, with a hostile visitor probing every parameter, on the day the one person who understood it is on holiday. The gap between those two states is the whole discipline of software engineering, and it is precisely the part that AI, left alone, does not do, because nobody asked it to and the demo already looked finished.
I call this the 90% trap. AI gets you to 90% in a day. The remaining 10% (integrations with real payment providers and tax rules, legacy data, edge cases, performance under load, security, compliance evidence) is where the real work sits, and it is where many AI built projects quietly stall. The founder is left with something that almost works, nobody who can finish it, and a bill for starting again.
What the research measured
None of this is my opinion alone. Over the past eighteen months the security industry has measured AI generated code at scale, and the direction is consistent.
Veracode tested more than 100 large language models on 80 coding tasks and found that 45% of the generated code samples introduced a vulnerability from the OWASP Top 10, the standard list of the most common web application flaws. In Java the failure rate was above 70%, and the models failed to defend against cross site scripting in 86% of the relevant cases2. A study published on the Cloud Security Alliance's site found that 62% of AI generated code solutions contained design flaws or known security vulnerabilities, even with the latest models3.
Those are laboratory tests. Escape, a security firm, looked at real applications: more than 5,600 publicly reachable apps built on vibe coding platforms such as Lovable, Bolt and Base44. From the outside alone, without breaking in, it found more than 2,000 high impact vulnerabilities, over 400 exposed secrets (API keys, database credentials, tokens) and 175 cases of exposed personal data, including medical records and bank account numbers4.
Then there are packages that do not exist. Researchers presenting at the 2025 USENIX Security Symposium generated 576,000 code samples with 16 models and found that, on average, at least 5.2% of the packages suggested by commercial models and 21.7% of those suggested by open source models were invented: 205,474 unique fake names5. Attackers can register those plausible names on the public registries and fill them with malware, a technique now called slopsquatting. A developer who reads the dependency list is the defence. A tool that installs whatever it is told is not.
In March 2026 the UK's National Cyber Security Centre wrote that vibe coding carries "risks that are likely far outside most organisations' risk tolerances", even while it expects AI written code nobody has reviewed to become more common6. The OECD's AI incident monitor filed the warning as an AI hazard7. Gartner, meanwhile, estimates that 40% of new enterprise production software will be created with vibe coding techniques and tools by 20288. Both things are true at once: the method is here to stay, and it is dangerous without supervision.
Several of these sources are security vendors with an interest in the subject, so read the originals in the footnotes rather than the summaries. The direction of every number is the same.
The nine dangers, in the order they get expensive
The first dangers are loud and discussed everywhere. The later ones are quieter and cost more.
One: security you cannot see
The classic flaws are back because the models learned from a decade of code that had them: SQL built by string concatenation, user input rendered without escaping, authorisation checks that exist on the button but not on the endpoint, file uploads that accept anything, session tokens that never expire, administrative routes protected only by obscurity. Each of these is invisible in a demo and catastrophic in production.
Then there are secrets. Generated code tends to put the API key where it is convenient, and convenient is usually the browser. The 400 exposed secrets in Escape's scan were not exotic failures. They were the default behaviour of tools optimising for "it works" rather than "it is safe".
An experienced developer does not write secure code by being clever. They write it by habit and by checklist: parameterised queries, output encoding, authorisation on every request on the server, secrets in a vault, least privilege everywhere, dependencies pinned and reviewed, and a threat model written down before the feature is built. AI is good at helping with the threat model, if someone asks.
Two: the agent with the keys
In July 2025, during a public experiment, an AI coding agent on the Replit platform reportedly deleted a company's live production database in the middle of a declared code freeze, then gave misleading answers about what it had done and whether the data could be restored9. The details are specific to that platform. The lesson is general: an agent with write access to production is a new hire with root access and no fear. Nobody sensible gives a new hire the production credentials in week one, and yet many vibe coding setups do exactly that by default.
Experienced engineering separates environments, gives every actor the minimum permissions required, keeps production changes behind a release process, and keeps backups that are tested by actually restoring them. None of this is glamorous. All of it is the difference between an incident and the end of the business.
Three: the critical path that changes by accident
This is the danger I consider the most important, and the one companies rarely name until it has happened to them. Every business runs on a handful of paths that must work: the checkout, the login, the quote, the invoice, the onboarding form, the data export the accountant needs. Everything else is decoration.
Software changes constantly. Every feature, every dependency update, every "small fix" touches code that other code depends on. Without a test suite that encodes how the critical paths are supposed to behave, there is no way to know whether today's change broke yesterday's promise. Vibe coded systems rarely have that suite, because tests are the first thing a tool skips when nobody asks for them, and the tool's own confidence is not evidence.
This is where test driven and behaviour driven development earn their keep, and it is why I put them at the centre of how I work (the TDD and BDD guide shows the method in detail). In behaviour driven development the critical paths are written down first, in plain language a client can read: "Given a customer with items in the basket, when they pay with a valid card, then the order is confirmed and the stock is reduced." Those sentences become automated tests. The tests run on every change. A release that breaks a promise does not ship. The surprise is caught at my desk, not at your customer's.
I go one step further in the client hub: the critical paths are verified and frozen behind an approval. Changing one of those behaviours is a deliberate, recorded decision, never a side effect of something else.
Four: architecture and the data model
The decisions that cost the least to make are the ones that cost the most to change. How the data is structured, how money is represented, how state moves through the system, how a second tenant or a second country will be handled. All of these are free on day one. Each of them is a rewrite at month twelve.
AI optimises for the prompt in front of it. Take an example. Fern and Frond, an invented Bristol plant shop at fernandfrond.example, asks a tool for a shop. It gets one that works for one currency, one VAT rule and one warehouse, with prices stored as floating point numbers. In floating point, 0.1 + 0.2 is 0.30000000000000004, so across thousands of orders the shop's totals will one day disagree with the accountant by a penny, and nobody will know which order caused it. Money belongs in integer pence or a decimal type, decided before the first order is stored. Ask the same tool for a SaaS and it will often produce a single tenant application with the customer identifier bolted on afterwards, which is among the most expensive mistakes in that category of software.
An experienced developer has made these mistakes already, on somebody else's project, and asks about the second country before writing the first line. That question is where a large part of the rate goes, and it is the best money in the budget.
Five: nobody understands the system
Code that nobody on the team can explain cannot be changed safely, cannot be audited, cannot be handed over and cannot be insured with a straight face. Vibe coded systems produce exactly this: thousands of lines that appeared in an afternoon, structured however the model felt that day, with no record of why.
The result is maintainability debt. It is not visible in the demo and it does not appear on an invoice, but every future change costs more, every new developer takes longer to become useful, and eventually the rational choice is to throw the whole thing away. The free afternoon turns out to be the most expensive hour the company ever bought.
What experience adds is structure and story: conventions a future developer will recognise, documentation that explains decisions rather than restating the code, tests that double as a specification, and a handover that assumes I will not be there forever. "Documented, tested, yours" is a design constraint for me, not a slogan.
Six: compliance keeps arriving
Regulation does not care who wrote the code. UK GDPR and the Data Protection Act 2018 require you to know what personal data you hold, why and for how long, and to be able to prove it10. PECR decides whether you may send that marketing email or set that cookie at all11. The Data (Use and Access) Act 2025 amended both, and since 30 September 2026 the regulator is the Information Commission, formerly the ICO12.
If you sell to consumers in the EU, more applies. The European Accessibility Act has covered ecommerce and many other digital services since 28 June 202513 (the accessibility requirements article covers what that means in practice). The EU Cyber Resilience Act's duty to report actively exploited vulnerabilities and severe incidents in products with digital elements has applied since 11 September 2026, and its main security obligations follow on 11 December 202714 15. NIS2 adds security and reporting duties for medium and large organisations in the sectors it lists16.
Every one of these frameworks asks the same three questions: what did you build, how do you know it is safe, and who is responsible. A vibe coded system answers none of them. An experienced developer builds the evidence as part of the work: a data map, consent that is enforced in the code and not only in the banner, accessibility built into the components rather than bolted on by a plugin, a release register, an audit log. When the regulator or the client's lawyer asks, the answer is a link, not a scramble.
Seven: insurance and liability
This one is new, and it is moving fast. In the US, Verisk's ISO made three optional generative AI exclusion endorsements available for commercial general liability policies in January 2026. By mid 2026 a review of state filings counted 2,369 generative AI exclusion records in force, large carriers had filed to use them, and at least one carrier had added an absolute AI exclusion across its directors and officers, errors and omissions and fiduciary products17. Legal commentary goes further: an insurer facing a claim may argue that a professional who relied on unverified AI output, with no supervision or oversight, never rendered a "professional service" within the policy at all18.
Those are American forms, and UK wordings differ, so read your own policy and ask your broker. The direction is clear enough to plan for. After an incident, the insurer's questions are predictable: who signed off this release, where are the tests, what changed and when, who had access to production, where is the security review. If every answer is "the AI did it", the policy may not respond, and the directors are exposed in a way they never were when a named engineer stood behind the work.
I am a named person with a contract, a documented process and an audit trail. That is what makes the work insurable, for you and for me. In the age of AI, "who is accountable" has become a balance sheet question.
Eight: ownership, licences and lock in
Many vibe coding platforms host the application themselves, store the data in their systems and charge by usage. The code may be exportable in theory and hard to run anywhere else in practice. Usage costs that looked trivial in the demo grow with every user. If the platform changes its pricing, its terms or its mind, the business goes with it.
There is also provenance. Models trained on public code can reproduce fragments under licences that carry obligations you did not plan for. For a company that may one day sell, raise money or be audited, unclear ownership of its core asset is a due diligence problem waiting to happen.
What I build runs on standard, open technology, in infrastructure you control, with the code in your repository. Bespoke code becomes yours on full payment, dependencies are reviewed and their licences known. For analytics and data science work, your raw data stays yours, and the terms for code and models are in the analytics and data science terms.
Nine: measurement that lies, and building the wrong thing
Two quieter dangers. First, analytics and tracking are among the easiest things to get confidently wrong: events that fire twice, conversions that count test orders, consent that a server side pipeline ignores, attribution that credits the wrong channel. A business then makes decisions on numbers that are precise and false. Getting measurement right is slow, careful work that needs someone who understands both the law and the plumbing.
Second, AI will build anything, including the wrong thing, with equal enthusiasm. The scarcest skill in software today is not writing code. It is deciding what not to write. An experienced developer will push back, ask what the business is actually trying to change, and often save more money by saying no than by saying yes. That conversation is why I start every engagement with a workshop rather than a quote.
What "experienced" means in 2026
The word has changed. Ten years ago an experienced developer was someone who could write a lot of correct code quickly. Today the model writes the code quickly, and experience shows up elsewhere.
It shows up as judgment about risk: knowing which part of a system can be generated and glanced at, and which part must be designed, read line by line and tested before it is trusted. It shows up as critical reading: the model produces plausible code, and only a reader with scar tissue notices the missing authorisation check, the race condition, the index that is not there, the decimal that should not be a float. It shows up as threat modelling, asking before the feature exists how a hostile user, a careless user and a broken dependency will each misuse it.
It also shows up as data correctness (understanding money, time zones, tax, inventory and identity well enough to know when the clean looking answer is wrong), as scope and sequence (what to build first, what to leave out of the first release, what to defer until the data justifies it), as integration with reality (payment providers, accounting systems, legacy databases, carriers and marketplaces do not take prompts) and as writing it down: tests as specification, decisions as records, handover as a deliverable.
None of these are things the model does on its own. All of them are things the model makes faster when a person who has them is in charge.
How I use AI, and why that lowers your price
I would be a hypocrite to warn about AI and then pretend I write every line by hand. I do not. I use it constantly, under one rule: the lower the blast radius of a mistake, the more AI builds alone. The higher it is, the more AI advises while I decide. In practice that gives three tiers.
Low risk: AI builds, I glance. The visual layer: HTML and styling, responsive layouts, dark mode, email templates, PDF layouts. A wrong result is visible instantly and harms nothing. Form scaffolding, client side validation, error states, country and phone widgets, second language strings. Boilerplate models, controllers and views away from the critical path. Seed and fixture data, realistic demo content, anonymised test datasets. One off scripts, import and export jobs, API clients for third parties, deployment recipes. Documentation drafts and the runbook that otherwise never gets written. This tier used to consume a large share of every project's hours. Now it consumes a fraction, and that saving is in my package prices rather than in my margin.
Medium risk: AI drafts, I edit. Test authoring: I give the model the acceptance criteria and ask for the edge cases, the contradictions, the requirements nobody mentioned and the things a hostile user would try. It is good at this, and it makes the test suite broader than any one person's imagination. Code review as a second reader: before I review a change, the model reads the diff and flags the unchecked nil, the N+1 query, the missing index, the forgotten permission check. Refactoring under a green test suite. Release notes written from the tests that were added, which keeps them honest, because a behaviour that was not tested does not appear in the notes. Log triage, query plans and caching strategies, all verified on real data. Dependency and secret scanning.
High risk: I decide, AI advises. Architecture, the data model, money and tax logic, state machines, authentication and authorisation, payments, and every verified critical path. Here the model is a sparring partner: what breaks if, what did I forget, how would you attack this. It never commits alone, and its suggestions go through the same tests and the same review as mine.
What this means for a client is concrete. The non critical bulk of a first release ships in days rather than weeks. Test coverage goes up, not down, because writing tests now takes a fraction of the time. Documentation exists because producing it is no longer a chore. One accountable person with these tools does what used to need a small team, and you do not pay for the coordination overhead, the handovers or the junior layer. The rate per hour is that of an experienced engineer. The number of hours is that of a team with AI. The total is lower than either alternative, and the result is something an insurer, an auditor and your next developer can all read.
What you get in writing
Promises cost nothing, so here is what exists as evidence rather than as copy:
- Tests you can read. The client hub shows the automated test runs for your project, the behaviour specifications in plain language, and which critical paths are verified and frozen behind approval.
- A release register. What shipped, when, what changed, which tests covered it, who approved it. The document an insurer or auditor asks for first.
- An audit log and a decisions log. Every significant action and every significant choice, with its reasoning, recorded at the time.
- Documents and contracts in one place, including the clause that says what you own and when.
- A named person on the contract, with a process behind the name.
- The workshop before the contract, where we decide what should be built at all.
Twelve questions to ask anyone who builds your software
Whether you talk to me, an agency or a tool, these questions separate a product from a demo. Any honest professional will welcome them.
- Which parts of this system will be generated, which will be designed by a person, and how do you decide?
- Where are the automated tests, and can I read the ones for my critical paths in plain language?
- What happens when a change breaks a critical path? Show me the process, not the intention.
- Who has access to production, and how are secrets stored?
- How are dependencies chosen and reviewed, and who checks that every package exists and is what it claims to be?
- Where does my data live, who owns the code, and can I take everything and leave?
- How will this handle a second currency, a second country, a second tenant? If the answer is "later", ask what later costs.
- What is your evidence for compliance: data map, consent enforcement, accessibility, release records?
- Who signs off a release, and what would your insurer see if they asked?
- What will the running costs be at ten times today's usage?
- What will you refuse to build, and why?
- If you disappeared tomorrow, how long would it take another developer to be productive in this codebase?
If the answers are vague, the risk is not theoretical. If the answers are links to real artefacts, you are probably talking to the right person.
The honest conclusion
AI has made software abundant. It has not made responsibility abundant. The code is now the easy part. The judgment about what to build, the discipline to prove it works, the architecture that survives growth, the evidence that satisfies a regulator and an insurer, and a named person who answers for all of it are scarcer than ever, precisely because the tools make it so tempting to skip them.
That is what you pay for when you work with an experienced developer who uses AI properly: not the typing, which costs little now, but the accountability, which never did. And because the typing costs little now, you pay less for the whole than you would have three years ago. Lower cost and higher certainty is the actual offer, and it is why the question "can't we just do this with AI?" has a better answer than yes or no: yes, with someone whose name is on it.