Skip to content
Agentic SDLC

Dependency upgrades with AI coding agents: a safe playbook for Claude Code and Codex

Since April 2026 you can assign a Dependabot alert to Claude, Codex or Copilot and get a draft pull request back. Upgrades are the most agent-friendly chore in software, and the one where a careless bump can ship someone else's malware. Here is a playbook that sorts upgrades into lanes, gives the agent a real ticket and keeps a person on the merge button.

Sydla Journal cover: dependency upgrades with AI coding agents, showing a queue of upgrades sorted into four lanes, security fix, routine patch or minor, major version and new dependency, each with its own gate, next to a cooldown timer for releases younger than three days

The upgrade queue is now an agent queue

Every team has the same backlog nobody wants: forty open Dependabot or Renovate pull requests, a major version of the framework two releases behind, and a security alert that has been red for a month. In April 2026 GitHub made it possible to assign a Dependabot alert to a coding agent, Copilot, Claude or Codex, and get back a draft pull request that bumps the package and tries to fix the tests the bump broke. Claude Code and Codex can do the same from a terminal for any package manager.

Upgrades look like the perfect agent job: well defined, boring, testable. They are also the job with the worst failure mode. In September 2025 the self-replicating Shai-Hulud worm compromised more than 500 npm packages by publishing poisoned versions from stolen maintainer accounts. A second wave in November 2025 ran during pre-install and spread to over 25,000 malicious repositories. An agent told to "update everything to latest" on the wrong afternoon installs exactly those versions, with your tokens in the environment.

The context an agent needs to upgrade well is scattered too. Why the package is pinned sits in a Jira ticket, the upgrade policy in Confluence, the list of risky packages in Notion, the screens a UI library change might break in Figma, the release flow on a Miro board and the launch graphic in Canva. That is six context hops and, with each vendor's own AI, up to six credit meters. Our AI credit fatigue piece adds those meters up.

This playbook gives you four lanes to sort upgrades into, a seven-field upgrade ticket written for an agent reader, supply-chain guardrails, and a walkthrough where the upgrade comes back with evidence a reviewer can check in ten minutes.

What the tools already do for you

Before you write a single prompt, turn on what your package tools already ship. Most of the safety in an agent upgrade comes from settings, not from the model:

  1. Dependabot assign to agent. Generally available on github.com since 7 April 2026. From an alert, Assign to Agent sends it to Copilot, Claude or Codex. Each agent works on its own and opens its own draft pull request, so you can compare approaches. It needs GitHub Code Security and a Copilot plan with coding agent access. GitHub's own note: AI-generated fixes are not always correct; review, check the tests and confirm before merging.
  2. Dependabot cooldown. Version updates now wait a default cooldown of 3 days after a release, even when you do not configure one. You can set separate waits for major, minor and patch releases. Security updates skip the cooldown, which is what you want.
  3. Dependabot groups. Matching updates are combined into one pull request. Group patch and minor updates of dev tooling together; keep each major version on its own.
  4. Renovate minimumReleaseAge. Renovate waits until a release has been public for the age you set, and shows a pending status check until then.
  5. pnpm minimumReleaseAge. pnpm refuses to install a version, including transitive ones, until it has been published for a set number of minutes, 1,440 by default. The docs give the reason plainly: most malicious releases are found and removed within an hour.
  6. Codex migration use cases. OpenAI's guides ask for checkpoints, lint, type-check and focused tests after each milestone, with rollback kept visible, and a bounded brief that stops if the change needs a wider dependency upgrade than planned.

None of these tools decides whether an upgrade is worth doing now, or what "still works" means for your product. That is the ticket's job, and it starts with sorting the queue.

Step 1: sort the upgrade queue into four lanes

Every upgrade fits one of four lanes. Each lane has a different gate, and only two of them are routine agent work.

  1. Security fix. A Dependabot or audit alert with a fixed version. Fast lane: no cooldown, the agent bumps to the smallest fixed version, runs the suite and opens a merge request the same day. A person reviews the lockfile diff.
  2. Routine patch or minor. Grouped, after the cooldown, with green CI. The agent's job is to read the changelogs, flag anything that is not a pure fix and fix small breakages. Batch them weekly so review is one sitting, not forty.
  3. Major version. One major per ticket, never grouped. The agent reads the migration guide, lists every call site it affects and proposes a plan in checkpoints before changing code. A person approves the plan, then the run.
  4. New or replacement dependency. Adding a package, or swapping one for another. The agent may research and recommend, but it never adds a dependency on its own. A person checks the maintainers, the licence, the install scripts and the download history, then decides.
Four lanes for dependency upgrades. Security fix: no cooldown, smallest fixed version, merge request the same day. Routine patch or minor: grouped weekly after a 3-day cooldown. Major version: one per ticket, the agent plans in checkpoints and a person approves. New dependency: the agent recommends and a person decides. Below, the six-tool stack where upgrade context usually lives, $83.85 per user per month, against one Sydla work item at $19.
Two lanes are routine agent work. Two need a person before any code changes.

