How to Supercharge Claude Code with 100 Specialized AI Agents

"The secret to building large apps is never build large apps. Break your applications into small pieces. Then, assemble those testable, bite-sized pieces into your big application." - Justin Meyer

Hey folks! If you've been using Claude Code for development work, you've probably experienced that moment where you wish Claude just knew your testing philosophy, or understood Kubernetes best practices without you explaining it every single time. That's the itch I've been scratching for months, and today I'm excited to share what came out of it.

Meet Claude Code Agents: a plugin marketplace I built with 100 specialized AI agents, 110 skills, and 76 development tools. Install only what you need, pay only the tokens you use. The project just crossed 24k stars on GitHub, so clearly I wasn't the only one with this problem.

The Problem I Kept Running Into

I love Claude Code. It's incredible out of the box. But after using it daily for months, I noticed the same friction points kept coming up:

• •Repeating myself: Every new session, I'd explain my Python testing approach, my preferred FastAPI patterns, my Kubernetes deployment philosophy
• •Token bloat: Loading a massive system prompt when I only needed help with one specific thing
• •Shallow expertise: Getting generic responses when I needed deep domain knowledge on Terraform or Helm charts
• •Manual orchestration: When building a feature, I'd manually prompt through the whole chain: architect the API, design the database, write the frontend, add tests, check security, set up deployment

I wanted specialized agents that load only when needed. So I built it.

What You Actually Get

Before diving into how to use it, here's what the toolkit includes:

• •68 Focused Plugins: Each does one thing well
• •100 Specialized Agents: Deep expertise in specific domains
• •110 Agent Skills: Knowledge that loads progressively (only when needed)
• •76 Development Tools: Scaffolding, testing, deployment automation

The key design principle: install only what you need. Each plugin loads around 300 tokens on average, not the entire marketplace.

Getting Started: Two Commands

Open Claude Code and run:

/plugin marketplace add wshobson/agents

This makes all 68 plugins available for browsing but doesn't load anything yet. Then browse what's available:

/plugin

Install what you need:

/plugin install python-development
/plugin install kubernetes-operations
/plugin install security-scanning

That's it. The agents are now available in your session.

Understanding the Plugin Structure

Here's something that confused me early on and I see others stumble on: you install plugins, not agents directly. Each plugin bundles related agents together.

# This won't work
/plugin install typescript-pro

# This works - install the plugin containing the agent
/plugin install javascript-typescript

Here's how some popular plugins map to their agents:

Each plugin also includes skills that load progressively. For example, python-development includes skills for async patterns, testing, packaging, performance optimization, and the UV package manager. These only load when the conversation needs them.

How I Actually Use This Daily

Let me show you some real workflows I use constantly.

Morning Code Review

When reviewing PRs, I install the comprehensive review plugin:

/plugin install comprehensive-review

Then I can invoke specific agents:

@architect-review "Review this PR for architectural concerns - focus on the new payment service"

@security-auditor "Check the authentication changes for vulnerabilities"

@code-reviewer "Review code quality and suggest improvements"

Each agent brings deep expertise. The security-auditor knows OWASP patterns, common vulnerabilities, and security best practices. The architect-review agent understands microservices patterns, API design, and system boundaries.

Building a New Feature End-to-End

This is where it gets powerful. I install the full-stack orchestration plugin:

/plugin install full-stack-orchestration

Then one command kicks off a multi-agent workflow:

/full-stack-orchestration:full-stack-feature "user authentication with OAuth2"

This automatically coordinates seven agents in sequence:

1. 1.backend-architect: Designs the API structure
2. 2.database-architect: Creates the schema
3. 3.frontend-developer: Builds UI components
4. 4.test-automator: Adds test coverage
5. 5.security-auditor: Checks for vulnerabilities
6. 6.deployment-engineer: Sets up CI/CD
7. 7.observability-engineer: Adds monitoring

No more manually prompting each step. The orchestrator handles handoffs between agents.

Python Project Setup

For new Python projects, I use the scaffolding command:

/plugin install python-development
/python-development:python-scaffold fastapi-microservice

This creates a production-ready FastAPI project and automatically activates relevant skills:

• •async-python-patterns for AsyncIO guidance
• •python-testing-patterns for pytest setup
• •uv-package-manager for fast dependency management

The skills provide deep context only when the conversation needs it. Asking about async patterns loads that skill; asking about deployment doesn't.

The Three-Tier Model Strategy

One thing I spent a lot of time on: not every task needs Opus. I configured agents with intelligent model assignment to balance cost and capability:

Tier 1 - Opus 4.5 (42 agents)
├── Architecture decisions
├── Security audits
├── Production code review
└── Language-specific experts (python-pro, typescript-pro, etc.)

Tier 2 - Inherit (42 agents)
├── AI/ML development
├── Frontend/mobile work
└── Uses your session's default model

Tier 3 - Sonnet 4.5 (51 agents)
├── Documentation
├── Testing
├── Debugging support

Tier 4 - Haiku 4.5 (18 agents)
├── SEO tasks
├── Simple docs
├── Deployment automation

For Tier 2 agents, you control the model by how you start your session:

claude --model opus    # Tier 2 agents use Opus
claude --model sonnet  # Tier 2 agents use Sonnet (default)

The orchestration workflows chain models intelligently: Opus for architecture decisions, then Sonnet for implementation, then Haiku for deployment tasks.

Plugins I Recommend Starting With

Here's what I'd install first depending on your work:

For most developers:

/plugin install debugging-toolkit        # Error analysis, smart debugging
/plugin install code-documentation       # Auto-generate docs
/plugin install git-pr-workflows         # Git automation, PR enhancement

For backend work:

/plugin install python-development       # Python/Django/FastAPI
/plugin install backend-development      # API design patterns
/plugin install database-design          # Schema optimization

For infrastructure:

/plugin install kubernetes-operations    # K8s, Helm, GitOps
/plugin install cloud-infrastructure     # AWS/Azure/GCP, Terraform
/plugin install cicd-pipelines           # GitHub Actions, GitLab CI

For security and quality:

/plugin install security-scanning        # SAST, vulnerability scanning
/plugin install comprehensive-review     # Multi-agent code review

Troubleshooting

A few issues I've seen people run into:

"Plugin not found"

You're probably trying to install an agent name instead of a plugin name. Run /plugin to see available plugins.

Plugins not loading after install

Clear the cache and reinstall:

rm -rf ~/.claude/plugins/cache/claude-code-workflows
rm ~/.claude/plugins/installed_plugins.json

Then run /plugin marketplace add wshobson/agents again.

Too many tokens being used

Uninstall plugins you're not actively using:

/plugin uninstall plugin-name

What's Next?

The project is open-source with 33+ contributors now. I use these agents daily for my own work and keep adding based on what I need.

Some areas I'm exploring:

• •More workflow orchestrators for common patterns
• •Specialized domain agents (healthcare, legal tech)
• •Deeper skill libraries
• •Better tooling for creating custom agents

If you've been following my work on MaverickMCP and Capital Companion, this fits into the same philosophy: build tools that make the daily work easier, automate the repetitive stuff, and let you focus on the interesting problems.

Give it a try and let me know what you build with it!

Get started:

/plugin marketplace add wshobson/agents

Star the repo: github.com/wshobson/agents