developer-toolbox
Install this skill
npx skills add jezweb/claude-skillsWorks across Claude Code, Cursor, Codex, Copilot & Antigravity
The Developer Toolbox provides a curated set of seven specialized agents that integrate directly with your Claude Code workflow. Instead of manually navigating complex development tasks, these agents focus on repetitive, high-friction areas such as testing, debugging, code review, and documentation. Each agent follows a specific discovery pattern that prompts Claude to suggest the right tool based on your current request, rather than requiring you to hunt for scripts. The bundle also includes an 'agent-first-thinking' rule, which forces a shift in how you approach development, pushing you to delegate repetitive operations to these agents before attempting manual shell commands or file edits. This setup reduces token waste during file exploration and creates a structured path for handling multi-step tasks across large codebases.
When to Use This Skill
- β’Ensuring production builds accurately reflect the latest source code updates
- β’Automatically drafting meaningful commit messages for complex staging areas
- β’Running systematic TDD loops when developing new functional requirements
- β’Reviewing authentication logic for common security vulnerabilities
- β’Documenting newly created REST endpoints without manual drafting
How to Invoke This Skill
Example prompts that trigger this skill in Claude Code, Cursor, or Antigravity:
- βverify why my changes are missing in the build
- βreview this code for security vulnerabilities
- βhelp me write a conventional commit message
- βdebug this TypeError in the validation service
- βcoordinate an auth refactor across these services
Pro Tips
- π‘Leverage the 'orchestrator' agent for any task involving multiple steps or complex feature implementations to ensure a structured approach.
- π‘Integrate 'agent-first-thinking' into your workflow by consciously considering if an agent can assist before diving into manual work.
- π‘Utilize specific triggers listed for each agent (e.g., 'security audit' for code-reviewer) to quickly invoke the most relevant helper.
What this skill does
- β’Automates conventional commit message formatting based on staged changes
- β’Validates production build outputs against source files to detect sync issues
- β’Performs security-focused audits and quality checks using OWASP standards
- β’Coordinates complex multi-service refactoring through a central orchestrator
- β’Generates documentation for READMEs, APIs, and project architecture
When not to use it
- βOne-off tasks involving only a single file or simple operation
- βCreative coding work requiring constant, high-level human intuition
- βHighly specific workflows with complex external dependency constraints
Example workflow
- Identify a technical debt area in the codebase
- Call the code-reviewer to perform a security audit
- Invoke the test-runner to identify failing coverage paths
- Use the debugger to trace the root cause of failures
- Execute the documentation-expert to update API specs
- Finish with commit-helper to log the final changes
Prerequisites
- βClaude Code installed and configured
- βAccess to the jezweb/claude-skills repository
Pitfalls & limitations
- !Over-reliance on agents for simple tasks may increase cost unnecessarily
- !Agent markdown files require manual updates if you need to change logic
- !Behavioral interrupts can slow down trivial, one-line code edits
FAQ
How it compares
Unlike generic prompting which requires manual instruction for every step, these agents are pre-configured to detect specific triggers and context, effectively automating the 'planning' phase of your dev task.
π Full skill instructions β original source: jezweb/claude-skills
A collection of essential development workflow agents that integrate seamlessly with Claude Code.
## What's Included
### Agents (7)
| Agent | Purpose | Triggers On |
|-------|---------|-------------|
| **commit-helper** | Generate conventional commit messages | "commit message", "staged changes" |
| **build-verifier** | Verify dist/ matches source after builds | "changes not appearing", "verify build" |
| **code-reviewer** | Security audits and code quality reviews | "code review", "security audit", "OWASP" |
| **debugger** | Systematic debugging with root cause analysis | "error", "TypeError", "stack trace", "bug" |
| **test-runner** | TDD workflow and test creation | "write tests", "TDD", "coverage", "jest" |
| **orchestrator** | Coordinate complex multi-step projects | "coordinate", "multi-step", "complex feature" |
| **documentation-expert** | README, API docs, architecture diagrams | "document", "README", "API docs" |
### Rules (1)
| Rule | Purpose |
|------|---------|
| **agent-first-thinking** | Behavioral interrupt - consider agents before manual work |
## Installation
# Via marketplace
/plugin install developer-toolbox
# Or local development
/plugin install ./skills/developer-toolboxAfter installation, restart Claude Code to load the agents.
## Usage Examples
### Commit Helper
"Help me write a commit message for these staged changes"### Build Verifier
"My changes aren't appearing in production, verify the build output"### Code Reviewer
"Review this authentication code for security vulnerabilities"### Debugger
"I'm getting TypeError: Cannot read property 'map' of undefined"### Test Runner
"Use TDD to implement this user validation function"### Orchestrator
"Coordinate a refactor of the authentication system across 5 services"### Documentation Expert
"Create comprehensive API documentation for this REST endpoint"## Agent Design Philosophy
All agents follow the **"MUST BE USED when"** pattern for reliable auto-discovery:
description: |
[Role] specialist. MUST BE USED when: [trigger 1], [trigger 2], [trigger 3].
Use PROACTIVELY for [broad task category].
Keywords: keyword1, keyword2, error-message-fragmentThis ensures Claude Code discovers and proposes the right agent automatically based on user requests.
## Agent-First Thinking Rule
The included
agent-first-thinking.md rule encourages using agents by default:**The Inversion:**
- Wrong: "I'll do this manually unless it's big enough for agents"
- Right: "I'll use agents unless there's a reason not to"
**Triggers:**
| If about to... | Use instead... |
|----------------|----------------|
| grep/glob 3+ times | Explore agent |
| Read 5+ files | Explore agent |
| Same edit across files | Parallel agents |
| Audit multiple items | Parallel swarm |
## Customization
Each agent can be extended by editing its markdown file after installation:
# Find installed agents
ls ~/.claude/plugins/cache/*/developer-toolbox/*/agents/
# Or copy to user-level for customization
cp [plugin-path]/agents/code-reviewer.md ~/.claude/agents/## Combining Agents
Agents work well together:
"Review this code for security issues, then write tests for the critical paths"
# β code-reviewer first, then test-runner"Debug this failing test, document the root cause, and commit the fix"
# β debugger β documentation-expert β commit-helper## Version History
- **1.0.0** (2025-01-20): Initial release with 7 agents and 1 rule
---
---
description: Behavioral interrupt - consider agents before manual work
alwaysApply: true
---
# Agent-First Thinking
## The Rule
**Before doing repetitive or multi-step manual work, ask: "Could agents do this?"**
This is a behavioral interrupt, not a suggestion.
## Triggers (STOP When You Notice These)
| If you're about to... | STOP and consider... |
|-----------------------|----------------------|
|
grep or glob 3+ times | Explore agent || Read 5+ files to understand something | Explore agent |
| Do same edit across multiple files | Parallel agents |
| Audit/verify multiple items | Parallel swarm |
| Research multiple options | Parallel research |
## The Inversion
β Wrong mental model: "I'll do this manually unless it's big enough for agents"
β Right mental model: "I'll use agents unless there's a reason not to"
## Quick Decision
Is this a single, one-off action?
YES β Do it manually
NO β Use agents## Why This Matters
Manual grep/read loops waste tokens and time. Each back-and-forth costs ~500 tokens. An Explore agent does it in one call with better results.
Measured: 70 skill audits took 3 minutes with agents vs ~70 minutes manually.
## When Agents DON'T Fit
Only skip agents when:
- **Single, one-off action** - One file, one search, one edit
- **Real-time creative direction** - Needs constant human input
- **Cross-item dependencies** - Items depend on each other's results
How to Use This Skill Unit
Option A: Project-Specific (Recommended)
- Click "Download" above
- In your project, create the directory:
.agent/skills/developer-toolbox/ - Save the file as
SKILL.md - The agent will automatically discover the skill based on its description.
Option B: Global Installation (All Agents)
Save the file to these locations to make it available across all projects:
- Claude Code:
~/.claude/skills/jezweb/claude-skills/developer-toolbox/SKILL.md - Cursor:
~/.cursor/skills/jezweb/claude-skills/developer-toolbox/SKILL.md - Antigravity:
~/.gemini/antigravity/skills/jezweb/claude-skills/developer-toolbox/SKILL.md
π Install with CLI:npx skills add jezweb/claude-skills
