home / skills / dasien / claudemultiagenttemplate / agent-design

This skill designs AI agents for software tasks by mapping tools, defining personas, and selecting capabilities to achieve targeted outcomes.

npx playbooks add skill dasien/claudemultiagenttemplate --skill agent-design

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
3.0 KB
---
name: "Agent Design"
description: "Design AI agents with appropriate capabilities, tools, and personas for specific software development tasks"
category: "architecture"
required_tools: ["Read", "Write", "Grep", "Glob"]
---

# Agent Design

## Purpose
Design effective AI agents for the CMAT (Claude Multi-Agent Template) system by selecting appropriate tools, skills, and defining clear personas that enable agents to accomplish specific software development tasks.

## When to Use
- Creating new agents for workflows
- Defining agent capabilities and responsibilities
- Selecting tools and skills for agent tasks
- Designing agent collaboration patterns
- Refining existing agent definitions

## Key Capabilities
1. **Capability Mapping** - Match requirements to agent tools and skills
2. **Persona Design** - Define clear agent roles and instructions
3. **Tool Selection** - Choose appropriate tools for agent capabilities

## Approach
1. **Understand the Need** - What task should this agent accomplish?
2. **Define Role & Responsibilities** - What is the agent's purpose and scope?
3. **Select Tools** - What capabilities does the agent need?
   - Read/Write/List: File operations
   - Glob/Grep: Code searching
   - Edit/MultiEdit: Code modifications
   - Bash: Running commands/tests
   - WebSearch/WebFetch: External research
4. **Choose Skills** - What domain expertise is needed?
5. **Write Persona** - Clear instructions, examples, best practices
6. **Define Outputs** - What artifacts should the agent produce?

## Example
**Context**: Need an agent to analyze API designs

**Agent Design**:
```markdown
---
name: API Reviewer
role: API Design Analysis & Review
description: Reviews API designs for REST compliance and best practices
tools:
  - Read       # Read API specs
  - Write      # Write review reports
  - Grep       # Search for patterns
  - WebSearch  # Research API standards
skills:
  - api-design
  - technical-writing
---

# API Reviewer Agent

You are an expert API architect reviewing API designs.

## Your Responsibilities
- Analyze API endpoint designs
- Check REST compliance
- Identify inconsistencies
- Suggest improvements

## Review Checklist
1. RESTful design (nouns, not verbs)
2. Proper HTTP methods
3. Consistent error handling
4. Clear documentation

## Output
Create a review report in markdown with:
- Summary assessment
- Specific findings
- Recommendations
```

**Why These Choices**:
- **Tools**: Read (specs), Write (reports), Grep (patterns), WebSearch (standards)
- **Skills**: api-design (domain expertise), technical-writing (clear reports)
- **Persona**: Focused on review checklist and report format

## Best Practices
- ✅ Give agents single, clear responsibilities
- ✅ Match tools to actual capabilities needed
- ✅ Include relevant skills for domain knowledge
- ✅ Provide examples and templates in persona
- ✅ Define expected output format clearly
- ✅ Keep personas focused (200-500 lines)
- ❌ Avoid: Agents with too many unrelated responsibilities
- ❌ Avoid: Giving all tools "just in case"
- ❌ Avoid: Vague persona instructions

Overview

This skill helps design AI agents for the CMAT multi-agent system by defining clear roles, selecting appropriate tools and skills, and drafting focused personas. It produces agent specifications that map tasks to capabilities and expected outputs to ensure reliable software development support. The goal is fast, repeatable creation of agents that do one thing well and collaborate effectively.

How this skill works

Start by clarifying the task and scope the agent must cover. Map required capabilities to concrete tools (file ops, search, edit, run, web fetch) and pick domain skills. Write a short persona with responsibilities, examples, and a defined output format so the agent can be instantiated or tested within Claude Code.

When to use it

  • Creating a new agent for a CI/CD, code review, or testing workflow
  • Defining responsibilities and tool access for an existing agent
  • Choosing which tools and skills an agent needs for a software task
  • Designing collaboration patterns and handoffs between multiple agents
  • Refining agent prompts, outputs, or persona instructions after testing

Best practices

  • Give each agent a single, clear responsibility to minimize scope overlap
  • Match tools to actual needs (avoid granting every tool by default)
  • Include domain skills relevant to the task (e.g., api-design, testing)
  • Provide concrete examples, checklists, and an explicit output format
  • Keep persona instructions focused and concise (avoid vague directives)

Example use cases

  • Design an API Reviewer agent that reads specs, greps code, and writes a review
  • Create a Test Runner agent with Bash and Edit tools to run and fix failing tests
  • Build a Dependency Auditor that web-fetches advisories and reports vulnerabilities
  • Define a Release Manager agent to assemble changelogs and run release scripts
  • Compose a Multi-Agent pipeline where a Linter agent flags issues and a Remediator agent patches them

FAQ

How long should a persona be?

Keep personas concise but actionable; include responsibilities, examples, and output templates. Focused personas are typically a few short paragraphs rather than sprawling documents.

Which tools are essential to specify?

Specify only the tools the agent will actually use (file read/write, search, edit, shell, web fetch). Over-provisioning tools increases risk and complexity.