← Blog

Developers don’t need thirty OWASP Top 10s

Three fact cards: broad permissions appear on six OWASP lists under six names, prompt injection has three names across the AI lists, and IDOR from 2007 is still in the 2025 Top 10.

OWASP now has close to thirty Top 10 lists, and an AI feature can be in scope for several of them. A reflection for fellow security people on what that looks like from the developer’s chair.

This is a reflection for fellow security people. I’m not here to point fingers at anyone, but I do want to question whether more and more lists is a viable way forward for the developers we’re trying to help.

Every time a new OWASP Top 10 comes out, the same thing tends to happen. It gets shared on LinkedIn within days, vendors map their products to it, and at some point it ends up in an email to the engineering team with a short note saying “please review”.

I know this pattern quite well, because I’ve been part of it myself, on security teams, as a consultant, and now as a vendor. So I’d like to look at what it actually looks like from the other side, from the developer’s chair.

An AI feature in a normal web app can fall under five or six OWASP Top 10s at once, and those lists overlap heavily. The developer needs the few risks that apply to the change in front of them, in plain words and with the basics first. For a new endpoint that returns user data, that might be two lines: check that the user owns the record, and keep the record out of the logs. Getting from thirty lists to those two lines is work for us security people.

Which OWASP Top 10 applies to an AI feature?

Usually several, and the one that matters most may not be among them. Let’s say a team is adding an AI assistant to their product this sprint. On Monday someone from security forwards the OWASP GenAI LLM Top 10. On Wednesday it’s the Top 10 for Agentic Applications, and on Friday the MCP Top 10. That’s thirty items, with names like “intent flow subversion”, “excessive agency” and “confused deputy”, and the team still has a feature to ship.

What might easily get lost in all of that is something much more basic. The assistant the team is building needs an endpoint that returns a user’s past conversations. It checks that the user is logged in, but it doesn’t check that the conversation actually belongs to that user. So anyone who changes the ID in the URL can read other customers’ chats.

There’s no AI attack involved here at all. It’s a classic IDOR (insecure direct object reference), and it was item 4 on the OWASP Top 10 already back in 2007. It’s still there in the 2025 edition, under A01 Broken Access Control. The AI lists don’t cover a plain API endpoint like this one, and that’s by design, since they’re meant to cover what’s new. But it does mean that the bug most likely to hurt this team is the one nobody forwarded.

How many OWASP Top 10 lists are there?

Close to thirty, but first I want to be clear about OWASP itself. OWASP is a great initiative in many regards, and I especially appreciate the volunteers behind it, who spend their evenings and weekends writing down what they’ve learned, for free, for anyone to use. The OWASP Top 10 has probably done more to teach developers about security than any course, standard or product out there.

OWASP is also quite honest about what the lists are for. In its own words, they are “awareness documents” and “not meant to be a complete list, only a starting place.” So the intention here is not to say that OWASP is doing something wrong. Each list makes a lot of sense on its own. My question is what happens when all of them land on the same developer.

Counting the Top 10 projects in OWASP’s GitHub organization, there are now around thirty, covering web apps, APIs, mobile, LLM applications, AI agents, MCP, agent skills, CI/CD pipelines, Docker, Kubernetes, serverless, machine identities, smart contracts and so forth, some mature and some still early drafts. On top of that, many companies have their own security guidelines, which usually link out to a few of them.

When you build an AI solution, several of these lists could be relevant, depending on the context, the use case, your existing architecture and the technology platform you’re on. An AI feature in a normal web app could easily be in scope for five or six of them.

Do the LLM, Agentic and MCP Top 10s overlap?

Yes, quite a lot. Each list is written for its own technology, so each one covers the basics again in its own words. Prompt injection is item 1 on the LLM list. On the agentic list it’s the usual way into item 1, agent goal hijack, and on the MCP list it’s item 6, under the name “intent flow subversion”. Too-broad permissions show up on at least six lists, under six different names. The MCP Top 10, still in beta, is the latest one I’ve read, and it overlaps significantly with the LLM Top 10, the Agentic Applications Top 10 and the classic OWASP Top 10.

