Skip to main content
skill CX Codex

deps — Claude Code skill: what it does, how to install

deps hardens a project's dependency chain: pins versions, adds a release quarantine, Renovate and a dependency review check, skipping whatever is already configured.

MIT 305 installs ★ 8 updated 2026-10-24

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add tartinerlabs/skills --skill deps -a claude-code
Open on GitHub

What deps does

The skill reads the manifest, works out the language and package manager, then applies the missing supply-chain measures: pinned versions, a release quarantine, Renovate, a dependency review step in PRs, and a package runner rule.

It starts by looking for existing setup: renovate.json, a workflow that already runs dependency-review, versions written without ^ or ~. Anything already in place is skipped and listed in the closing summary together with the manual steps left over. The package manager comes from the lockfile, checked in a fixed order that starts with nub.lock. No lockfile means the skill asks rather than guessing.

JS/TS gets the deepest coverage, with the rule files under rules/. Python, Go and Rust go through references/python.md, go.md and rust.md. Other ecosystems follow the same shape: pin versions, scan for known issues, gate pull requests. The skill ships no guide for them, so the config is on you.

What it helps with

  • pin exact dependency versions instead of ranges
  • add a dependency review check to GitHub Actions
  • set up Renovate in an existing repository
  • hold back brand-new package releases with a quarantine
  • see which hardening is already configured before changing anything

Example prompts for the agent

  • Pin the dependency versions and add a dependency review to CI
  • Set up Renovate for this repository
  • Check what supply-chain hardening is already in place and add what's missing

How to install deps

1Skills CLI (Vercel)

npx skills add tartinerlabs/skills --skill deps -a claude-code

2Manually: put the files in place

~/.claude/skills/deps/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/deps/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about deps

How do I install deps in Claude Code?

Run npx skills add tartinerlabs/skills --skill deps -a claude-code. The skill lands at ~/.claude/skills/deps/SKILL.md.

What does the deps skill do?

It detects the project language from the manifest and the package manager from the lockfile, then applies only the measures that are missing: version pinning, release quarantine, Renovate, dependency review and a package runner rule.

Which languages does it cover?

JS/TS is the main path and lives in rules/. Python, Go and Rust are handled by the guides in references/; for other languages the skill has no bundled guide.

Source text

SKILL.md · MIT
---
name: deps
description: Use when hardening a dependency supply chain, pinning versions, adding registry/security flags, or setting up Renovate. Detects the language and locks down install scripts, versions, and CI checks (JS/TS, Python, Go, Rust).
license: MIT
allowed-tools: Read Glob Grep Write Edit Bash(nub:*) Bash(nubx:*) Bash(pnpm:*) Bash(pnx:*) Bash(npx:*) Bash(bunx:*) Bash(npm:*) Bash(bun:*) Bash(yarn:*) Bash(uv:*) Bash(pip:*) Bash(pip-audit:*) Bash(go:*) Bash(govulncheck:*) Bash(cargo:*) Bash(cargo-audit:*) Bash(cargo-deny:*) Bash(gh:*) Bash(glab:*)
model: haiku
effort: medium
compatibility: Any language project; hardens that ecosystem's dependency supply chain (JS/TS best-supported, Python, Go and Rust via references/)
metadata:
  short-description: Dependency supply-chain hardening.
---

You harden dependency supply-chain security. Detect the project's language, then auto-detect what's already configured and apply only missing hardening measures for that ecosystem.

## 0. Detect Language and Route

Detect the project's language from its manifest, then follow the matching hardening guide:

| Language | Detected by | Hardening guide |
|----------|-------------|-----------------|
| **JS/TS** | `package.json` | the `rules/*.md` files below (pinning · release quarantine · Renovate · dependency review · package runner) |
| **Python** | `pyproject.toml`, `requirements*.txt`, `setup.py` | `references/python.md` (pin + hashes · pip-audit · Renovate/Dependabot · dependency review) |
| **Go** | `go.mod` | `references/go.md` (`go mod verify` · govulncheck · checksum DB · dependency review) |
| **Rust** | `Cargo.toml` | `references/rust.md` (commit `Cargo.lock` · cargo audit/cargo-deny · source policy · dependency review) |

Load **only** the guide for the detected language. For a language not listed (e.g. Ruby → `bundler-audit`), apply the same shape — pin versions, scan for vulnerabilities, automate updates, gate PRs — and note that first-class support for it is not yet bundled.

The rest of this file (Steps 1-4) is the **JS/TS** path. For Python, Go or Rust, follow the referenced guide, then use the shared summary format in Step 4.

## 1. Detect Package Manager

