Stop Writing Generic Prompts! 147 AI Agents That Actually Deliver

Your AI assistant just gave you another soulless, cookie-cutter response—and you're wondering why you even bothered. Here's the brutal truth: generic prompts produce generic results. That "Act as a senior developer" line you've been copy-pasting? It's the equivalent of hiring a random person off the street and calling them your CTO.

But what if you could assemble an entire specialized agency—frontend wizards who obsess over Core Web Vitals, Reddit ninjas who understand community nuance, security engineers who default to threat modeling, and whimsical designers who measure delight in reduced task-completion anxiety? What if each team member arrived with proven workflows, measurable deliverables, and a personality that doesn't put you to sleep?

That's exactly what agency-agents delivers. Born from a viral Reddit thread and refined through months of real-world battle testing, this collection of 147 meticulously crafted AI agent personalities transforms how developers, marketers, product teams, and creators collaborate with AI. No more bland templates. No more vague guidance. Just specialized experts who actually know their craft—and prove it with every interaction.

Ready to fire your generic prompts forever? Let's dive into the agency that never sleeps, never complains, and always ships.

What Is agency-agents?

agency-agents is a meticulously curated open-source repository containing 147 specialized AI agent personalities designed for seamless integration with Claude Code and 10+ other AI coding tools. Created by Michał Sitarzewski and nurtured by a global community of contributors, this project started as a simple Reddit discussion about AI specialization—and exploded into a comprehensive agency framework that developers and teams now depend on daily.

The repository's philosophy is deceptively simple yet profoundly different from typical prompt libraries: every agent is a complete specialist with identity, not a template with instructions. Each personality file contains deep domain expertise, distinctive communication style, concrete deliverables with code examples, step-by-step workflows, and measurable success metrics. The Frontend Developer doesn't just "know React"—it obsesses over pixel-perfect implementations, proactively suggests performance optimizations, and communicates with the confident precision of someone who's shipped production apps for years.

What makes agency-agents genuinely trend-worthy is its production-ready maturity. These aren't theoretical constructs. The repository contains 10,000+ lines of personality definitions, process documentation, and executable code examples. The agents have been iterated based on real usage feedback, with 50+ requests flooding in within the first 12 hours of the original Reddit post. The project now spans 12 specialized divisions covering engineering, design, marketing, sales, product management, testing, support, spatial computing, finance, game development, academia, and niche specialized roles.

Crucially, agency-agents embraces multi-tool flexibility. While optimized for Claude Code's native .md agent format, the repository ships intelligent conversion scripts that transform these personalities for GitHub Copilot, Cursor, Aider, Windsurf, Gemini CLI, OpenCode, OpenClaw, Qwen Code, and Kimi Code. This isn't vendor lock-in—it's genuine workflow freedom.

Key Features That Separate Amateurs from Pros

🎯 Hyper-Specialized Domain Expertise

Forget "full-stack developer" vagueness. The Engineering Division alone contains 27 distinct roles—from Filament PHP optimization specialists to Solidity smart contract engineers, from embedded firmware experts working bare-metal on ESP32 to incident response commanders managing production outages. Each agent possesses granular knowledge appropriate to their seniority and focus area.

🧠 Authentic Personality Architecture

Every agent communicates with distinctive voice and behavioral patterns. The Whimsy Injector speaks in playful metaphors while rigorously defending functional purpose: "Every playful element must serve a functional or emotional purpose. Design delight that enhances rather than distracts." The Evidence Collector demands visual proof for every claim: "I don't just test your code—I default to finding 3-5 issues and require visual proof for everything." These aren't decorative flourishes; they shape how the AI reasons and responds.

📋 Deliverable-Centric Design

Each agent file specifies concrete outputs: code examples with proper syntax, process documentation with decision trees, success metrics with measurable thresholds. The Backend Architect doesn't vaguely "design APIs"—it produces OpenAPI specifications, database schema diagrams, and scalability calculations with specific RPS targets.

✅ Battle-Tested Workflows

