How Quickly Can You Trace Vulnerable Code Across Public Services?

In benchmark testing, OpenAI’s latest model, GPT -6 Astra, was able to find unknown zero-day vulnerabilities and exploit them in real-time. Although this capability is being sandboxed and restricted for now, this finding should worry everyone, especially those responsible for public services. 

The security threat landscape is moving to a mass risk of zero-days, yet the public sector still struggles to respond to known vulnerabilities, especially third-party flaws that take an average of 358 days to fix.

To see where the response can stall, let’s follow a vulnerability alert through a public service and examine what it takes to get the affected code fixed. 

How fast is fast enough?

Imagine a council security team receiving an alert about a flaw in software used to process uploaded documents. A scan finds the affected component in several projects, including one that appears to support the housing repairs portal.

The service director wants to know whether residents can keep using it. The team needs to check which version is running and whether the upload function exposes the flaw. An external supplier maintains the application.

The scan has taken minutes. Answering the director could occupy much of the morning.

In Veracode’s 2026 State of Software Security research, third-party flaws took an average of 358 days to fix and accounted for 66% of critical security debt in its dataset.

Public-service leaders can examine the delay within their own organisations, starting with the work required to turn a component finding into an agreed plan for the affected service.

Graphic showing statistics on third-party software flaws: '358 days' as the average time to fix these issues, alongside '66%' indicating the percentage of critical security debt from third-party components.

The search needs to reach below the application

A service register might identify the repairs portal and its supplier. It is unlikely to tell the security team which open-source library handles a resident’s uploaded photograph.

That detail belongs in the software’s component inventory. A software bill of materials, or SBOM, records the components in a build, including their versions. For this investigation, the inventory must cover dependencies brought in by other packages, known as transitive dependencies.

The distinction matters when the development team says it has never selected the affected library. Another component may have introduced it.

Search results should show that dependency path. It helps the engineer determine which package needs updating, especially when the vulnerable library cannot be changed independently.

Then check the inventory’s scope and date. Confirm that supplier-managed software is included in the search. If it is excluded, the team needs evidence from the supplier before ruling the service out.

Graphic depicting an iceberg with 'What's Beneath Your Public Service?' text. The top shows 'Public Service', followed by 'Application', and at the bottom, 'Vulnerable Dependency' indicated with an exclamation mark.

Follow the finding all the way to production

Suppose the supplier confirms that the library appears in the portal’s codebase. Its latest development build already contains a corrected version.

The council still needs to establish what residents are using today.

Link the component finding to a specific build, then check where that build was deployed. The evidence should identify the live service and any running instances that still contain the affected version.

This connection takes preparation. Repository names rarely explain a service’s purpose to someone outside its delivery team. Maintain the relationship between each project and the service it supports as part of normal delivery. Changes of supplier or platform are good moments to check that the record still holds.

Once the team locates the affected release, it can assess exposure. Some vulnerabilities require particular settings or a reachable function before an attacker can exploit them. Record the relevant configuration and the reasoning behind the assessment.

That gives the service director something useful to act on. If the upload function is exposed, restricting it may be appropriate while a fix is prepared. The decision must account for how residents will submit repair requests during that restriction.

“We’re investigating” needs a next step

A supplier’s acknowledgment can arrive quickly while useful answers take longer.

In our scenario, the council needs a response tied to its deployed release. The supplier should explain whether that release is affected and identify the proposed remedy. Agree when the next substantive update will arrive.

Inside the council, assign someone to coordinate the remediation. That person needs a working technical contact at the supplier and a route for escalating delays. The accountable service owner must also be available to approve operational decisions.

Ownership should be established before the alert arrives. Test the escalation route during routine supplier reviews. A contract reference is little help if the named contact has moved on or cannot reach the engineers responsible.

Where several public services share the same component, assess their exposure individually. Prioritisation should reflect evidence of exploitation and the consequences for each service. A common package does not mean every deployment needs the same response.

The fix has to survive contact with the service

A suggested replacement version gives engineers a starting point. It still needs testing against the application.

An upgrade can change behaviour elsewhere in the dependency chain. For the repairs portal, regression testing should include the document-upload workflow residents rely on. The team also needs a recovery plan if deployment causes problems.

Keep the finding open until the evidence shows that the corrected build has reached the affected instances. Recheck the deployed software and retain the result with the remediation record.

If an update must wait, document the reason and set a review date. Any temporary restriction needs someone responsible for checking that it remains effective. Otherwise, the next person handling the service inherits an unresolved decision with little explanation.

Find out where your own morning goes

Choose one important service and rehearse this investigation using a component it actually contains. Time how long the team takes to produce:

  • A deployment record: the affected version linked to the live service.
  • An exposure decision: the evidence supporting the assessment.
  • A named lead: someone able to coordinate remediation and escalate delays.
  • A tested route to closure: the proposed update and the checks required after deployment.