The risk, in plain wordsLLM (2026)Agentic (2026)MCP (2025, beta)Elsewhere
The AI follows instructions hidden in something it readsLLM01 Prompt InjectionASI01 Agent Goal HijackMCP06 Intent Flow SubversionNot a separate item
A token or agent can do more than its task needsLLM03 Excessive AgencyASI03 Identity & Privilege AbuseMCP02 Privilege Escalation via Scope CreepKubernetes K02, Non-Human Identities NHI5, CI/CD CICD-SEC-2
A secret sits where it can leakLLM08 Hidden Context ExposureNot a separate itemMCP01 Token Mismanagement & Secret ExposureKubernetes K03, Non-Human Identities NHI2 and NHI7, CI/CD CICD-SEC-6

The lists also move, and sometimes change names. In August, the OWASP Top 10 for LLM Applications was succeeded by the OWASP GenAI LLM Top 10 2026, and for the first time the order was tested against a corpus of 7,714 real-world incidents. Excessive agency climbed from item 6 to item 3, and system prompt leakage became hidden context exposure. Checking the vote against real incidents is a good idea. But OWASP’s own LLM Top 10 page still shows the 2025 list, the old project page now calls itself a “legacy entry point”, and the first draft of this post used the old numbering without anyone noticing. If that confuses people who follow these lists for a living, I don’t think we can expect developers to keep up.

So when the lists reach developers as they are, developers end up doing work that I don’t think should be theirs. They have to figure out which lists apply to their context, remove the duplicates, and translate all of it into actual code changes. If they don’t read them all, I don’t think it’s because they’re lazy. I think we’re simply asking too much.

Does AI make the classic OWASP Top 10 risks worse?

I think it does. What worries me most is that while the new lists pull our attention toward new AI risks, AI is at the same time making the old risks more dangerous. I see three things happening.

Attackers are using AI to find old bugs faster. In November 2025, Anthropic reported disrupting a cyber-espionage campaign where AI carried out an estimated 80-90% of the tactical operations. The attackers didn’t need any new techniques, and according to the full report the operation “relied overwhelmingly on open source penetration testing tools rather than custom malware development.” So, standard tools, just run at machine speed.

AI also writes code fast, including the bugs. Veracode tested code from more than 100 AI models, and 45% of the code samples failed security tests. Newer and larger models didn’t do any better, and security performance stayed flat regardless of model size.

And AI features get hacked through old mistakes. Aikido’s PromptPwnd research showed how attackers could put instructions into GitHub issues and pull requests that AI tools in CI pipelines then read. What made it dangerous was something we’ve seen many times before: the workflows gave those AI tools secrets and a GitHub token with write access. I wrote about the same pattern in how an AI agent in CI turns a public issue into an unauthenticated input.

Put that together and we have more code, written faster and attacked faster, with the same basic weaknesses as before. I don’t think basic security has ever mattered more than it does now.

Why should findings be written in the developer’s language?

Because a finding only gets fixed if the person reading it understands it. “Least agency”, “confused deputy”, “intent flow subversion” and so on are useful terms when we security people talk to each other, but I think it’s a mistake when we pass them on to developers unchanged.

A developer doesn’t need any of those terms to write safe code. What they need to hear is something like “check that this user owns this record before you return it”, or “this token can delete repositories, but it only needs to read them”.

If good security practice only reaches the people who already speak security, it doesn’t make it into the code.

And it’s not only about security lingo, or about English for that matter. If a developer is more comfortable in Swedish, German, Spanish, Italian or Japanese, I think they should be able to get the finding in their own language. Everything that makes a finding easier to understand increases the likelihood that it actually gets fixed.

This matters even more for business logic flaws. Whether a refund can be issued twice, or a discount can be stacked, depends on what the business intended, and that intent lives in people’s minds. Most people think about their business in their native language, so a finding that meets them there is much more likely to click.

I think it’s especially important for citizen builders, the domain experts who now build their own apps with AI tools. They know the business logic better than anyone, they often build in their own language, and there’s no security team behind them to translate the finding for them.

What should security teams send developers instead of a list?

A short list for the change they’re working on, written in their terms. That’s a bigger shift than it sounds, because of who the lists have really been for.

On paper, OWASP describes the Top 10 as “a standard awareness document for developers and web application security”. In practice, the people who read the lists closely are AppSec people, and translating between OWASP and the changes inside the organization has been our method for as long as I’ve worked in this field. We read the list, turn it into internal guidelines and training, and push those out to the teams.

