Skip to content
Blog

8 min read

GitHub pauses Dependabot in inactive projects

From 8 December 2026, old repositories may stop receiving new vulnerability alerts even though the systems behind them are still in use.

By Written with AI assistance from the source

Mist-covered cliffs along a calm coast
Photo: Petra Reid on Unsplash

What GitHub is changing

From 8 December 2026, GitHub will disable Dependabot alerts in most repositories where no activity has been recorded during the previous year. Existing alerts will not be deleted. They will be archived and can be restored if monitoring is enabled again.

GitHub describes the change in its changelog about inactive repositories. The aim is to focus resources on repositories that are still being developed, while the number of known vulnerabilities and security alerts continues to grow.

Dependabot alerts are GitHub's warnings about known security issues in the packages used by a project. For a typical web project, this may include dependencies declared in package.json and locked to specific versions in files such as package-lock.json or pnpm-lock.yaml. GitHub compares the project's dependencies with published security advisories and creates an alert when an installed version is considered vulnerable.

The important word in this change is activity. GitHub counts the following as activity, among other things:

  • code or a tag is pushed to the repository
  • the repository is created
  • Dependabot alerts are enabled

A push to any branch or tag reactivates monitoring. You can also enable it manually in the repository's security settings. When this happens, the archived alerts are restored and the activity period starts again.

Some repositories are exempt. These include repositories covered by an enforced security configuration that requires Dependabot alerts to be enabled. The change applies to GitHub.com, including affected cloud-based enterprise environments, but not to GitHub Enterprise Server installations.

This is not the same as marking a repository as archived. A repository can be open and fully editable but still count as inactive because no changes have been pushed for a long time.

Why old prototypes may still be exposed

Activity in a repository does not indicate whether the system behind the code is in use. An old prototype may still be published on Vercel, connect to a Supabase database, receive form data or use authentication and external APIs. It may also be hosted on its own domain, which may still receive traffic.

It is therefore risky to interpret inactive code as decommissioned code. GitHub only sees what happens in the repository. The platform does not know whether a previously built version is still running elsewhere.

This is particularly relevant to projects created with Lovable or similar tools. A working application can be created, connected to GitHub and published quickly. When the idea is then put on hold, the repository may be left untouched while the deployment, database and integrations remain active.

If Dependabot alerts are disabled, you will not receive ongoing warnings when new vulnerabilities are discovered in the recorded dependencies. A package version that had no known issues when the prototype was built may be classified as vulnerable much later. The code does not need to have changed for the project's risk profile to change.

The change may also affect Dependabot's automatic security updates. These updates use open alerts to try to create pull requests with safer package versions. If alerts are disabled, the signal on which the security updates rely is no longer available.

At the same time, it is important to understand what Dependabot does not check. It is not a substitute for reviewing:

  • leaked secrets and API keys
  • incorrect permissions in Supabase
  • unprotected database rules
  • old user accounts and OAuth connections
  • environment variables in Vercel
  • insecure custom API routes
  • domains, webhooks and external integrations

A repository without Dependabot alerts is therefore not automatically secure. It only means that GitHub is not showing a known match within the part of the dependency chain that the service can analyse.

How to find repositories that still need monitoring

Do not start by asking whether a repository is active on GitHub. Start by asking whether anything from the repository is still running, storing data or accessible externally.

Review both personal repositories and repositories in organisations where you have administrator access. Prioritise projects connected to production environments, databases, authentication, payments or customer data.

Use this checklist for each old project:

  • Check whether a deployment is still active on Vercel or another platform.
  • Open the project's public URL and see whether the application can be used.
  • Check whether the repository is connected to an active Supabase project.
  • Review whether the database contains data that needs to be retained, exported or deleted.
  • Check whether Stripe, email services, OAuth providers or other APIs are still connected.
  • See whether domains, webhooks or scheduled jobs point to the project.
  • Check which people still have access to the repository and connected services.
  • Open the repository's security view and check the status of Dependabot alerts.
  • Review open and archived alerts before updating dependencies.
  • Decide who will be responsible for the project from now on.

Also check that GitHub can read an accurate description of the dependencies. Manifests and lockfiles need to be present in the repository and match the code that has actually been deployed. If a lockfile is missing, no longer updated or ignored by Git, the analysis may provide an incomplete picture.

For a project that has been rebuilt several times, production may also come from a different commit or branch from the one you first review. Compare the deployment's source version with the contents of GitHub before drawing conclusions about which packages are in use.

Then categorise the projects by their actual status:

  • In production – the system is in use and needs ongoing maintenance and security monitoring.
  • Paused – the system may be resumed and needs either monitoring or controlled decommissioning.
  • Abandoned but accessible – the system should not be used, but resources or URLs remain active.
  • Decommissioned – production, data, integrations and access have been dealt with and documented.

This categorisation is more useful than the date of the latest commit. It describes whether the project still has a real attack surface.

How to keep security alerts enabled

For an individual repository, open Settings, go to the security section and find Advanced Security. Check that Dependency graph and Dependabot alerts are enabled. If you want GitHub to suggest fixes, you also need to check the setting for Dependabot security updates.

You can reactivate alerts by pushing a change to the repository, but avoid making a meaningless commit solely to reset the activity period. This does not resolve the question of responsibility and may make the history harder to understand. Instead, use the review as an opportunity to document the project's status and make a deliberate decision about whether to keep it running.

The dependabot.yml file is not the same as Dependabot alerts. It mainly controls how Dependabot should look for and suggest version updates. The vulnerability alerts themselves are enabled in GitHub's settings. A repository can therefore contain a correctly configured file without alerts being enabled.

If several repositories are in the same GitHub organisation, consider a shared security configuration. An enforced configuration that enables Dependabot alerts prevents the feature from being disabled because of inactivity. It also reduces the risk of different projects having different security levels depending on who created them.

Whatever the method, someone needs to receive and handle the alerts. You should therefore also check GitHub's notification settings and which people or teams have access to the security information. An enabled alert that nobody sees or takes responsibility for offers limited protection.

When you enable monitoring again, previous alerts may be restored. Treat them as routine maintenance, not as changes to merge without checking:

  • read which dependency is affected and whether it is used in production
  • check whether the issue concerns a direct or indirect dependency
  • update the lockfile together with the manifest
  • run the project's tests and build process
  • check authentication, database queries and important integrations
  • deploy only after verifying that the update works

What you should do before 8 December 2026

The most sustainable approach is not to keep every old repository artificially active. The aim should be for every project either to have clear ownership for maintenance or to be properly decommissioned.

For repositories that still run a service, enable and check Dependabot alerts, make sure notifications reach the right person and plan regular dependency reviews. For projects in an organisation, a shared, enforced security configuration may be more appropriate than manual settings in each repository.

For prototypes that are no longer meant to be used, making the repository private or archived is not enough. Also disable deployments, remove unused domain connections, revoke API keys, stop webhooks and decide what should happen to the data. Check that no external service continues to call the system.

Document the decision in the repository's README or in the project's internal documentation. State whether the system is in production, paused or decommissioned, where it runs and who is responsible for it. This makes the next security review less dependent on the memory of the person who happened to build the first version.

GitHub's change makes an already important distinction clearer: inactive development is not the same as decommissioned production. A project may stop changing but remain exposed through its deployment, database and integrations.

If the review shows that a quick prototype is still in use but lacks clear maintenance, the next step is to move from prototype to product with controlled operations, security work and responsibility for ongoing development.


Source: GitHub changelog

Want to know what your build would take?

Three questions, then you get a clickable sketch for free.

← All articles