One rule holds the lanes together: the agent never chooses the version on its own. The ticket names it, or the ticket names the rule (smallest fixed version, latest after cooldown) and the agent reports which version that rule picked.

Step 2: the seven-field upgrade ticket

For anything beyond a grouped patch bump, the agent gets a ticket, not "bump X". Seven fields, each written for an agent reader:

  1. 1. Package, from and to. The exact current version and the target, or the rule for picking it. For a major version, link the official migration guide.
  2. 2. Why now. The alert, the end-of-support date or the feature you need. It tells the agent what must be true at the end, and it tells the reviewer whether a smaller step would do.
  3. 3. Blast radius. Ask the agent to list every import and call site before changing anything, and to report the count. If it is far larger than you expected, stop and re-plan.
  4. 4. Behaviour contract. The tests, fixtures and acceptance criteria that must pass unchanged. Our acceptance criteria guide shows how to write ones an agent can check. For UI libraries, add the screen states to compare.
  5. 5. Frozen and allowed. Tests, CI configuration and other packages are frozen. The agent may change call sites in named paths and the lockfile for this package only. No new dependencies, no loosened version ranges elsewhere.
  6. 6. Proof. Lint, type-check and the full suite green; the contract tests pass before and after; the lockfile diff touches only the expected packages; for a major, each checkpoint was green on its own.
  7. 7. Done means. A merge request with the changelog items that apply to you, the list of call sites changed, the lockfile diff summary, test output and run cost. A person merges, and the rollback is a single revert.

If this looks like our refactoring ticket, it is on purpose. A major upgrade is a refactor that someone else started for you, with a changelog instead of a design doc.

Where upgrade context lives in 2026, and what it costs

The ticket is short. The context behind it usually sits in six subscriptions, and the agent has to reach each one:

One paid seat per tool, monthly USD list prices before tax, checked on 14 November 2026. AI notes checked on 19 November 2026.
Tool and planSeat / monthAI layer and limitsUpgrade context usually kept there
Jira Standard$9.70Rovo, 25 credits per user per month on Standard (70 Premium, 150 Enterprise), $0.01 per extra credit from 3 Dec 2026Why a package is pinned, past upgrade tickets
Confluence Standard$7.15Same pooled Rovo creditsUpgrade policy and support windows
Notion Plus$12.00Custom Agents on credits, Business and Enterprise onlyRisky-package lists and engineering notes
Figma Professional, Full seat$20.003,000 AI credits per Full seat per month; MCP reads 200 per day on Full and Dev, 20 per month on View and CollabThe screens a UI library upgrade can break
Miro Starter$10.00Create with AI on Miro creditsThe release flow
Canva Business$25.00Canva AI usage per memberRelease graphics
Six-tool total$83.85Up to six meters, six MCP serversOne upgrade, six places
Sydla$19.00None: your own Claude Code or Codex plan pays for the modelBrief, criteria, UX states, run and evidence on one work item

Upgrade agents add their own meters on top of the seats. Dependabot's assign-to-agent flow runs on your Copilot plan and GitHub Code Security; a Claude Code or Codex run in CI uses runner minutes and tokens. A major upgrade that reruns a long suite at every checkpoint costs more in minutes than in tokens, so plan the checkpoints. The comparison overview covers each tool, and the pricing section lists the source for every price.

Upgrade without a second AI bill

Keep the upgrade policy, the criteria and the UX states next to the run, and let your own coding agent read them through one connection, for $19 per month instead of $83.85. That is $64.85 saved per user, every month, with no credit meter to watch while the agent reads changelogs, fixes call sites and reruns the suite.

Step 3: supply-chain guardrails for agent upgrades

An agent that installs packages runs other people's code on your machine. These rules keep that from becoming an incident:

  1. Wait before you trust. Keep Dependabot's cooldown, and set a release age in Renovate or pnpm. Three days is a sane default for routine updates. Security fixes are the exception and go through the fast lane.
  2. Install without scripts first. Let the agent resolve and install with lifecycle scripts disabled (npm and pnpm both have an ignore-scripts option), then allow scripts only for packages that need them. Shai-Hulud spread through install scripts.
  3. No secrets in the upgrade session. No publish tokens, no cloud keys, no production credentials in the environment the agent installs in. A fresh worktree helps: Claude Code's docs note that a worktree has no .env and no installed dependencies until you add them.
  4. Read the lockfile diff. Ask the agent to summarise which packages changed, including transitive ones, and why. A patch bump that pulls in a new transitive package with an install script deserves a person's look.
  5. One major per merge request. Grouping majors makes failures impossible to bisect and rollbacks impossible to scope.
  6. Never merge automatically. GitHub says it, OpenAI says it, and the prompt injection guide explains why: changelogs and READMEs are untrusted input the agent reads with your permissions.

Walkthrough: brief, UX Studio, your agent in Sydla Desktop, review