Agents include step-by-step processes refined through actual use. The Reddit Community Builder follows a specific engagement protocol: "You're not marketing on Reddit—you're becoming a valued community member who happens to represent a brand." This philosophical foundation drives tactical decisions about posting frequency, comment depth, and value-first content creation.

🔌 Universal Tool Integration

The convert.sh and install.sh scripts automatically generate appropriate formats for every supported tool. Claude Code gets native .md files; Cursor receives .mdc rule files; Aider compiles everything into a single CONVENTIONS.md; Windsurf produces .windsurfrules. The installer even auto-detects your installed tools and presents an interactive checkbox UI.

🌐 Community-Driven Expansion

With community translations including 141 Chinese-localized agents plus 46 China-market originals, the project demonstrates genuine global adoption. The maintainer actively acknowledges contributors: "Every agent in this repo exists because someone cared enough to write it, test it, and share it."

Real-World Use Cases Where These Agents Dominate

🚀 Startup MVP Sprint

The Challenge: You need to ship a minimum viable product in two weeks with limited budget and zero full-time hires.

Your Agency Team:

• Frontend Developer: Builds React components with performance budgets, implements responsive designs with accessibility considerations
• Backend Architect: Designs RESTful APIs with proper versioning, selects database technology based on query patterns, documents deployment architecture
• Rapid Prototyper: Accelerates iteration cycles with quick proof-of-concepts, validates technical assumptions before full implementation
• Growth Hacker: Structures user acquisition experiments, identifies viral loop opportunities, sets up analytics instrumentation
• Reality Checker: Establishes quality gates, verifies production readiness criteria, prevents premature launches

The Result: Coordinated specialization without coordination overhead. Each agent understands their boundaries and handoff points. The Frontend Developer doesn't overstep into API design; the Backend Architect defers to the Growth Hacker on analytics schema decisions.

📢 Multi-Platform Marketing Campaign

The Challenge: Launch coordinated presence across Twitter, Instagram, Reddit, and emerging platforms with authentic voice adaptation per channel.

Your Agency Team:

• Content Creator: Develops editorial calendar with platform-appropriate content variants
• Twitter Engager: Executes real-time engagement strategy, monitors trending conversations, builds thought leadership positioning
• Instagram Curator: Crafts visual storytelling sequences, optimizes posting times based on audience behavior patterns
• Reddit Community Builder: Navigates subreddit-specific norms, contributes genuine value before any promotional content, builds long-term community trust
• Analytics Reporter: Tracks cross-platform performance, identifies content resonance patterns, recommends budget reallocation

The Result: Platform-native expertise prevents embarrassing misfires. The Reddit agent knows that r/programming despises obvious marketing; the Instagram agent understands carousel sequencing for maximum retention.

🏛️ Enterprise Feature Development

The Challenge: Deliver complex functionality through established engineering processes with quality documentation and measurable outcomes.

Your Agency Team:

• Senior Project Manager: Converts ambiguous requirements into structured tasks with realistic scope boundaries
• Software Architect: Evaluates domain-driven design patterns, models system evolution strategy, documents trade-off analyses
• UI Designer: Extends existing design system, ensures component consistency, validates accessibility compliance
• Experiment Tracker: Designs A/B test protocols, defines hypothesis validation criteria, structures measurement frameworks
• Code Reviewer: Provides constructive feedback with security and maintainability focus, mentors through review comments
• Evidence Collector: Documents quality verification with screenshot evidence, maintains visual proof for all claims

The Result: Enterprise-grade discipline without enterprise-grade bureaucracy. Each agent's success metrics align with organizational standards while maintaining individual specialization depth.

💰 Paid Media Account Recovery

The Challenge: Rescue underperforming advertising accounts with systematic diagnosis and reconstruction.

Your Agency Team:

• Paid Media Auditor: Executes 200+ point account assessment, identifies structural weaknesses, benchmarks against competitive landscape
• Tracking & Measurement Specialist: Verifies conversion tracking accuracy, implements server-side tracking where needed, validates attribution models
• PPC Campaign Strategist: Rebuilds account architecture with proper campaign/ad group hierarchy, implements portfolio bidding strategies
• Search Query Analyst: Eliminates wasted spend through negative keyword expansion, maps search intent to appropriate landing experiences
• Ad Creative Strategist: Refreshes responsive search ad copy, develops Performance Max asset groups, designs creative testing roadmaps

