Upgrade Project Dependencies Safely

Dependency Upgrade Strategy is a skill that positions the model as a dependency management expert specializing in safe, incremental upgrades of project dependencies. It plans and executes dependency updates with minimal risk, proper testing and clear migration paths for breaking changes. The stated focus is risk assessment, incremental upgrades, automated testing and rollback strategies, so that upgrades keep the system stable while dependencies stay current and secure.

The playbook is organized into ten steps:

1. Dependency update analysis: a Python DependencyAnalyzer that audits all dependencies and produces the dependencies, an update strategy, a risk assessment and a priority order.
2. Breaking change detection: a BreakingChangeDetector that fetches a changelog between two versions, scans it for markers such as BREAKING CHANGE, removed, deprecated and renamed, and records API changes, removed features, changed behavior and an estimated effort.
3. Migration guide generation: a generator that writes a guide for a package upgrade, including estimated time, risk level, a pre-migration checklist, steps for updating dependencies, addressing breaking changes, updating code patterns, running codemods, testing and performance validation, a rollback plan and common issues.
4. Incremental upgrade strategy: an IncrementalUpgrader that lists the versions between the current and target release, identifies safe stopping points and creates a stepwise upgrade path with upgrade, test and verification commands for each step.
5. Automated testing strategy: a JavaScript upgrade test suite for validating a target version.
6. Compatibility matrix: a checker that records, for each dependency, its current and target versions, what it is compatible with, conflicts and peer requirements.
7. Rollback strategy: a shell script that creates a rollback point (backup copies of package.json and package-lock.json, a timestamped git tag, an optional database backup), performs the rollback, and verifies it.
8. Batch update strategy: grouping updates into security, patch, minor and major batches. Security updates come first with immediate handling and full testing, patch updates are grouped, minor updates go in incrementally, and major updates are handled one at a time.
9. Framework-specific upgrades: guides for Angular (ng update with dry-run pre-checks), React (rename-unsafe-lifecycles and error-boundaries codemods) and Vue (a migration tool and the Vue 2 to 3 breaking changes such as the Composition API, multiple root elements, Teleport and Fragments).
10. Post-upgrade monitoring: thresholds for page load time, API response time, memory usage, error rate, console errors and bundle size.

The generated migration guide includes a rollback section like this:

# Revert package version
git checkout package.json package-lock.json
npm install

Use it when you need to upgrade project dependencies safely, handle breaking changes, ensure compatibility and maintain stability. It fits work that needs a prioritized list of updates, a per-package migration guide and a rollback plan.

Do not use it when the task is unrelated to dependency upgrade strategy or requires a different domain or tool outside this scope. The skill also states that its output is not a substitute for environment-specific validation, testing or expert review, and that you should stop and ask for clarification if required inputs, permissions, safety boundaries or success criteria are missing.

The input is the upgrade request, supplied as the skill's arguments, along with the project's current dependencies. The skill asks you to clarify goals, constraints and required inputs, apply best practices and validate outcomes, and provide actionable steps with verification.

The output is organized into eight parts, listed here in the skill's own order:

• Upgrade Overview: a summary of available updates with risk assessment.
• Priority Matrix: an ordered list of updates by importance and safety.
• Migration Guides: step-by-step guides for each major upgrade.
• Compatibility Report: dependency compatibility analysis.
• Test Strategy: automated tests for validating upgrades.
• Rollback Plan: clear procedures for reverting if needed.
• Monitoring Dashboard: post-upgrade health metrics.
• Timeline: a realistic schedule for implementing upgrades.

The testing and monitoring examples add concrete pass criteria. The upgrade test suite captures a baseline of unit, integration and end-to-end results, performance metrics and bundle size before the upgrade, reruns the same checks afterward, and reports failures, regressions and improvements, with smoke tests for critical user flows, API compatibility and the build process. The post-upgrade health check compares measured values against thresholds and marks each metric PASS or FAIL: page load time up to 3000 ms, API response time up to 500 ms, memory usage up to 512 MB, an error rate of 0.01 percent, zero console errors, a bundle of at most 5 MB and a gzipped size of at most 1.5 MB.

The examples use npm commands (install, lint, test, type-check, ci), git branches and tags, Python's packaging module for version comparison, and framework tooling such as ng update, react-codemod and the Vue migration tool. The rollback script optionally calls a database-backup.sh script if one exists in the project, and it checks service health on a local health endpoint.

Developers and maintainers who are responsible for keeping project dependencies current and secure, and who want incremental, tested upgrades with a clear way back.