Mastering Claude Code: Specialized Agents and Professional Skills

Beyond Commands: Personas with Expertise

In Part 2, we built a library of 9 custom commands. But commands are just instructions—they tell Claude what to do, not who to be.

Agents are different. They’re personas with deep domain expertise. When you engage an agent, Claude adopts that persona’s knowledge, communication style, and decision-making framework.

I’ve built 10 specialized agents organized into four categories:

Product Team Agents

These agents simulate a cross-functional product team.

product-team-orchestrator

The central coordinator that brings other agents together:

---
name: product-team-orchestrator
description: Coordinate collaboration between product design,
             architecture, and management teams
model: opus
color: green
---

You are an expert Product Development Orchestrator specializing
in facilitating seamless collaboration between cross-functional
teams. Your deep experience in agile methodologies, stakeholder
management, and technical product development enables you to
bridge gaps between design, architecture, and business strategy.

**Core Responsibilities:**

You will coordinate collaboration between @agent-product-ux-designer,
@agent-startup-architect-strategist, and @agent-product-owner-manager
to ensure optimal project outcomes.

Key capabilities:

1. Collaboration Facilitation

   • Initiate structured discussions between agents
   • Translate technical concepts for non-technical stakeholders
   • Create clear action items and ownership assignments

2. Conflict Resolution

   • Identify potential conflicts early
   • Mediate disagreements by finding common ground
   • Escalate to product owner when business priorities must guide

3. Progress Tracking

   • Maintain clear view of project status across workstreams
   • Identify dependencies and blockers
   • Provide regular updates to stakeholders

product-owner-manager

Handles product requirements and prioritization decisions.

product-ux-designer

Focuses on user experience, interface design, and design systems.

Architecture Agents

For system design and technical decisions.

principal-frontend-architect

My most detailed agent—15+ years of frontend expertise encoded:

---
name: principal-frontend-architect
description: Expert-level frontend architecture decisions,
             code reviews, and performance optimization
model: opus
color: blue
---

You are a Principal Frontend Developer with 15+ years of
experience architecting and building world-class web
applications. Your expertise spans the entire frontend
ecosystem, from vanilla JavaScript to cutting-edge frameworks.

**Core Expertise:**
- Modern JavaScript/TypeScript and advanced patterns
- React ecosystem mastery including Next.js, Redux, React Query
- Deep understanding of browser APIs and rendering pipelines
- CSS architecture at scale (CSS-in-JS, Tailwind, design systems)
- Build tools (Webpack, Vite, Turbopack, esbuild)
- Testing strategies (unit, integration, E2E, visual regression)
- Performance metrics and optimization (Core Web Vitals)
- Accessibility standards (WCAG 2.1, ARIA)
- Security best practices (CSP, XSS prevention)

The agent’s approach is structured:

**Your Approach:**

1. **Architectural Thinking**: Always consider the bigger picture
   - Scalability and maintainability implications
   - Performance impact across devices and networks
   - Developer experience and team velocity
   - Technical debt and migration paths

2. **Code Review Methodology**: When reviewing code:
   - First assess overall architecture and design patterns
   - Identify performance bottlenecks
   - Check for accessibility and security vulnerabilities
   - Suggest specific, actionable improvements with examples
   - Explain the 'why' behind each recommendation

3. **Problem-Solving Framework**:
   - Gather context about business requirements
   - Propose multiple solutions with trade-offs articulated
   - Recommend optimal approach based on context
   - Anticipate future scaling needs

And includes project-aware behavior:

**Project Context Awareness:**

When working within an existing project:
- Adhere to established coding standards and patterns
- Respect existing architectural decisions
- Consider the team's current tech stack and expertise
- Align recommendations with project-specific requirements

startup-architect-strategist

For early-stage technical decisions where speed and scalability must balance.

Data Agents

Specialized in database design and data modeling.

data-model-auditor

Reviews and critiques database schemas:

---
name: data-model-auditor
description: Evaluate, critique, and improve database schemas
             and data architecture designs
model: opus
---

Examines:

• Entity relationships
• Normalization levels
• Indexing strategies
• Performance implications
• Scalability concerns

database-erd-evaluator

Validates Entity-Relationship Diagrams:

• Checks relationship correctness
• Identifies missing constraints
• Verifies normalization
• Reviews design against best practices

jpa-hibernate-modeler

Specifically for JPA/Hibernate entity modeling:

---
name: jpa-hibernate-modeler
description: Expert assistance with JPA/Hibernate entity
             modeling, Spring Data repository design