What AppSec can promise is changing enormously right now. With AI writing more of the code, and domain experts building their own apps, there are far more changes than a security team can sit in the middle of and translate.

What should be expected of us now is a language aimed directly at the people building, in terms of the change they’re making.

I spent many years promoting threat modeling in large software organizations, and if you strip away the workshops and the acronyms, it comes down to one question: what could go wrong with this particular change, and what should we do about it?

The answer to that is also a top list, just not a fixed one. A change to a button label might have a Top 0. A new login flow might have a Top 9. A new endpoint returning user data might have a Top 2: check that the user owns the record, and don’t put the record in the logs.

And I think that list should be written for the code that’s actually changing, in the tech stack the team actually uses, with the company’s own rules already included. Working out which of thirty lists apply, and checking them against an internal policy page, should be our job, not the developer’s. The big lists still matter, of course. They’re how we know what to look for. But I think they should sit behind the list the developer sees, not in front of it.

This goes for all of us, whether we sell security tools or work on a security team. Here is what I think could work better.

  • Translate before we forward. If a new list matters for a team, read it first and tell them the one or two things that actually apply to what they’re building.
  • Ask for one thing at a time, and explain why in a sentence, like “add an ownership check here, otherwise anyone can read any conversation”. That’s usually enough.
  • Keep the mapping on our side. Mapping findings to OWASP categories is useful for audits and reports, but that’s work for us, not a checklist to hand over to developers.
  • Put the basics first. Access checks, keeping secrets out of code and logs, narrow and short-lived tokens, up-to-date dependencies. It’s not very exciting, but it’s where most of the damage starts, and AI is making it worse.

What are the five basics that apply to almost every change?

Yes, I see the irony in adding a list of my own. But if I could only pass on five things to a development team, instead of the next list, it would be these, since they apply to almost every change.

  1. Check ownership, not just login. Every time you return or change a record, ask whether this user has the right to this specific one.
  2. Give every token the least access it needs. That includes the tokens your AI tools and pipelines use.
  3. Treat anything the AI reads as untrusted. Documents, issues, web pages and tool output can all contain instructions. Limit which tools the AI can use, and what it can do if it follows them.
  4. Keep secrets out of code, logs and prompts.
  5. Look at each change before it ships. That doesn’t have to mean reading the code line by line. It’s more about understanding what the change actually consists of, its scope and impact, what can go wrong and what could be done about it, and once it’s done, whether it actually solved the problem. Tools like Oplane can give you that as an augmented view of the change, so you don’t have to work it out from the diff. With AI writing more of the code, a yearly pentest or review covers less and less of it anyway.

So is more lists the way forward?

Not on their own. The lists were never the problem. OWASP calls them a starting place, and that’s exactly what they are.

A developer facing thirty starting places isn’t going to read thirty. Most likely they’ll read none, and the most common bugs will stay.

So I’m not asking OWASP to stop writing lists, or anyone to stop doing what they’re doing. I’m questioning whether handing all of them to developers is the way forward. I’d like us to talk about what developers actually need to make real security improvements, in greenfield development of completely new AI systems and just as much in teams adopting AI coding to change legacy software.

To give a simple example of what I mean. Instead of a finding that just says “email header injection”, wouldn’t it be great if every security finding could answer the question “why is this important?” Something like: “A malicious actor could send emails that actually come from your product or company. That might affect how your company is perceived, and whether your customers keep trusting you.” That’s something a developer, and a product owner for that matter, understands right away.

That’s in a nutshell what Oplane is built to do. For each change, whether it’s a pull request or a design, it gives you an augmented view of what the change actually consists of, covering its scope and impact, what can go wrong and what could be done about it, in terms of that code, its architecture and your organization’s own rules. And once the fix is in, it checks whether it actually solved the problem, which is the idea behind giving every step a definition of done. The OWASP mapping is there for those who need it, and the developer just sees what to do.

I’d really like to hear how others see this, especially if you’re the one forwarding the lists, or the one receiving them.

See the short list for your own change

Oplane reads each pull request or design and tells the developer what could go wrong with that change and what to do about it, in plain words, with the OWASP mapping kept on the side.

We value your privacy

We use cookies to make the site work better for you and to analyze traffic. You can accept all cookies, customize your settings, or reject non-essential cookies.