There are two very different ways a developer learns to spot security flaws, and they are easy to confuse. One is running a tool that flags known problems across your dependencies. The other is understanding why a flaw exists in the first place. A tool such as an osv-scanner vulnerability scanner, covered in CodeRed’s intermediate course on Google’s OSV-Scanner, represents the first path, and it is genuinely useful. But it is only half of the skill.
The reason both halves matter shows up in the numbers. Black Duck’s 2025 Open Source Security and Risk Analysis report found the average application pulls in 911 open source components, and that 64% of them are transitive dependencies the developer never chose directly. No human reviews that by hand, which is exactly why scanning exists, and also why understanding has to come from somewhere else.
What Does an Automated Scanner Actually Teach You?
A dependency scanner teaches breadth and consistency. It checks every package in a project against a database of known vulnerabilities and flags matches far faster than any human review could. The CodeRed OSV-Scanner course describes exactly this: scanning open source dependencies, reading SBOMs, and wiring the check into a CI/CD pipeline.
What it teaches is a workflow habit, not the anatomy of a flaw. The scanner tells you that a component is vulnerable and which advisory applies. It does not teach you what the underlying weakness does or how an attacker would reach it. That second kind of knowledge has to be built deliberately, because a database can only recognize what someone has already catalogued.
What Does a Practice App Like Google Gruyere Teach Instead?
Google Gruyere comes at the problem from the opposite direction. It is a deliberately broken web application, built by Google, that lets learners study flaws like cross-site scripting and data exposure in a safe, isolated setting. The CodeRed lab on it is described as an advanced, hands-on exercise in identifying these weaknesses and then developing mitigation and secure coding strategies.
The value here is depth. Working through google gruyere in an authorized lab, a developer sees why a flaw exists in application logic, not just that a package version is flagged. That understanding is what lets someone recognize a brand new weakness no database has caught yet, because they grasp the pattern rather than the signature.
Where Do the Two Approaches Overlap?
Both aim at the same outcome: fewer exploitable weaknesses shipped to production. Both also reward the same mindset, a willingness to look for problems before an attacker does rather than after. In that sense they are two routes up the same hill.
They also feed each other. A scanner finding becomes far more useful to a developer who understands the class of flaw it points at, and lab practice becomes more grounded once a learner has seen how often these issues show up in real dependency reports. The overlap is the mindset. The difference is where each one points your attention.
Where Do They Diverge Most Sharply?
The sharpest divergence is coverage versus comprehension. A scanner covers everything shallowly and instantly, flagging every known issue across a huge dependency tree. A practice app covers one thing deeply and slowly, building intuition for a single class of flaw at a time.
They also differ in what they miss. A scanner is blind to a novel flaw no advisory describes, and to logic bugs in code your own team wrote. Practice against an app like Gruyere is blind to the sheer scale of those 911 components, where hundreds of third party packages hide risk no single person could review by hand. Each approach’s strength is precisely the other’s blind spot.
Which One Should a Developer Learn First?
For most working developers, the scanner comes first because it plugs into daily work immediately and produces value on day one. It raises the floor of your security posture without asking you to become a specialist. That early, visible payoff is worth a lot when you are busy shipping.
Made-up example: a backend developer runs a scan and sees a flagged serialization library. The scanner tells her it is vulnerable, but having never studied that flaw class, she bumps the version and moves on. A teammate who practiced the same category in a lab recognizes the pattern elsewhere in their own code, where no scanner was ever going to flag it. Same report, two very different outcomes, decided entirely by depth.
Building Both Halves on Purpose
The mistake is treating either half as the whole. A team that only scans becomes dependent on a database to think for it, and a learner who only studies flaws in isolation underestimates how risk scales across real projects. Neither is wrong, but neither alone is complete.
The developers who age best in security careers keep both muscles working. They let tools handle breadth so their attention is free for depth, and they keep practicing on safe, broken-by-design targets so their judgment stays sharp. Coverage and comprehension are not a choice between two camps. They are two skills worth building side by side, and the gap between a team that gets this and one that does not only widens as dependency trees keep growing.
