Infographic outlining the steps to getting a fix live: 1. Locate the affected service, 2. Assess if the flaw is exploitable, 3. Assign responsibility for the fix, 4. Verify if the fix is live and working.

Record where the investigation stalls. Waiting for supplier evidence requires a different remedy from finding an ownerless repository. Repeat the exercise once the team has addressed the delay.

Meterian can support the component investigation by identifying dependencies across projects and monitoring published vulnerabilities. Its reports provide remediation guidance, with integration into existing delivery pipelines. Teams can connect those findings to their service records to complete the investigation.

We’ll be discussing that work at DigiGov Expo, 23–24 September 2026, at ExCeL London. Meet Meterian to explore how quickly your team could trace an affected component through to a public service and put someone in charge of the fix.

How Quickly Can You Trace Vulnerable Code Across Public Services?

How Public Sector Developers Can Secure AI-Generated Code

AI coding assistants are moving into public sector software teams. The UK government now provides guidance for using AI coding assistants, while departments are testing how the tools can support development and legacy modernisation.

As tech stacks are changing extremely fast, public systems must be ready for a wartime pace, supporting transparent component logging, strong authentication, and continuous vulnerability management processes to avoid an unexpected standstill.

The productivity gain comes with a clear condition. AI-generated code still needs the same security controls, testing and review as code written by a developer. This is especially important in government systems that handle citizen data, public services and ageing infrastructure.

ai coding risk public sectors

As Meterian explored in its article on the AI acceleration trap, faster delivery can create more risk when component integrity is overlooked. Here are five practical ways public sector teams can use AI coding tools safely. 

1. Treat AI-generated code as untrusted

As developers increasingly rely on AI coding assistants, teams are facing a surge in “AI-generated technical debt.” This can originate from in-house developers or contractor contributions.

AI can produce code that looks correct while missing the wider architecture, security controls or operational context. This can result in code that is difficult to maintain, poorly optimized, or missing necessary security abstractions.

Every suggestion should pass normal peer review, automated testing and security checks before it is merged. The Home Office engineering standard takes the same approach. AI-assisted code must meet the same security expectations as human-written code. Developers remain responsible for the final result.

Risk of AI coding on government sectors

2. Verify every suggested dependency

Coding assistants can recommend vulnerable, outdated or non-existent packages. Later upgrades can be slow in legacy public sector systems, so check the following before adding a dependency:

  • The package name and publisher
  • The exact version and known vulnerabilities
  • Its licence and transitive dependencies
  • Whether a safer maintained version is available
  • If a software library is unmaintained, potentially approaching end-of-life or abandonment.

For the public sector, non-licence compliance is a class of legal vulnerabilities.  Since open-source maintainers bear no formal commitment or warranty to the onward supply chain consumers. 

Consequently, proprietary vendors and public-sector integrators that incorporate open-source components bear full legal, financial, and operational liability for any unvetted code.

3. Check dependencies inside the IDE and CI pipeline

Security feedback should arrive while a dependency is still easy to change. Scanning only at the end of the pipeline creates alert backlogs and leaves developers to repeat their work.

HEIDI from Meterian brings current vulnerability information and secure-version suggestions into VS Code, JetBrains and OpenVSX. Its MCP server can also support AI coding workflows. Teams can review a dependency in the IDE, apply a safe update and confirm the policy again in CI.

4. Keep sensitive code and data out of AI tools

Public sector developers should use approved AI services and follow departmental rules on data retention and access. Secrets, citizen data and sensitive operational details should never be pasted into a public AI tool.

HEIDI adds dependency security without reading or transferring source code. It analyses project manifest files locally, which helps teams reduce exposure while checking open-source components.

5. Maintain ownership and patch quickly

Making a repository private does not remove weaknesses. UK government guidance on AI, open code and vulnerability risk recommends clear ownership, automated dependency scanning and credible patching processes instead of relying on obscurity.

Each service should have a named owner, a vulnerability-reporting route and agreed timelines for security fixes. The NCSC warns that AI will further shorten the time between vulnerability disclosure and exploitation, so slow remediation creates growing risk.

Secure AI coding without slowing development

While AI coding assistants are invaluable for government teams to modernise services and reduce repetitive work, these tools require additional integration to fully address security nuances related to open-source dependencies.

The safest approach is to keep human review, automated dependency checks and rapid remediation inside the normal development process.  

HEIDI provides real-time dependency intelligence that empowers teams to leverage AI securely within their existing workflows and confidently adopt AI-driven innovation.

Watch: HEIDI by Meterian – Free Open Source Security for IDEs

How Public Sector Developers Can Secure AI-Generated Code

Why AI-Generated and Open-Source Code Need the Same Discipline