The Result: Systematic 30-day turnaround with verified tracking, eliminated waste, optimized structure, and refreshed creative—all documented with before/after performance metrics.

Step-by-Step Installation & Setup Guide

Prerequisites

You'll need:

• Git for cloning the repository
• Bash environment (Linux, macOS, or WSL on Windows)
• Claude Code installed (for primary integration), or any supported alternative

Step 1: Clone the Repository

# Clone the complete agency repository
git clone https://github.com/msitarzewski/agency-agents.git
cd agency-agents

Step 2: Quick Install for Claude Code (Recommended)

# Install all agents to your Claude Code directory with one command
./scripts/install.sh --tool claude-code

This copies all agent .md files to ~/.claude/agents/, making them immediately available in Claude Code sessions.

Step 3: Selective Installation by Division

# Install only Engineering Division agents if you're focused on development
cp engineering/*.md ~/.claude/agents/

# Or install multiple specific divisions
cp engineering/*.md design/*.md ~/.claude/agents/

Step 4: Multi-Tool Setup (Advanced)

For teams using multiple AI coding tools, generate and install across all platforms:

# Step 1: Generate integration files for ALL supported tools
./scripts/convert.sh

# Faster parallel generation on multi-core machines:
# ./scripts/convert.sh --parallel

# Step 2: Interactive installation with auto-detection
./scripts/install.sh

The interactive installer scans your system and presents detected tools:

  +------------------------------------------------+
  |   The Agency -- Tool Installer                 |
  +------------------------------------------------+

  System scan: [*] = detected on this machine

  [x]  1)  [*]  Claude Code     (claude.ai/code)
  [x]  2)  [*]  Copilot         (~/.github + ~/.copilot)
  [ ]  3)  [ ]  Antigravity     (~/.gemini/antigravity)
  [x]  7)  [*]  Cursor          (.cursor/rules)
  ...

  [1-11] toggle   [a] all   [n] none   [d] detected
  [Enter] install   [q] quit

Step 5: Tool-Specific Direct Installation

# Target specific tools directly without interactive mode
./scripts/install.sh --tool cursor           # Cursor IDE rules
./scripts/install.sh --tool aider            # Aider conventions
./scripts/install.sh --tool windsurf         # Windsurf rules
./scripts/install.sh --tool opencode         # OpenCode agents
./scripts/install.sh --tool antigravity      # Gemini Antigravity skills

Step 6: Post-Installation Verification

Activate any agent in your Claude Code session:

Hey Claude, activate Frontend Developer mode and help me build a React component

Or reference agents contextually:

Use the Security Engineer agent to review this authentication flow

Environment Setup for CI/CD Pipelines

# Non-interactive installation for automated environments
./scripts/install.sh --no-interactive --tool all

# Parallel processing for faster CI builds
./scripts/install.sh --no-interactive --parallel --jobs 4

REAL Code Examples from the Repository

The repository's power lies in executable specificity. Here are authentic examples demonstrating how agents translate personality into practice.

Example 1: Claude Code Quick Start Installation

The simplest path to agency deployment uses the native shell script:

# Install all agents to your Claude Code directory
./scripts/install.sh --tool claude-code

# Or manually copy a category if you only want one division
cp engineering/*.md ~/.claude/agents/

# Then activate any agent in your Claude Code sessions:
# "Hey Claude, activate Frontend Developer mode and help me build a React component"

What's happening here? The script handles directory creation, file permissions, and validation. The manual cp alternative shows the underlying simplicity—agents are just well-structured Markdown files that Claude Code reads as system prompts. The comment demonstrates natural language activation; no special syntax required.

Example 2: Multi-Tool Conversion Pipeline

For teams with heterogeneous tool environments, the conversion system generates appropriate formats automatically:

# Step 1 -- generate integration files for all supported tools
./scripts/convert.sh

# Step 2 -- install interactively (auto-detects what you have installed)
./scripts/install.sh

# Or target a specific tool directly
./scripts/install.sh --tool antigravity
./scripts/install.sh --tool gemini-cli
./scripts/install.sh --tool opencode
./scripts/install.sh --tool copilot
./scripts/install.sh --tool openclaw
./scripts/install.sh --tool cursor
./scripts/install.sh --tool aider
./scripts/install.sh --tool windsurf
./scripts/install.sh --tool kimi

The technical insight: Each tool has distinct agent formats. Claude Code uses flat .md files; Cursor requires .mdc with YAML frontmatter; Aider expects a single consolidated CONVENTIONS.md; Kimi Code needs YAML agent specifications. The convert.sh script handles these transformations while preserving each agent's personality architecture, critical rules, and deliverable specifications. This abstraction layer prevents vendor lock-in and enables tool migration without re-crafting prompts.

Example 3: Parallel Processing for Scale

Performance-conscious users can accelerate generation and installation:

# Faster (parallel, output order may vary): ./scripts/convert.sh --parallel

# Parallel installation with job control
./scripts/convert.sh --parallel                    # convert all tools in parallel
./scripts/convert.sh --parallel --jobs 8           # cap parallel jobs
./scripts/install.sh --no-interactive --parallel   # install all detected tools in parallel
./scripts/install.sh --interactive --parallel      # pick tools, then install in parallel
./scripts/install.sh --no-interactive --parallel --jobs 4

Why this matters: With 147 agents and 11 target formats, sequential processing becomes a bottleneck. The --parallel flag distributes work across CPU cores, with automatic detection via nproc (Linux) or sysctl -n hw.ncpu (macOS), defaulting to 4 cores. The --jobs parameter provides explicit control for resource-constrained environments. Note the honest documentation that "output order may vary"—this transparency about non-determinism builds trust with technical users who need to understand system behavior.

Example 4: Non-Interactive CI/CD Deployment

For automated environments where human interaction isn't possible:

# Non-interactive (CI/scripts):
./scripts/install.sh --no-interactive --tool all

Production consideration: The --no-interactive flag suppresses the checkbox UI and proceeds with installation based on provided parameters. Combined with --tool all, this ensures complete coverage in automated pipelines. For more selective CI deployment, specify exact tools: --tool claude-code --tool cursor. The script exits with appropriate status codes for success/failure, enabling proper pipeline error handling.

Example 5: Agent Activation Patterns

Once installed, agents integrate seamlessly into natural workflows:

# Direct personality activation
Use the Frontend Developer agent to review this component.

# Contextual role assignment
@agency-frontend-developer review this React component

# Rule-based reference in Cursor
Use the @security-engineer rules to review this code.

# Aider's consolidated convention reference
Use the Frontend Developer agent to refactor this component.

The interaction design: Different tools support different activation patterns. Claude Code uses natural language mentions; Antigravity uses @ prefixes with slugified names; Cursor leverages @ rule references; Aider's single-file consolidation requires explicit agent naming. The repository documents all patterns, ensuring users don't struggle with "right syntax" questions and can focus on productive work.

Advanced Usage & Best Practices

🎯 Compose Multi-Agent Teams for Complex Projects

The Nexus Spatial Discovery Exercise demonstrates orchestrating 8 agents simultaneously: Product Trend Researcher, Backend Architect, Brand Guardian, Growth Hacker, Support Responder, UX Researcher, Project Shepherd, and XR Interface Architect. Each contributes their specialization to a unified product plan covering market validation, technical architecture, brand strategy, go-to-market, support systems, UX research, project execution, and spatial UI design.

🔄 Regenerate After Customization

When you modify agent files or add new specialists, regenerate all integration files:

./scripts/convert.sh                    # regenerate all (serial)
./scripts/convert.sh --parallel         # faster parallel generation
./scripts/convert.sh --tool cursor      # regenerate just one tool's format

🧪 Fork and Specialize for Your Organization

The MIT license permits commercial modification. Consider creating organization-specific variants:

• Add proprietary technology stacks to Engineering agents
• Inject company brand voice guidelines into Marketing specialists
• Include internal compliance requirements in Security and Legal agents
• Build division-specific onboarding sequences

📊 Measure Agent Effectiveness

Each agent includes success metrics. Track whether deliverables meet stated standards:

• Does the Frontend Developer consistently suggest performance optimizations?
• Does the Evidence Collector actually provide visual proof?
• Does the Reddit Community Builder maintain authentic voice without promotional overreach?

🌐 Contribute Back to Community

Follow the established template when proposing new agents:

• Frontmatter with name, description, color
• Identity & Memory section
• Core Mission with measurable scope
• Critical Rules (domain-specific guardrails)
• Technical Deliverables with executable examples
• Workflow Process with decision trees
• Success Metrics with quantifiable thresholds

Comparison with Alternatives

Why agency-agents wins: Generic libraries give you "a developer prompt." Built-in tools give you "whatever the model knows." agency-agents gives you a specific senior frontend engineer who defaults to React Server Components, proactively checks Core Web Vitals, and communicates with confident precision—then lets you deploy that personality across every tool your team uses.

FAQ: What Developers Actually Ask

Q: Do I need Claude Code specifically, or will these work with other AI assistants?

A: While optimized for Claude Code, the repository supports 11 major tools including GitHub Copilot, Cursor, Aider, Windsurf, Gemini CLI, OpenCode, OpenClaw, Qwen Code, and Kimi Code. The convert.sh script handles all format transformations automatically.

Q: How do these differ from just writing better prompts?

A: Individual prompts are ephemeral and inconsistent. agency-agents provides persistent, version-controlled personalities with structured identity, proven workflows, and measurable deliverables. It's the difference between hiring a contractor for a task and building a specialized team with institutional memory.

Q: Can I modify agents for my specific technology stack?

A: Absolutely. The MIT license permits unrestricted modification. Most teams fork the repository and add proprietary frameworks, internal conventions, and company-specific success metrics while maintaining the original personality architecture.

Q: How do I handle agent conflicts when using multiple specialists simultaneously?

A: The Agents Orchestrator specialist exists specifically for this purpose. For simpler scenarios, clearly scope each agent's responsibility in your activation prompt. The agents are designed with boundary awareness—they know when to defer to specialists.

Q: Are these suitable for non-technical teams?

A: Yes. Divisions cover Marketing, Sales, Design, Product Management, Project Management, and Support—requiring no coding knowledge. The Finance, Legal, and Healthcare specialists serve highly regulated industries with compliance-aware workflows.

Q: How frequently is the repository updated?

A: Active development continues with community contributions. The roadmap includes an interactive agent selector web tool, video tutorials, community marketplace, and personality quiz for project matching. Check GitHub Discussions for latest activity.

Q: What's the performance impact of loading many agents?

A: Agents are lazy-loaded—you only activate specific personalities in conversations. The underlying files are lightweight Markdown; storage overhead is negligible. Conversion scripts run once per modification, not per usage.

Conclusion: Your AI Agency Awaits

The era of generic AI interactions is ending. What started as a Reddit thread about making AI assistants more useful has evolved into 147 specialized personalities that transform how technical and creative work gets done. The agency-agents repository represents something rare in the AI tooling landscape: genuine open-source infrastructure that improves with community contribution rather than vendor dictate.

I've watched countless developers struggle with inconsistent AI outputs, burning hours refining the same prompt templates while never achieving reliable quality. The agency model solves this fundamentally—by investing once in well-crafted specialist definitions, you compound productivity gains across every subsequent project. Your "Frontend Developer" remembers optimal patterns. Your "Security Engineer" consistently flags the vulnerabilities others miss. Your "Reddit Community Builder" never forgets that authenticity beats promotion.

The installation takes minutes. The first activated agent demonstrates immediate difference. The long-term impact reshapes how you think about AI collaboration entirely.

⭐ Star the repository to follow development, 🍴 fork it to build your custom agency, and 💬 join the discussions to share what your dream team delivers.

Your AI specialists are hired. They're trained. They're ready to ship. What will you build first?