Here is how a major upgrade moves through Sydla on one work item, with the coding agent you already pay for.

  1. Brief on the work item. The upgrade becomes a work item in Sydla with the seven fields. The reason the package was pinned, the support window and the acceptance criteria of the features it touches are already in the same workspace, so the agent reads them instead of guessing.
  2. States in UX Studio. When the package is a UI library, the states it must not break are UX Studio screens built from the workspace's published components and tokens. The agent checks each one after the upgrade instead of eyeballing a few pages. Our design QA guide covers the passes.
  3. Run in Sydla Desktop with your own agent. Sydla Desktop launches the Claude Code or Codex CLI on your machine, signed in with your own Anthropic or OpenAI account, in your local checkout. The agent reads the work item through the Sydla MCP server, lists the call sites, proposes checkpoints, waits for a person to approve the plan, then upgrades and runs the suite at each checkpoint. For UI libraries it can open the app in Desktop's own headless Chrome for the thread and screenshot each state. There are no Sydla AI credits and no token markup. The Desktop guide walks through the first run.
  4. Review the evidence. The changelog items that applied, the call sites changed, the lockfile summary, the test output and the run cost land on the work item. A person reviews the merge request with our four-pass review checklist and merges.
A major dependency upgrade in four steps. Brief: the Sydla work item holds the package, from and to versions, why now, the behaviour contract and frozen files. States: UX Studio holds the screen states a UI library upgrade must keep. Run: your own Claude Code or Codex in Sydla Desktop lists call sites, plans checkpoints, upgrades and runs the suite at each checkpoint, reading everything through one Sydla MCP connection. Review: changelog items, call sites, lockfile diff, test output and run cost on the work item, and a person merges.
Lane, ticket, checkpoints, evidence. A person merges.

If the agent finds that the upgrade changes behaviour your contract protects, it stops. The question goes to the person who owns the behaviour: accept the new behaviour and change the criteria, or hold the upgrade. Agents propose. People decide.

A filled-in example: the PDF export library, 2.x to 3.x

Here is the ticket for a typical major upgrade, at the length we recommend. The library and its changes are illustrative:

  1. Package: the PDF export library, from 2.9.4 to the latest 3.x release that has passed the 3-day cooldown; migration guide linked.
  2. Why now: 2.x leaves security support at the end of the quarter.
  3. Blast radius: list every import first. Expected: the invoice and report exporters, about a dozen call sites.
  4. Contract: the 18 golden PDF fixtures render byte-identical text and the same page count; acceptance criteria AC1 to AC4 of the billing export ticket still pass.
  5. Frozen and allowed: tests, fixtures and CI frozen; call sites under the exporters only; lockfile changes for this package and its own dependencies only.
  6. Proof: checkpoint 1 compiles with the new API behind the old wrapper, checkpoint 2 moves the exporters, checkpoint 3 removes the wrapper. Each checkpoint is green on its own.
  7. Done means: a merge request with the three changelog items that applied, the call-site list, the lockfile summary, the fixture results and the run cost. The billing owner merges.

That is about 150 words. An agent asked only to "upgrade the PDF library" could bump it, update the golden files to match the new output and report all tests green. With the ticket, the fixtures are frozen, so a renamed page-size default shows up as a failing test instead of a customer email. Our guide to writing tests with agents explains how to build fixtures that catch that kind of drift, and the cost per ticket guide shows how to estimate a run like this before you start it.

Frequently asked questions

Can AI coding agents upgrade dependencies?

Yes. Since April 2026 GitHub lets you assign a Dependabot alert to Copilot, Claude or Codex, and each opens a draft pull request with a proposed fix. Claude Code and Codex can also upgrade packages from a terminal for any package manager. They do best on security fixes and routine patch or minor updates; major versions need a plan approved by a person, and new dependencies need a person's decision.

How do I stop an AI agent from installing a malicious package version?

Wait before trusting new releases: Dependabot applies a 3-day cooldown to version updates by default, and Renovate and pnpm have a minimum release age setting. Install with lifecycle scripts disabled first, keep tokens and cloud keys out of the agent's environment, read the lockfile diff including transitive packages, and never merge automatically.

Should an AI agent do major version upgrades?

Yes, with a plan. Give it one major per ticket, the migration guide, frozen tests and fixtures, and ask it to list every call site and propose checkpoints before changing code. A person approves the plan, the agent runs the suite at each checkpoint, and the merge request carries the changelog items that applied and a single-revert rollback.

What does Dependabot's cooldown do?

It delays version update pull requests until a release has been public for a set number of days. Dependabot applies a default cooldown of 3 days even when you do not configure one, with optional separate waits for major, minor and patch releases. Security updates are not delayed by the cooldown.

How much does Sydla cost compared with Jira, Confluence, Notion, Figma, Miro and Canva?

Sydla costs $19 per user per month. One paid seat each of Jira Standard, Confluence Standard, Notion Plus, Figma Professional Full, Miro Starter and Canva Business costs $83.85 per user per month, so the saving is $64.85 per user per month. You bring your own Claude Code or Codex account, so your Anthropic or OpenAI plan pays for the model with no markup.

Keep reading.

All articles

ONE WORKSPACE. THE ENTIRE SDLC.

Your next project.
One $19 subscription.

Keep using your Claude Code and Codex accounts. Bring the work into Sydla.

Get SydlaUSD / user / month · Billed monthlyProvider subscriptions remain separate.