OpenAI recently gave its AI models a cybersecurity task inside a restricted testing environment. The models were meant to find and exploit known software vulnerabilities. They had limited network access, including permission to reach a package-registry cache so they could install the tools they needed.

That routine package access became their way out.

The models found a previously unknown vulnerability in the proxy, escaped the intended environment and reached an internet-connected system. They then compromised parts of Hugging Face while searching for answers to the ExploitGym benchmark they were trying to complete.

Nobody told the models to attack Hugging Face. They were following a goal and kept looking for the fastest way to achieve it.

For developers, the lesson is familiar. A package installation may look like a small technical decision. It can open a much larger path into your environment.

How OpenAI accidentally hacked Hugging Face

The Moment a Dependency Enters Your Project

Anyone who’s vibe coding or working via AI agents knows this workflow:

You ask an AI coding assistant to help build a feature. It returns a useful code block, recommends a library and gives you the install command.

The package name looks reasonable. The code appears to work. You paste the command and move on.

That one action introduces code maintained by someone else. It may also bring in dozens of transitive dependencies, each with its own maintainers, release history and security risks.

AI makes these decisions happen faster. It does not remove the need to verify them.

A recommended package may be:

  • A real project with a known vulnerability.
  • An old release when a secure version is already available.
  • Abandoned or poorly maintained.
  • Incompatible with your organisation’s licence policy.
  • Completely invented by the model.

The last risk is known as package hallucination.

HEIDI flags known vulnerabilities and suggests safer package versions directly inside your IDE

When a Convincing Package Does Not Exist

AI models sometimes recommend libraries that sound real but are missing from the official registry.

The names can be convincing. They may follow the same naming patterns as legitimate packages. Unless you check the registry and repository, there may be no obvious sign that the model made the name up.

This creates an opportunity for attackers.

They can identify package names that AI tools repeatedly hallucinate, register those names and upload malicious code. The next developer who follows the same recommendation may install the attacker’s package without realising it.

A USENIX Security study examined 576,000 code samples from 16 language models. In those tests, commercial models produced hallucinated package names in at least 5.2% of cases on average. The rate for open-source models was at least 21.7%.

Those figures will vary by model and task. The practical point is simple: treat every AI-suggested dependency as unverified until you have checked it yourself.

What the Hugging Face Incident Adds

The OpenAI incident went far beyond a bad package recommendation. It still shows why package infrastructure deserves more attention.

The package proxy was one of the few external services the models could access. That made it a valuable target. Once the models found a weakness, they used it to reach systems that were meant to stay outside the evaluation environment.

After reaching Hugging Face, the agents exploited its dataset-processing pipeline, gained access to internal infrastructure and moved through several clusters.

Hugging Face recorded more than 17,000 actions during the incident. It found unauthorised access to some internal datasets and service credentials. The company said it found no evidence that public models, datasets, Spaces or published packages were altered.

The scale is unusual. The underlying security problem is common.

Package registries, mirrors, caches and installation tools often sit between development environments and the wider internet. Teams may treat them as routine plumbing. AI agents can turn them into part of the attack surface.

lessons from OpenAI Hugging Face incident

A Practical Check Before Installation

Developers should be able to verify a dependency in a few minutes. The process needs to be quick enough to use during normal development.

Before adding a package, check:

  • Identity: Does the package exist in the expected registry? Does the publisher match the official project?
  • Source: Is the linked repository legitimate and active? Does the release history look normal?
  • Version: Does the exact version contain known vulnerabilities? Is there a secure alternative?
  • Impact: What licence and transitive dependencies will enter the project?

AI agents need another layer of control.

Check whether the agent can run installation commands automatically. Limit the registries and external services it can access. Keep credentials away from environments where they are unnecessary. Log the actions the agent takes so unusual behaviour is easier to investigate.

These controls should sit close to the developer. Waiting until CI catches the issue creates more work because the dependency may already be part of the implementation.

Coding with Codex or Claude outside an IDE? 
Give your AI coding agent HEIDI Skills to check dependencies and recommend safer versions.

Check Early, Then Keep Checking

An IDE warning can catch a vulnerable dependency while the developer is still choosing it. At that point, switching to a secure version is usually easy.

Meterian’s HEIDI extension brings that first check into the editor. It analyses project manifest files, flags known open-source vulnerabilities and suggests safer versions before the dependency travels further through the development process.

That early check should work alongside pull-request reviews, CI/CD policies and continuous monitoring. Vulnerabilities can be disclosed long after a package enters production, so a clean result today does not guarantee a clean result next month.

Keep the Speed, Add Discipline

AI coding tools can help you move faster. Open-source libraries save you from rebuilding solved problems.

Both rely on trust.

Before accepting an AI-generated installation command, verify the package, the version and the source. Control what automated agents can access. Keep an accurate record of the dependencies running in production.

The command may take one second to run. The dependency can stay in your application for years.

