Agent Generation

Agent Generation for Project-Specific Teams

This skill provides the knowledge and templates needed to generate high-quality Claude Code agents that are experts on a specific codebase.

Core Principles

1. Project-Aware Agents

Generated agents must understand the specific project, not just general concepts:

• Reference actual file paths and directories from the project
• Mention specific frameworks, libraries, and versions used
• Include project-specific conventions and patterns
• Use terminology from the codebase (class names, module names, etc.)

2. Complementary Team Design

Each agent should have a distinct role without overlapping:

3. Strong Trigger Conditions

Each agent needs specific, non-overlapping trigger phrases:

whenToUse: |
  This agent should be used when the user asks about "React component patterns",
  "hook usage in this project", "state management with Redux", or needs help
  understanding how the frontend architecture works.

Agent Structure Template

Every generated agent follows this structure:

---
identifier: project-role-expert
whenToUse: |
  This agent should be used when... [specific triggers with project context]
systemPrompt: |
  [Comprehensive system prompt with project knowledge]
tools: [Glob, Grep, Read, Edit, Write, Bash, LS, Task, WebFetch, WebSearch]
color: "#hexcode"
model: sonnet
---

Analysis-to-Agent Mapping

Tech Stack Analysis

Analyze these files to identify tech stack:

• package.json, requirements.txt, Cargo.toml, go.mod
• Framework config files: next.config.js, vite.config.ts, django/​settings.py
• Build configs: tsconfig.json, webpack.config.js, babel.config.js

Generate agents for each major technology:

• One agent per primary framework (React, FastAPI, Django, etc.)
• Combined agents for related libraries (testing libraries together)

Architecture Analysis

Analyze these patterns:

• Directory structure depth and organization
• Module/​package boundaries
• Import patterns and dependencies
• Design patterns in use (MVC, Clean Architecture, etc.)

Generate architecture agent covering:

• Project structure and navigation
• Code organization conventions
• Module relationships
• Naming conventions

Domain Analysis

Analyze these elements:

• Data models and schemas
• API endpoints and routes
• Business logic modules
• Database migrations and queries

Generate domain agents for:

• Data model understanding
• API structure and contracts
• Business rule implementation

Color Palette for Agent Types

Use consistent colors by agent type:

Writing Effective System Prompts

Structure

1. Role Definition (1-2 sentences)

   You are an expert on the [Project Name] codebase, specializing in [domain].
   

2. Project Context (3-5 sentences)

   This project uses [tech stack]. The codebase is organized with [structure].
   Key directories include [paths]. The project follows [patterns/​conventions].
   

3. Expertise Areas (bullet list)

   Your expertise includes:
   - Specific area 1 with project context
   - Specific area 2 with file references
   - Specific area 3 with convention details
   

4. Guidance Principles (3-5 bullets)

   When helping:
   - Always reference existing patterns in [path]
   - Follow the [convention] established in [file]
   - Ensure consistency with [standard]
   

Include Project-Specific Knowledge

Always embed actual project details:

systemPrompt: |
  You are an expert on the **Acme Dashboard** React application.

  ## Project Overview
  This is a Next.js 14 application using the App Router. The codebase uses:
  - TypeScript with strict mode
  - Tailwind CSS for styling
  - React Query for server state
  - Zustand for client state

  ## Key Directories
  - `src/​app/` - Next.js app router pages
  - `src/​components/` - Reusable UI components
  - `src/​hooks/` - Custom React hooks
  - `src/​lib/` - Utility functions and API clients

  ## Conventions
  - Components use PascalCase: `UserProfile.tsx`
  - Hooks use camelCase with 'use' prefix: `useAuth.ts`
  - API routes follow REST conventions
  - All components have co-located test files

Example Triggers by Agent Type

Tech-Stack Expert Triggers

whenToUse: |
  This agent should be used when the user asks about "React patterns in this project",
  "how hooks are used here", "component architecture", "state management approach",
  "Next.js configuration", "TypeScript types", or needs help with frontend implementation
  following project conventions.

Architecture Expert Triggers

whenToUse: |
  This agent should be used when the user asks "where should I put this code",
  "how is the project organized", "what's the module structure", "how do imports work",
  "project conventions", "directory layout", or needs guidance on code organization
  and architectural decisions.

Domain Expert Triggers

whenToUse: |
  This agent should be used when the user asks about "user authentication flow",
  "how orders are processed", "data model relationships", "API endpoint structure",
  "business rules for [feature]", or needs understanding of domain-specific logic
  and data flows.

Dynamic Team Sizing

Determine team size based on project complexity:

Additional Resources

Reference Files

For detailed templates and examples:

• references/​agent-templates.md - Complete agent templates for each type
• references/​analysis-patterns.md - Patterns for codebase analysis

Example Files

Working examples in examples/:

• tech-stack-expert.md - Complete tech-stack agent example
• architecture-expert.md - Complete architecture agent example
• domain-expert.md - Complete domain agent example