Detect the package manager from the lockfile, in this order: `nub.lock`, `pnpm-lock.yaml`, `bun.lock`/`bun.lockb`, `yarn.lock`, `package-lock.json`. With no lockfile, ask.

A `devEngines.packageManager` or `packageManager` field in `package.json` outranks any lockfile. For pnpm, prefer `devEngines.packageManager` over `packageManager`: pnpm 11+ and the `pnpm/setup` action read it first, and pnpm records the resolved version in `pnpm-lock.yaml`. Pin an exact version rather than a range, so every machine and CI run uses the same pnpm — resolve the current latest at setup time (`pnpm view pnpm version`) and write it as `{ "name": "pnpm", "version": "<latest>", "onFail": "download" }`. The same goes for the runtime: declare Node in `devEngines.runtime` (pnpm 10.14+ downloads it and records its checksum in the lockfile) rather than `.nvmrc` or `engines.node`, pinned to the current LTS resolved at setup time — `pnpm runtime set node lts` (pnpm 11.4+) writes the field; confirm the saved `version` is exact, not a range. Write that field when declaring pnpm; migrating a legacy `"packageManager": "pnpm@…"` is worthwhile but optional. Keep one declaration, not both — version switchers refuse a project whose two fields disagree. Yarn still needs `packageManager`, the only field it reads. Nub runs in compat-mode over another manager's lockfile, so `nub.lock` alongside `pnpm-lock.yaml` means nub — check the field before concluding from lockfiles alone.

Rule files use two placeholders. Replace `<pm>` with the detected manager and `<pmx>` with that manager's ephemeral package runner — see the mapping table in `rules/package-runner.md`.

## 2. Detect Existing Config

Before applying any hardening, scan for existing configurations:
- `renovate.json` / `.renovaterc` / `.renovaterc.json` / `renovate` key in `package.json` → Renovate already configured
- `.github/workflows/*.{yml,yaml}` containing `dependency-review` → dependency review exists
- `package.json` dependency versions without `^` or `~` prefixes → already pinned

**Skip rules whose checks already pass.** Report what was skipped at the end.

## 3. Apply Rules

Read each rule file for detailed instructions and config templates.

| Rule | Impact | File |
|------|--------|------|
| Release quarantine | MEDIUM | `rules/release-quarantine.md` |
| Version pinning | HIGH | `rules/version-pinning.md` |
| Renovate | MEDIUM | `rules/renovate.md` |
| Dependency review | HIGH | `rules/dependency-review.md` |
| Package runner | MEDIUM | `rules/package-runner.md` |

## 4. Output Summary

After all rules are processed, display a summary:

```
## Supply Chain Hardening Complete

### Applied
- [list of rules applied with brief description]

### Skipped (already configured)
- [list of rules skipped with reason]

### Manual Steps Required
- [any post-setup steps, e.g. "Run `<pm> exec husky` to reinitialise git hooks"]
```

© tartinerlabs · MIT · tartinerlabs/skills

Similar skills

All skills for Security →

From the same set17

The whole set →
setup setup reads the project manifest, picks the language, and fills in the missing tooling: linter, formatter, git hooks, type checking, secret scanner. CX Codex +1 413installs create-branch create-branch creates git branches with naming validation and connects them to GitHub or GitLab issues automatically. Helps start new feature work cleanly. CX Codex +1 413installs update-project The update-project skill compares AGENTS.md, CLAUDE.md and README.md against recent commits and fixes the stale parts. Run it after big changes or before a release. CX Codex +1 410installs github-issues github-issues — a skill that files, updates, searches and comments on GitHub and GitLab issues through gh and glab, with repo templates and auto-assignment. CX Codex +1 409installs modernize-tests The modernize-tests Claude Code skill migrates XCTest and XCUIAutomation suites to Swift Testing and revises existing Swift Testing tests. It activates for work on those frameworks and code using @Test, @Suite, #expect, or #require. CX Codex +1 340installs app-intents-whats-new-27 app-intents-whats-new-27 — a skill for Claude Code and Codex guides migration to new App Intents APIs in iOS 26 and iOS 27. It enforces exact @available checks and keeps code strictly within public Apple interfaces. CX Codex +1 184installs building-document-based-swiftui-applications The building-document-based-swiftui-applications skill guides SwiftUI document apps built around the Document protocol. Use it for file opening, editing, saving, exporting, and migrations from older document APIs. CX Codex +1 183installs app-intents-specialist app-intents-specialist — a skill for Claude Code, Codex, Cursor, and other agents that loads Apple's App Intents reference material into context. Covers perform(), AppEntity, AppEnum, @Dependency, donations, and AppShortcut phrases. CX Codex +1 183installs

Project sponsors

Companies that keep this analytics open