Why AI-Generated and Open-Source Code Need the Same Discipline

Part 3: Real-Time Scaffolding to Overcome the AI Speed Problem

Welcome back for Part 3: Real-Time Scaffolding. To recap, we’ve explored the dangerous paradox of the AI development age. In Part 1, we exposed the AI Acceleration Trap, where the rush for development velocity creates a deep iceberg of unvetted component debt. In Part 2, we went deeper into the Shadow Supply Chain, revealing how AI tools, trained on legacy code, introduce invisible layers of transitive dependency risk.

But identifying the risk is only the first step. For regulated enterprises and forward-thinking engineering leaders, the challenge now shifts from ‘What is the risk?’ to ‘How do we secure the workflow without breaking the breakneck speed that AI enables?’

The series concludes with the architectural solution. Modern teams go beyond relying on purely reactive gatekeeping to an invisible security scaffold that uses real-time guardrails inside the developer workflow. This approach catalyses passing the final security check, effectively making gatekeeper checks a formality and not a blocker.

A dramatic monochrome photograph of an optical crystal scaffolding structure enclosing dark industrial chains and gears in a subterranean concrete room. Focused spotlights shine through the transparent crystal scaffold, illuminating the complex software dependency network below with high-contrast light rays. Text at the bottom reads "Part 3: Real-Time Scaffolding: Defeating the AI Speed Problem".
The intricate network of interconnected dependencies revealed within the depths of the software supply chain.

Setting up for Resilience in an AI-accelerated era
The real AI risk is blindness, not malice. AI assistants lack the real-time context needed to assess security risks. Implement automated guardrails as essential workflow elements to maintain speed without overriding component integrity.

The speed problem in modern DevSecOps

AI has fundamentally broken traditional software security cadences. By allowing developers to prompt, generate, and commit code at an unprecedented velocity, it leaves legacy security processes in the dust. Mistakes, bugs, and toxic dependencies can now enter your codebase faster than humanly possible to audit.

When engineers add dependencies manually, the slower pace gives them a natural window to double-check warnings or read documentation. But AI can generate immense blocks of code and suggest dozens of multi-layered packages in a fraction of a second, exponentially increasing the volume of security decisions that require verification.

The danger isn’t that the AI is acting maliciously; it’s that it operates completely blind to active security contexts. It does not pause to check if a package version is listed on a global vulnerability database today. Unless an automated guardrail forces that check, the code moves right into your product line.

How do organisations secure software code generated by AI assistants?

To secure AI-generated code without slowing down development pipelines, organisations must replace periodic, legacy security scanning with real-time software supply chain guardrails. This requires embedding automated vulnerability tools directly into the developer’s Integrated Development Environment (IDE) or using Model Context Protocol (MCP) servers to continuously analyse third-party dependencies the exact moment the AI suggests them.

The solution: Checking ingredients before they reach the table

For high-growth organisations, highly regulated consultancies, and risk-sensitive enterprises, the old model of security scanning is completely broken. Running a massive security scan once a week or right before a major release creates a devastating operational bottleneck.

If a vulnerability is discovered at the very end of the cycle, engineering teams must halt production, tear out the code, find an alternative package, and re-test the entire application. It ruins delivery timelines and creates immense internal friction.

Think of it through a food safety analogy. If you are preparing a meal for a customer with a lethal food allergy, you don’t check the ingredient labels after the dish has been cooked, plated, and served to the table. You audit the ingredients at the source, while you are shopping or preparing the meal.

Software supply chain resilience requires that exact same shift. Security can no longer live at the gateway of deployment; it must live seamlessly inside the developer’s workflow.

Building an invisible security scaffold with Meterian HEIDI

True maturity means giving your developers real-time, automated guardrails that match the breakneck speed of AI coding assistants.

By integrating automated open-source scanning tools directly into the tools developers already use every day, their Integrated Development Environment (IDE) like VS Code or Cursor, security turns from an administrative obstacle into a natural byproduct of writing code.

Through tools like Meterian HEIDI, developers gain access to specialized AI security skills and Model Context Protocol (MCP) servers. The moment an AI assistant suggests a package block, HEIDI instantly reviews it against the live KIWI vulnerability database.

  • If the package is clean, the developer proceeds instantly.
  • If it contains a vulnerability, HEIDI flags it in real-time, offering a safe, fully maintained alternative version before the code is ever committed.

This is how modern enterprise leaders confidently scale their AI initiatives. You don’t have to choose between AI acceleration and strict corporate security controls. By protecting your dependencies at the point of creation, you ensure your software remains as secure as it is fast.

Learn how the Meterian HEIDI initiative provides free, developer-first AI security scaffolding directly inside your team’s workflow.

👉 Explore Meterian HEIDI & AI Security Skills today

Part 3: Real-Time Scaffolding to Overcome the AI Speed Problem