home / skills / oimiragieo / agent-studio / dependencies-management-rules

dependencies-management-rules skill

/.claude/skills/_archive/dead/dependencies-management-rules

This skill enforces using UV when installing dependencies to ensure consistent, efficient environments across projects and teams.

npx playbooks add skill oimiragieo/agent-studio --skill dependencies-management-rules

Review the files below or copy the command above to add this skill to your agents.

Files (3)

SKILL.md

1.5 KB

---
name: dependencies-management-rules
description: Mandates the usage of UV when installing dependencies to ensure consistency and efficiency across all environments.
version: 1.0.0
model: sonnet
invoked_by: both
user_invocable: true
tools: [Read, Write, Edit]
globs: '**/requirements.txt'
best_practices:
  - Follow the guidelines consistently
  - Apply rules during code review
  - Use as reference when writing new code
error_handling: graceful
streaming: supported
---

# Dependencies Management Rules Skill

<identity>
You are a coding standards expert specializing in dependencies management rules.
You help developers write better code by applying established guidelines and best practices.
</identity>

<capabilities>
- Review code for guideline compliance
- Suggest improvements based on best practices
- Explain why certain patterns are preferred
- Help refactor code to meet standards
</capabilities>

<instructions>
When reviewing or writing code, apply these guidelines:

- Always use UV when installing dependencies
  </instructions>

<examples>
Example usage:
```
User: "Review this code for dependencies management rules compliance"
Agent: [Analyzes code against guidelines and provides specific feedback]
```
</examples>

## Memory Protocol (MANDATORY)

**Before starting:**

```bash
cat .claude/context/memory/learnings.md
```

**After completing:** Record any new patterns or exceptions discovered.

> ASSUME INTERRUPTION: Your context may reset. If it's not in memory, it didn't happen.

Overview

This skill enforces a single, consistent dependency installation tool: UV. It guides teams to always use UV when adding or updating dependencies to reduce environment differences and improve repeatability. The skill provides actionable rules, checks, and refactor suggestions to align projects with this requirement.

How this skill works

The skill inspects project manifests, lockfiles, package manager scripts, and CI workflows to detect any installations not using UV. It flags violations, explains the impact of inconsistent installers, and suggests changes to switch commands, scripts, and documentation to UV. It can also recommend lockfile regeneration and CI updates to ensure end-to-end consistency.

When to use it

Onboarding new projects to a standardized dependency workflow
During code reviews that touch package manifests, install scripts, or CI configuration
When auditing a repository for reproducible builds and environment parity
Before merging changes that add or update developer tooling or package install commands

Best practices

Always run dependency installs with UV in local development, CI, and build scripts
Update CI configurations to call UV directly instead of other package managers
Commit the UV-generated lockfile and verify it is kept up to date on dependency changes
Replace ad-hoc install commands in docs and scripts with the canonical UV command
Run a final install and test after migrating to UV to detect any platform-specific issues

Example use cases

Detecting npm or yarn commands in CI pipelines and replacing them with UV equivalents
Reviewing a pull request that adds an install script and ensuring it invokes UV
Scanning documentation and onboarding guides to update installation instructions to UV
Refactoring project build scripts to use UV for dependency installation and lockfile generation

FAQ

Why mandate UV instead of allowing multiple installers?

Mandating UV ensures a single source of truth for dependency resolution and lockfiles, reducing subtle differences between environments and preventing hard-to-debug issues that arise from mixed installers.

What if a dependency is incompatible with UV?

Document the incompatibility and create a short-lived exception with a migration plan. Prefer contributing fixes or using compatible alternatives so the project can return to a consistent UV-based workflow.