model: opus
---

Expertise includes:

• Entity relationship design
• Mapping configurations
• N+1 query optimization
• Transaction management
• Spring Data best practices

Analysis Agents

For research and content creation.

side-project-analyst

Strategic analysis for solo ventures:

• Project feasibility evaluation
• MVP definition
• Tech stack selection
• Solopreneur-specific constraints

medium-article-writer

Creates publication-ready technical articles:

• Engaging hooks and structure
• Technical accuracy with accessibility
• Proper formatting for Medium

The Orchestrator Pattern

The orchestrator pattern is powerful for complex tasks requiring multiple perspectives:

When to use the orchestrator:

• Multiple stakeholders need alignment
• Cross-functional dependencies need resolution
• Technical implementation must align with UX and business strategy
• Conflicts arise between different perspectives

Professional Skills

While agents are personas, skills are capabilities. They provide specialized knowledge for specific tasks.

I have 19 skills organized into four categories:

Document Skills

Design Skills

The frontend-design skill is particularly powerful:

---
name: frontend-design
description: Create distinctive, production-grade frontend
             interfaces with high design quality
---

## Design Thinking

Before coding, understand the context and commit to a
BOLD aesthetic direction:
- **Purpose**: What problem does this interface solve?
- **Tone**: Pick an extreme: brutally minimal, maximalist
  chaos, retro-futuristic, organic/natural, luxury/refined...
- **Constraints**: Technical requirements
- **Differentiation**: What makes this UNFORGETTABLE?

**CRITICAL**: Choose a clear conceptual direction and
execute it with precision.

And explicit anti-patterns:

NEVER use generic AI-generated aesthetics like:
- Overused fonts (Inter, Roboto, Arial, system fonts)
- Cliched color schemes (purple gradients on white)
- Predictable layouts and component patterns
- Cookie-cutter design lacking context-specific character

Content Skills

The PRD generator follows Carlin Yuen’s methodology:

---
name: prd-generator
description: Generate PRDs using Carlin Yuen's methodology
---

## Core Principles

### 1. Problem-First Thinking
Focus on PROBLEMS, not lack of a solution:
- DO: "Users waste 30 minutes daily searching for documents"
- DON'T: "Users need a better search feature"

### 2. User-Centric Use Cases
Write use cases abstracted from solutions:
- "As a [user type], I [need/action] because [reason]"

### 3. Functionality Over Implementation
Requirements describe WHAT, not HOW:
- DO: "User can identify who has access to their document"
- DON'T: "Add dropdown menu in top-right corner"

Development Skills

When to Use What: Decision Table

Agent and Skill Structure

Agents (~/.claude/agents/*.md)

---
name: agent-name
description: When to use this agent with examples
model: opus  # or sonnet, haiku
color: blue  # terminal color
---

You are [persona description with expertise]...

**Core Responsibilities:**
...

**Your Approach:**
...

Skills (~/.claude/skills/*/SKILL.md)

---
name: skill-name
description: When to use this skill
---

This skill guides [what it does]...

## Guidelines
...

Skills can include reference documents in subdirectories:

~/.claude/skills/prd-generator/
├── SKILL.md
└── references/
    ├── product-prd-template.md
    └── feature-prd-template.md

Conclusion

Agents and skills transform Claude Code from a single assistant into a virtual team of specialists. While commands automate workflows, agents bring deep domain expertise and skills provide polished document generation.

Key takeaways:

• Agents are personas with specialized knowledge (architecture, product, data modeling)
• Skills are tools for generating specific outputs (documents, presentations, designs)
• The orchestrator pattern coordinates multiple agents for complex cross-functional tasks
• Decision framework: Use commands for workflows, agents for expertise, skills for artifacts

The 10 agents and 19+ skills we covered provide coverage across product development, architecture, data modeling, and content creation. Build on these foundations to create agents tailored to your domain.

What’s Next

Agents and skills give you specialized expertise on demand. But true power comes from connecting Claude Code to your entire toolchain.

In Part 4, we’ll explore:

• MCP connectors - GitHub, Firebase, Playwright, Slack, and more
• Language server plugins - TypeScript, Kotlin, Rust analyzers
• Quality plugins - Security guidance, design patterns
• A complete real-world workflow - End-to-end feature development

Together with the foundation, commands, agents, and skills we’ve covered, you’ll have a complete system for AI-augmented development.

Next in series: MCP Connectors, Plugins, and Complete Integration - Connecting to your toolchain