Back to Workflow & Productivity

developer-toolbox

workflowcodingautomationdevelopmentcode reviewdebuggingtestingdocumentation
⭐ 860πŸ“„ MITπŸ•’ 2026-06-11Source β†—

Install this skill

npx skills add jezweb/claude-skills

Works 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

  1. Identify a technical debt area in the codebase
  2. Call the code-reviewer to perform a security audit
  3. Invoke the test-runner to identify failing coverage paths
  4. Use the debugger to trace the root cause of failures
  5. Execute the documentation-expert to update API specs
  6. 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 do I install the toolbox?
You can install it via the marketplace using /plugin install developer-toolbox or directly from the local directory.
Can I modify how these agents behave?
Yes, you can edit the markdown files located in your ~/.claude/plugins/cache/ directory to customize agent logic.
What is the agent-first-thinking rule?
It is a mandatory rule that forces you to pause before doing manual tasks to check if an agent could handle the request more efficiently.
Do these agents work in parallel?
Yes, they are designed to be chained or used as a swarm, such as running a reviewer followed by a test generator.

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.

Source & trust

⭐ 860 starsπŸ“„ MITπŸ•’ Updated 2026-06-11
πŸ“„ Full skill instructions β€” original source: jezweb/claude-skills
# Developer Toolbox

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-toolbox


After 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-fragment


This 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)

  1. Click "Download" above
  2. In your project, create the directory: .agent/skills/developer-toolbox/
  3. Save the file as SKILL.md
  4. 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

Read the Master Guide: Mastering Agent Skills β†’

Recommended Rules

View more rules β†’

Recommended Workflows

View more workflows β†’

Recommended MCP Servers

View more MCP servers β†’

Take It Further

Maximize your productivity with these powerful resources

πŸ“‹

Define Your Standards

Set up coding standards to ensure this workflow produces consistent, high-quality results.

Browse Rules Library
πŸ“–

Master Workflows

Learn how to create custom workflows, use Turbo Mode, and build your automation library.

Complete Guide

How to use this Skill in Claude Code & Cursor

For Claude Code (CLI)

To use this skill in Claude Code, copy the rule content into your project's custom instructions or follow our Add-Skill CLI guide. This ensures Claude follows your standards during every code generation.

For Cursor & Windsurf

For Cursor or Windsurf, individual skills are best used in the "Rules for AI" section. This specific unit helps the agent avoid workflow & productivity issues, leading to cleaner, more efficient code.

Why the skill format matters: the standardized Agent Skills format lets your AI agent load detailed instructions only when they are relevant, keeping your prompt clean while improving results.

Source & attribution

This skill is categorized under Workflow & Productivity and is published by JezWeb, maintained in jezweb/claude-skills.

← Browse All Agent Skills
Sponsored AI assistant. Recommendations may be paid.