【LLMs篇】20：Claude Code 智能代理完全使用手册

最新推荐文章于 2025-08-25 23:42:58 发布

原创最新推荐文章于 2025-08-25 23:42:58 发布 · 485 阅读

17 ·

CC 4.0 BY-SA版权

文章标签：

#人工智能 #机器人

日常随记同时被 3 个专栏收录

87 篇文章

订阅专栏

LLMs

32 篇文章

订阅专栏

工程技巧

14 篇文章

订阅专栏

在这里插入图片描述

📖 目录

概述与核心概念
代理系统架构
使用方法详解
编程语言专家代理
架构与系统设计代理
前端与移动开发代理
数据库与数据处理代理
AI与机器学习代理
安全与质量保证代理
DevOps与部署代理
性能与优化代理
搜索与研究代理
内容与文档代理
专业工具代理
专业领域代理
代理协作策略
高级使用技巧
常见问题与解决方案

概述与核心概念

Claude Code（https://github.com/wshobson/agents）提供了一个由 68个高度专业化的智能代理 组成的生态系统，每个代理都在特定技术领域拥有深度专长。这不是简单的工具集合，而是一个 协作式AI开发平台，能够理解复杂的开发需求并提供企业级的解决方案。

🎯 核心优势

专业化深度: 每个代理都针对特定领域进行了深度优化，拥有该领域的最佳实践、设计模式和解决方案
智能路由: 系统会自动分析任务特征，选择最适合的代理或代理组合
上下文感知: 代理间可以共享上下文信息，确保解决方案的一致性
主动协作: 代理会主动识别需要其他专家介入的情况
持续学习: 基于项目特征和代码风格，动态调整工作方式

🔧 代理分类体系

核心开发代理 (24个): 涵盖主流编程语言和框架
架构设计代理 (8个): 负责系统设计和架构决策
运维部署代理 (12个): 处理DevOps、部署和基础设施
专业领域代理 (16个): 针对特定行业和应用场景
质量保证代理 (8个): 确保代码质量、安全性和性能

代理系统架构

🏗️ 三层架构设计

┌─────────────────────────────────────┐
│         用户接口层                    │
│    (自然语言理解 & 任务路由)           │  
├─────────────────────────────────────┤
│         代理编排层                    │
│  (任务分解 & 代理协调 & 上下文管理)     │
├─────────────────────────────────────┤
│         专业代理层                    │
│     (68个专业化代理执行层)            │
└─────────────────────────────────────┘

🔄 工作流程

需求分析: 解析用户请求，识别任务类型和复杂度
代理选择: 基于任务特征选择最适合的代理组合
任务分解: 将复杂任务分解为可执行的子任务
并行执行: 多个代理同时工作，提高效率
结果整合: 整合各代理的输出，形成统一解决方案
质量验证: 自动验证结果的正确性和完整性

使用方法详解

🎯 基本使用模式

直接任务描述 (推荐)

# 自动代理选择
"帮我优化这个React组件的性能"
"设计一个高可用的微服务架构"  
"修复这个SQL查询的性能问题"

# 系统会自动选择: frontend-developer + performance-engineer
# 或 backend-architect + cloud-architect  
# 或 sql-pro + database-optimizer

明确代理指定

"使用 typescript-pro 重构这个复杂的类型系统"
"让 security-auditor 审查这个认证模块"
"用 ai-engineer 构建一个RAG系统"

多代理协作

"使用 backend-architect 设计API，然后用 frontend-developer 创建对应的UI组件"
"让 data-engineer 构建数据管道，data-scientist 进行分析"

🚀 高级调用模式

条件触发模式

"当代码覆盖率低于80%时，自动调用 test-automator"
"在部署失败时，立即启用 incident-responder"  
"检测到性能问题时，激活 performance-engineer"

流水线模式

"创建一个完整的开发流水线：
1. architect-reviewer 设计架构
2. 对应语言专家实现功能  
3. test-automator 创建测试
4. security-auditor 安全审查
5. deployment-engineer 配置部署"

📋 任务追踪与管理

每个复杂任务都会创建详细的任务列表：

✅ 分析现有架构和痛点
🔄 设计新的微服务架构  
⏳ 创建API接口规范
⏳ 实现核心业务逻辑
⏳ 配置数据库和缓存
⏳ 编写单元和集成测试
⏳ 设置CI/CD管道
⏳ 部署到测试环境
⏳ 性能测试和优化
⏳ 生产环境部署

📚 编程语言专家代理

Python专家 (python-pro)

🎯 核心专长

高级语言特性: 装饰器、生成器、上下文管理器、元类
异步编程: async/await、asyncio、并发模式、异步IO优化
性能优化: 内存管理、GIL理解、Cython集成、性能分析
设计模式: 单例、工厂、观察者、策略模式的Pythonic实现
测试框架: pytest、unittest、mock、测试驱动开发
包管理: setuptools、pip、poetry、虚拟环境最佳实践

🚀 典型使用场景

性能关键代码优化

# 使用案例: 优化数据处理管道
"我有一个处理大量CSV文件的脚本很慢，帮我优化"

# Python专家会分析并重构为:
import asyncio
import aiofiles
from typing import AsyncGenerator
from concurrent.futures import ProcessPoolExecutor

async def process_csv_files(file_paths: list) -> AsyncGenerator:
    """异步并行处理CSV文件"""
    with ProcessPoolExecutor() as executor:
        tasks = [
            asyncio.get_event_loop().run_in_executor(
                executor, process_single_csv, path
            ) for path in file_paths
        ]
        for task in asyncio.as_completed(tasks):
            yield await task

复杂数据结构设计

# 使用案例: 设计缓存系统
"帮我设计一个支持LRU和TTL的缓存系统"

# Python专家会实现:
from collections import OrderedDict
from typing import Generic, TypeVar, Optional
import time
import threading

T = TypeVar('T')

class TTLLRUCache(Generic[T]):
    def __init__(self, capacity: int, ttl: float):
        self._cache: OrderedDict[str, tuple[T, float]] = OrderedDict()
        self._capacity = capacity
        self._ttl = ttl
        self._lock = threading.RLock()
    
    def get(self, key: str) -> Optional[T]:
        with self._lock:
            if key not in self._cache:
                return None
            
            value, timestamp = self._cache[key]
            if time.time() - timestamp > self._ttl:
                del self._cache[key]
                return None
            
            # LRU: 移动到末尾
            self._cache.move_to_end(key)
            return value

Web框架集成

# 使用案例: FastAPI + 异步数据库
"构建一个高性能的API服务，支持数据库连接池"

# Python专家会创建:
from fastapi import FastAPI, Depends
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
from contextlib import asynccontextmanager

@asynccontextmanager
async def lifespan(app: FastAPI):
    # 启动时创建连接池
    app.state.db_engine = create_async_engine(
        DATABASE_URL, 
        pool_size=20, 
        max_overflow=30
    )
    yield
    # 关闭时清理资源
    await app.state.db_engine.dispose()

app = FastAPI(lifespan=lifespan)

⚡ 主动触发条件

检测到Python性能瓶颈时
需要重构复杂Python逻辑时
处理大数据量或高并发需求时
集成机器学习模型时

Java专家 (java-pro)

🎯 核心专长

现代Java特性: Stream API、Lambda、方法引用、模块系统
并发编程: CompletableFuture、并行流、线程池、锁优化
JVM调优: GC优化、内存分析、性能监控、堆外内存
Spring生态: Spring Boot、Spring Security、Spring Data、微服务
企业模式: DDD、CQRS、事件驱动、分布式事务
响应式编程: Project Reactor、RxJava、非阻塞IO

🚀 典型使用场景

高并发服务设计

// 使用案例: 设计高吞吐量的订单处理服务
"构建一个能处理每秒10万订单的服务"

@Service
@Slf4j
public class OrderProcessingService {
    
    private final OrderRepository orderRepository;
    private final PaymentService paymentService;
    private final Executor taskExecutor;
    
    @Async("orderProcessingExecutor")
    public CompletableFuture<OrderResult> processOrderAsync(Order order) {
        return CompletableFuture
            .supplyAsync(() -> validateOrder(order), taskExecutor)
            .thenCompose(validOrder -> processPayment(validOrder))
            .thenCompose(paidOrder -> saveOrder(paidOrder))
            .thenApply(this::generateResult)
            .exceptionally(this::handleProcessingError);
    }
    
    @Bean("orderProcessingExecutor")
    public Executor orderProcessingExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(50);
        executor.setMaxPoolSize(200);
        executor.setQueueCapacity(1000);
        executor.setThreadNamePrefix("OrderProcessor-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        return executor;
    }
}

微服务架构实现

// 使用案例: 实现服务熔断和降级
"为微服务添加熔断器和重试机制"

@Component
public class UserServiceClient {
    
    @Retryable(value = {Exception.class}, 
               maxAttempts = 3, 
               backoff = @Backoff(delay = 1000, multiplier = 2))
    @CircuitBreaker(name = "user-service", fallbackMethod = "getUserFallback")
    public User getUser(Long userId) {
        return restTemplate.getForObject(
            "/api/users/{id}", User.class, userId);
    }
    
    @TimeLimiter(name = "user-service")
    public CompletableFuture<User> getUserAsync(Long userId) {
        return CompletableFuture.supplyAsync(() -> getUser(userId));
    }
    
    public User getUserFallback(Long userId, Exception ex) {
        log.warn("Fallback for user {}: {}", userId, ex.getMessage());
        return User.builder()
            .id(userId)
            .name("Unknown User")
            .build();
    }
}

⚡ 主动触发条件

Spring Boot应用优化需求
高并发性能问题
企业级架构设计
JVM内存或GC问题

TypeScript专家 (typescript-pro)

🎯 核心专长

高级类型系统: 泛型约束、条件类型、映射类型、模板字面量类型
类型体操: 类型推断、类型变换、递归类型、分布式条件类型
企业级架构: 模块系统、命名空间、声明合并、模块解析
装饰器: 元数据、反射、依赖注入、AOP实现
性能优化: 编译优化、类型检查优化、增量编译
现代框架集成: React、Vue、Node.js的类型安全实现

🚀 典型使用场景

类型安全的状态管理

// 使用案例: 设计类型安全的Redux Store
"创建一个完全类型安全的状态管理系统"

// TypeScript专家会设计:
type AppState = {
  user: UserState;
  posts: PostsState;
  ui: UIState;
};

type ActionType = 
  | { type: 'USER_LOGIN'; payload: { user: User; token: string } }
  | { type: 'USER_LOGOUT' }
  | { type: 'POSTS_LOAD_START' }
  | { type: 'POSTS_LOAD_SUCCESS'; payload: { posts: Post[] } }
  | { type: 'POSTS_LOAD_ERROR'; payload: { error: string } };

// 类型安全的reducer
const appReducer = (state: AppState, action: ActionType): AppState => {
  switch (action.type) {
    case 'USER_LOGIN':
      return {
        ...state,
        user: {
          ...state.user,
          data: action.payload.user,
          isAuthenticated: true,
          token: action.payload.token,
        },
      };
    // 其他case会有完整的类型推断和检查
  }
};

// 类型安全的selector
const createTypedSelector = <T>(selector: (state: AppState) => T) => selector;

const selectUser = createTypedSelector(state => state.user.data);
const selectPosts = createTypedSelector(state => state.posts.items);

高级泛型实用工具

// 使用案例: 创建API客户端的类型安全包装
"设计一个类型安全的API客户端"

// 递归深度只读类型
type DeepReadonly<T> = {
  readonly [P in keyof T]: T[P] extends (infer U)[]
    ? readonly DeepReadonly<U>[]
    : T[P] extends Record<string, any>
    ? DeepReadonly<T[P]>
    : T[P];
};

// API端点配置类型
type ApiEndpoint<TRequest = void, TResponse = unknown> = {
  method: 'GET' | 'POST' | 'PUT' | 'DELETE';
  path: string;
  request: TRequest;
  response: TResponse;
};

// 类型安全的API客户端
class TypeSafeApiClient {
  async call<T extends ApiEndpoint>(
    endpoint: T,
    ...[request]: T['request'] extends void ? [] : [T['request']]
  ): Promise<T['response']> {
    const response = await fetch(endpoint.path, {
      method: endpoint.method,
      body: request ? JSON.stringify(request) : undefined,
      headers: { 'Content-Type': 'application/json' },
    });
    return response.json();
  }
}

// 使用示例 - 完全类型安全
const userEndpoint: ApiEndpoint<{ id: number }, User> = {
  method: 'GET',
  path: '/api/users',
  request: { id: 1 },
  response: {} as User,
};

const client = new TypeSafeApiClient();
// TypeScript会推断出正确的请求和响应类型
const user = await client.call(userEndpoint, { id: 123 });

⚡ 主动触发条件

复杂类型系统设计需求
企业级TypeScript架构
类型安全性问题
高级类型推断需求

JavaScript专家 (javascript-pro)

🎯 核心专长

ES6+特性: 解构、模板字符串、箭头函数、模块系统
异步编程: Promise、async/await、事件循环理解、并发模式
函数式编程: 高阶函数、闭包、不可变性、函数组合
性能优化: V8引擎优化、内存泄漏检测、Bundle分析
Node.js生态: Express、Koa、微服务、流处理
现代工具链: Webpack、Vite、ESLint、Prettier

🚀 典型使用场景

事件循环优化

// 使用案例: 处理大量数据而不阻塞UI
"处理10万条记录时页面卡顿，需要优化"

// JavaScript专家会重构为:
async function processLargeDataset(data, chunkSize = 1000) {
  const results = [];
  
  for (let i = 0; i < data.length; i += chunkSize) {
    const chunk = data.slice(i, i + chunkSize);
    
    // 使用 MessageChannel 避免阻塞主线程
    const processed = await new Promise((resolve) => {
      const channel = new MessageChannel();
      const worker = new Worker('./dataProcessor.js');
      
      channel.port1.onmessage = (e) => resolve(e.data);
      worker.postMessage({ chunk, port: channel.port2 }, [channel.port2]);
    });
    
    results.push(...processed);
    
    // 让出控制权，防止阻塞UI
    await new Promise(resolve => setTimeout(resolve, 0));
  }
  
  return results;
}

高性能状态管理

// 使用案例: 创建轻量级响应式状态管理
"需要一个简单但高效的状态管理方案"

class ReactiveStore {
  constructor(initialState = {}) {
    this.state = new Proxy(initialState, {
      set: (target, property, value) => {
        const oldValue = target[property];
        target[property] = value;
        
        if (oldValue !== value) {
          this.notify(property, value, oldValue);
        }
        return true;
      }
    });
    
    this.subscribers = new Map();
    this.computedCache = new Map();
  }
  
  subscribe(key, callback) {
    if (!this.subscribers.has(key)) {
      this.subscribers.set(key, new Set());
    }
    this.subscribers.get(key).add(callback);
    
    return () => this.subscribers.get(key)?.delete(callback);
  }
  
  computed(key, computeFn, dependencies) {
    const compute = () => {
      const result = computeFn(this.state);
      this.computedCache.set(key, result);
      return result;
    };
    
    dependencies.forEach(dep => {
      this.subscribe(dep, () => compute());
    });
    
    return () => this.computedCache.get(key);
  }
}

⚡ 主动触发条件

JavaScript性能瓶颈
异步流程复杂化
Node.js应用优化
前端工具链配置

Go专家 (golang-pro)

🎯 核心专长

并发模型: Goroutines、Channels、Select语句、Context
接口设计: 隐式接口、组合模式、依赖注入
性能优化: 内存对齐、逃逸分析、GC调优、pprof分析
标准库: io、net、context、sync等核心包的高级用法
微服务: gRPC、HTTP服务、中间件、服务发现
并发模式: Worker Pool、Pipeline、Fan-in/Fan-out

🚀 典型使用场景

高并发数据处理

// 使用案例: 处理高并发API请求
"构建一个能处理10万QPS的HTTP服务"

package main

import (
    "context"
    "fmt"
    "net/http"
    "runtime"
    "sync"
    "time"
)

type Server struct {
    workerPool chan chan Request
    workers    []Worker
    quit       chan bool
}

type Request struct {
    Data     interface{}
    Response chan Response
}

type Worker struct {
    ID         int
    Work       chan Request
    WorkerPool chan chan Request
    QuitCh     chan bool
}

func NewServer(maxWorkers int) *Server {
    pool := make(chan chan Request, maxWorkers)
    server := &Server{
        workerPool: pool,
        quit:       make(chan bool),
    }
    
    // 创建工作者
    server.workers = make([]Worker, maxWorkers)
    for i := 0; i < maxWorkers; i++ {
        worker := Worker{
            ID:         i,
            Work:       make(chan Request),
            WorkerPool: pool,
            QuitCh:     make(chan bool),
        }
        worker.Start()
        server.workers[i] = worker
    }
    
    return server
}

func (w *Worker) Start() {
    go func() {
        for {
            w.WorkerPool <- w.Work
            
            select {
            case request := <-w.Work:
                // 处理请求
                result := processRequest(request.Data)
                request.Response <- Response{Data: result}
                
            case <-w.QuitCh:
                return
            }
        }
    }()
}

// 优雅关闭
func (s *Server) Shutdown(ctx context.Context) error {
    close(s.quit)
    
    done := make(chan bool, len(s.workers))
    for _, worker := range s.workers {
        go func(w Worker) {
            close(w.QuitCh)
            done <- true
        }(worker)
    }
    
    // 等待所有worker关闭或超时
    for i := 0; i < len(s.workers); i++ {
        select {
        case <-done:
        case <-ctx.Done():
            return ctx.Err()
        }
    }
    
    return nil
}

⚡ 主动触发条件

Go并发问题
微服务架构需求
高性能服务设计
系统级编程需求

Rust专家 (rust-pro)

🎯 核心专长

所有权系统: 借用检查、生命周期、智能指针
零成本抽象: trait、泛型、宏系统、编译期计算
并发安全: Arc、Mutex、RwLock、Atomic类型、异步编程
性能优化: SIMD、内联汇编、基准测试、profiling
系统编程: FFI、不安全代码、内存管理、操作系统接口
现代生态: Tokio、Serde、Diesel、WebAssembly

🚀 典型使用场景

高性能计算库

// 使用案例: 实现零拷贝的数据处理管道
"需要一个内存安全但极高性能的数据处理系统"

use std::marker::PhantomData;
use std::sync::{Arc, RwLock};
use tokio::sync::mpsc;

// 零拷贝数据容器
pub struct ZeroCopyBuffer<T> {
    data: Arc<RwLock<Vec<T>>>,
    _phantom: PhantomData<T>,
}

impl<T: Clone + Send + Sync + 'static> ZeroCopyBuffer<T> {
    pub fn new(capacity: usize) -> Self {
        Self {
            data: Arc::new(RwLock::new(Vec::with_capacity(capacity))),
            _phantom: PhantomData,
        }
    }
    
    pub fn view(&self) -> BufferView<T> {
        BufferView {
            data: Arc::clone(&self.data),
            _phantom: PhantomData,
        }
    }
}

pub struct BufferView<T> {
    data: Arc<RwLock<Vec<T>>>,
    _phantom: PhantomData<T>,
}

// 高性能异步处理管道
pub struct ProcessingPipeline<T, U> {
    input_tx: mpsc::UnboundedSender<T>,
    output_rx: mpsc::UnboundedReceiver<U>,
    workers: Vec<tokio::task::JoinHandle<()>>,
}

impl<T, U> ProcessingPipeline<T, U> 
where 
    T: Send + 'static,
    U: Send + 'static,
{
    pub async fn new<F, Fut>(
        worker_count: usize,
        processor: F,
    ) -> Self 
    where
        F: Fn(T) -> Fut + Send + Sync + Clone + 'static,
        Fut: std::future::Future<Output = U> + Send,
    {
        let (input_tx, mut input_rx) = mpsc::unbounded_channel();
        let (output_tx, output_rx) = mpsc::unbounded_channel();
        
        let mut workers = Vec::with_capacity(worker_count);
        
        for _ in 0..worker_count {
            let mut rx = input_rx.clone();
            let tx = output_tx.clone();
            let proc = processor.clone();
            
            let worker = tokio::spawn(async move {
                while let Some(item) = rx.recv().await {
                    let result = proc(item).await;
                    if tx.send(result).is_err() {
                        break;
                    }
                }
            });
            
            workers.push(worker);
        }
        
        Self {
            input_tx,
            output_rx,
            workers,
        }
    }
}

⚡ 主动触发条件

系统级性能要求
内存安全关键场景
WebAssembly项目
高并发底层服务

C++专家 (cpp-pro)

🎯 核心专长

现代C++: C++14/17/20特性、概念、模块、协程
内存管理: RAII、智能指针、自定义分配器、内存池
模板编程: 变参模板、SFINAE、类型特征、元编程
性能优化: 编译器优化、内联、分支预测、缓存友好设计
STL高级用法: 算法、容器、迭代器、函数对象
并发编程: 原子操作、内存序、线程池、无锁数据结构

🚀 典型使用场景

高性能容器设计

// 使用案例: 设计缓存友好的高性能容器
"需要一个比std::vector更快的动态数组"

#include <memory>
#include <iterator>
#include <algorithm>

template<typename T, typename Allocator = std::allocator<T>>
class fast_vector {
public:
    using value_type = T;
    using allocator_type = Allocator;
    using size_type = std::size_t;
    using iterator = T*;
    using const_iterator = const T*;

private:
    static constexpr size_type INITIAL_CAPACITY = 16;
    static constexpr double GROWTH_FACTOR = 1.618; // 黄金比例增长
    
    T* data_;
    size_type size_;
    size_type capacity_;
    [[no_unique_address]] Allocator alloc_;

    // 预取优化
    void prefetch_write(void* addr) const noexcept {
        #ifdef __builtin_prefetch
        __builtin_prefetch(addr, 1, 3);
        #endif
    }

public:
    fast_vector(const Allocator& alloc = Allocator{})
        : data_(nullptr), size_(0), capacity_(0), alloc_(alloc) {}

    template<typename... Args>
    void emplace_back(Args&&... args) {
        if (size_ == capacity_) [[unlikely]] {
            reserve_grow();
        }
        
        // 预取下一个可能的写入位置
        if (size_ + 1 < capacity_) [[likely]] {
            prefetch_write(data_ + size_ + 1);
        }
        
        std::construct_at(data_ + size_, std::forward<Args>(args)...);
        ++size_;
    }

    void push_back(const T& value) {
        emplace_back(value);
    }

    void push_back(T&& value) {
        emplace_back(std::move(value));
    }

    // 批量操作优化
    template<typename InputIt>
    void insert_range(const_iterator pos, InputIt first, InputIt last) {
        static_assert(std::is_same_v<typename std::iterator_traits<InputIt>::value_type, T>);
        
        const auto distance = std::distance(first, last);
        const auto index = pos - data_;
        
        if (size_ + distance > capacity_) {
            reserve(std::max(capacity_ * GROWTH_FACTOR, size_ + distance));
        }
        
        // 使用memmove进行优化移动(对于trivial类型)
        if constexpr (std::is_trivially_copyable_v<T>) {
            std::memmove(data_ + index + distance, data_ + index, 
                        (size_ - index) * sizeof(T));
            std::uninitialized_copy(first, last, data_ + index);
        } else {
            // 非trivial类型使用标准算法
            std::move_backward(data_ + index, data_ + size_, 
                             data_ + size_ + distance);
            std::uninitialized_copy(first, last, data_ + index);
        }
        
        size_ += distance;
    }

private:
    void reserve_grow() {
        const size_type new_cap = capacity_ == 0 ? 
            INITIAL_CAPACITY : 
            static_cast<size_type>(capacity_ * GROWTH_FACTOR);
        reserve(new_cap);
    }
};

⚡ 主动触发条件

C++性能关键代码
现代C++特性需求
内存优化需求
高性能计算场景

🏗️ 架构与系统设计代理

后端架构师 (backend-architect)

功能: 设计RESTful API、微服务边界、数据库模式
使用场景: 创建新的后端服务或API时主动调用
示例:

帮我设计一个电商系统的微服务架构

云架构师 (cloud-architect)

功能: AWS/Azure/GCP基础设施、Terraform IaC、云成本优化
使用场景: 云基础设施、成本优化、迁移规划
示例:

帮我设计一个自动扩展的AWS架构

架构评审师 (architect-reviewer)

功能: 评审代码变更的架构一致性和模式
使用场景: 结构更改、新服务、API修改后主动调用
示例:

评审这个新的API设计是否符合架构原则

GraphQL架构师 (graphql-architect)

功能: 设计GraphQL schema、解析器、联邦
使用场景: GraphQL API设计或性能问题
示例:

帮我设计一个高性能的GraphQL API

🎨 前端与移动开发代理

前端开发师 (frontend-developer)

功能: 构建React组件、响应式布局、客户端状态管理
使用场景: 创建UI组件或修复前端问题时主动调用
示例:

帮我创建一个响应式的数据表格组件

UI/UX设计师 (ui-ux-designer)

功能: 创建界面设计、线框图、设计系统
使用场景: 设计系统、用户流程、界面优化
示例:

帮我设计一个用户友好的登录流程

React Native开发师 (mobile-developer)

功能: 开发React Native或Flutter应用，原生集成
使用场景: 移动功能、跨平台代码、应用优化
示例:

帮我实现一个跨平台的推送通知系统

iOS开发师 (ios-developer)

功能: 原生iOS应用开发，Swift/SwiftUI
使用场景: iOS特定功能、App Store优化
示例:

帮我实现一个原生的iOS相机功能

Flutter专家 (flutter-expert)

功能: 精通Flutter开发，Dart、小部件、平台集成
使用场景: Flutter架构、UI实现、跨平台功能
示例:

帮我优化这个Flutter应用的性能

Unity开发师 (unity-developer)

功能: 构建Unity游戏，优化C#脚本、高效渲染
使用场景: Unity性能问题、游戏机制、跨平台构建
示例:

帮我优化这个Unity游戏的渲染性能

🗄️ 数据库与数据处理代理

SQL专家 (sql-pro)

功能: 编写复杂SQL查询、优化执行计划、设计规范化模式
使用场景: 查询优化、复杂连接、数据库设计
示例:

帮我优化这个慢查询的性能

数据库管理员 (database-admin)

功能: 管理数据库操作、备份、复制、监控
使用场景: 数据库设置、运维问题、恢复程序
示例:

帮我设置一个MySQL主从复制方案

数据库优化师 (database-optimizer)

功能: 优化SQL查询、设计高效索引、处理数据库迁移
使用场景: 数据库性能问题或模式优化
示例:

帮我分析并优化这个数据库的查询性能

数据工程师 (data-engineer)

功能: 构建ETL管道、数据仓库、流处理架构
使用场景: 数据管道设计或分析基础设施
示例:

帮我设计一个实时数据处理管道

数据科学家 (data-scientist)

功能: SQL查询、BigQuery操作、数据分析专家
使用场景: 数据分析任务和查询
示例:

帮我分析用户行为数据找出关键趋势

🧠 AI与机器学习代理

AI工程师 (ai-engineer)

功能: 构建LLM应用、RAG系统、提示管道
使用场景: LLM功能、聊天机器人、AI驱动的应用
示例:

帮我构建一个基于RAG的智能问答系统

ML工程师 (ml-engineer)

功能: 实现ML管道、模型服务、特征工程
使用场景: ML模型集成或生产部署
示例:

帮我部署一个机器学习模型到生产环境

MLOps工程师 (mlops-engineer)

功能: 构建ML管道、实验跟踪、模型注册表
使用场景: ML基础设施、实验管理、管道自动化
示例:

帮我设置一个完整的MLOps流水线

提示工程师 (prompt-engineer)

功能: 为LLM和AI系统优化提示
使用场景: 构建AI功能、改进代理性能、制作系统提示
示例:

帮我优化这个AI助手的提示词

🔒 安全与质量保证代理

安全审计师 (security-auditor)

功能: 审查代码漏洞、实现安全认证、确保OWASP合规
使用场景: 安全评审、认证流程、漏洞修复时主动调用
示例:

帮我审查这个登录系统的安全性

代码评审师 (code-reviewer)

功能: 专业代码评审专家，评估质量、安全性、可维护性
使用场景: 编写或修改代码后立即调用
示例:

评审我刚写的这个API接口代码

测试自动化师 (test-automator)

功能: 创建全面的测试套件，单元、集成、端到端测试
使用场景: 测试覆盖率改进或测试自动化设置时主动调用
示例:

为这个新功能创建完整的测试套件

调试专家 (debugger)

功能: 专门处理错误、测试失败、异常行为的调试
使用场景: 遇到任何问题时主动调用
示例:

帮我调试这个内存泄漏问题

错误侦探 (error-detective)

功能: 搜索日志和代码库中的错误模式、堆栈跟踪
使用场景: 调试问题、分析日志、调查生产错误时主动调用
示例:

帮我分析这个系统崩溃的根本原因

🚀 DevOps与部署代理

部署工程师 (deployment-engineer)

功能: 配置CI/CD管道、Docker容器、云部署
使用场景: 设置部署、容器、CI/CD工作流时主动调用
示例:

帮我设置一个完整的CI/CD管道

DevOps故障排除师 (devops-troubleshooter)

功能: 调试生产问题、分析日志、修复部署失败
使用场景: 生产调试或系统故障时主动调用
示例:

帮我排查这个Kubernetes集群的问题

Terraform专家 (terraform-specialist)

功能: 编写高级Terraform模块、管理状态文件
使用场景: Terraform模块、状态问题、IaC自动化
示例:

帮我创建一个可重用的Terraform模块

网络工程师 (network-engineer)

功能: 调试网络连接、配置负载均衡器、分析流量模式
使用场景: 连接问题、网络优化、协议调试
示例:

帮我诊断这个网络延迟问题

支付集成师 (payment-integration)

功能: 集成Stripe、PayPal等支付处理器
使用场景: 实现支付、计费、订阅功能时主动调用
示例:

帮我集成Stripe支付系统

📊 性能与优化代理

性能工程师 (performance-engineer)

功能: 性能分析、优化瓶颈、实现缓存策略
使用场景: 性能问题或优化任务时主动调用
示例:

帮我优化这个网站的加载速度

风险管理师 (risk-manager)

功能: 监控投资组合风险、R倍数、头寸限制
使用场景: 风险评估、交易跟踪、投资组合保护
示例:

帮我分析这个投资组合的风险水平

量化分析师 (quant-analyst)

功能: 构建金融模型、回测交易策略、分析市场数据
使用场景: 量化金融、交易算法、风险分析
示例:

帮我构建一个股票交易策略回测系统

🔍 搜索与研究代理

搜索专家 (search-specialist)

功能: 使用高级搜索技术的专业网络研究员
使用场景: 深度研究、信息收集、趋势分析时主动调用
示例:

帮我研究最新的AI发展趋势

通用代理 (general-purpose)

功能: 研究复杂问题、搜索代码、执行多步骤任务的通用代理
使用场景: 搜索关键词或文件且不确定能否快速找到时使用
示例:

帮我找到项目中所有与用户认证相关的代码

📝 内容与文档代理

SEO内容写手 (seo-content-writer)

功能: 基于关键词撰写SEO优化的内容
使用场景: 内容创建任务时主动调用
示例:

帮我写一篇关于机器学习的SEO优化文章

文档架构师 (docs-architect)

功能: 从现有代码库创建全面的技术文档
使用场景: 系统文档、架构指南、技术深度分析时主动调用
示例:

为这个微服务系统创建完整的架构文档

API文档师 (api-documenter)

功能: 创建OpenAPI/Swagger规范、生成SDK
使用场景: API文档或客户端库生成时主动调用
示例:

为这个REST API创建完整的文档

教程工程师 (tutorial-engineer)

功能: 从代码创建逐步教程和教育内容
使用场景: 入门指南、功能教程、概念解释时主动调用
示例:

为这个新功能创建用户教程

🛠️ 专业工具代理

事故响应员 (incident-responder)

功能: 紧急处理生产事故
使用场景: 生产问题发生时立即使用
示例:

系统出现严重故障，需要紧急处理

遗留系统现代化师 (legacy-modernizer)

功能: 重构遗留代码库、迁移过时框架
使用场景: 遗留系统更新、框架迁移、技术债务减少时主动调用
示例:

帮我将这个老旧的jQuery应用迁移到React

上下文管理器 (context-manager)

功能: 管理多代理和长期任务的上下文
使用场景: 协调复杂的多代理工作流
示例:

协调多个代理完成这个大型重构项目

DX优化师 (dx-optimizer)

功能: 开发者体验专家，改进工具、设置、工作流
使用场景: 设置新项目、团队反馈后、发现开发摩擦时主动调用
示例:

优化这个项目的开发环境配置

🎯 专业领域代理

Minecraft Bukkit专家 (minecraft-bukkit-pro)

功能: 精通Minecraft服务器插件开发
使用场景: 插件架构、游戏机制、跨版本兼容性时主动调用
示例:

帮我开发一个Minecraft服务器管理插件

销售自动化师 (sales-automator)

功能: 起草冷邮件、跟进、提案模板
使用场景: 销售推广或客户培养时主动调用
示例:

帮我创建一套完整的销售邮件模板

客户支持师 (customer-support)

功能: 处理支持工单、FAQ响应、客户邮件
使用场景: 客户咨询或支持文档时主动调用
示例:

帮我创建产品的FAQ文档

内容营销师 (content-marketer)

功能: 撰写博客文章、社交媒体内容、电子邮件通讯
使用场景: 营销内容或社交媒体帖子时主动调用
示例:

为新产品发布写一篇营销博客

商业分析师 (business-analyst)

功能: 分析指标、创建报告、跟踪KPI
使用场景: 商业指标或投资者更新时主动调用
示例:

帮我分析上季度的用户增长数据

法律顾问 (legal-advisor)

功能: 起草隐私政策、服务条款、免责声明
使用场景: 法律文档、合规文本、监管要求时主动调用
示例:

为我的网站起草GDPR合规的隐私政策

HR专家 (hr-pro)

功能: 专业、合规的HR合作伙伴，处理招聘、入职离职、绩效管理
使用场景: HR政策、员工管理、合规模板
示例:

帮我制定远程工作政策

💡 使用建议

最佳实践

具体描述任务: 提供详细的上下文和需求
选择合适代理: 根据任务类型选择最专业的代理
组合使用: 复杂项目可以结合多个代理
主动调用: 某些代理会根据任务自动调用

使用技巧

代理会根据你的具体需求自动选择最合适的专业领域
可以在一次对话中使用多个代理
代理会保持任务上下文，无需重复说明背景

常见应用场景

新项目启动: 使用架构师代理设计系统
代码优化: 使用对应语言的专家代理
问题排查: 使用调试专家和错误侦探
部署上线: 使用DevOps和部署相关代理
文档编写: 使用文档和API相关代理

🎯 代理协作策略

经典代理组合模式

1. 全栈开发流水线

architect-reviewer → backend-architect → [语言专家] → 
frontend-developer → database-optimizer → test-automator → 
security-auditor → deployment-engineer

使用场景: 从零构建完整的Web应用
协作优势: 每个环节都有专门代理负责，确保最佳实践

2. 性能优化流水线

performance-engineer → [语言专家] → database-optimizer → 
cloud-architect → monitoring-specialist

使用场景: 系统性能问题诊断和优化
协作优势: 从代码到基础设施的全方位优化

3. 安全加固流水线

security-auditor → [语言专家] → network-engineer → 
legal-advisor → compliance-checker

使用场景: 企业级安全合规需求
协作优势: 技术和法律双重保障

代理间通信机制

上下文共享

代理间会自动共享以下信息：

项目架构: 技术栈、框架选择、设计模式
代码规范: 命名规则、格式化标准、最佳实践
性能需求: 延迟要求、吞吐量目标、资源限制
安全策略: 认证方式、加密标准、合规要求

自动触发规则

触发条件:
  代码变更: 
    - code-reviewer (always)
    - security-auditor (if auth/payment related)
    - performance-engineer (if critical path)
  
  部署操作:
    - incident-responder (if failure)
    - monitoring-specialist (always)
    - backup-manager (if database changes)
  
  性能异常:
    - performance-engineer (always)
    - database-optimizer (if DB related) 
    - cloud-architect (if infrastructure related)

🔧 高级使用技巧

1. 智能任务分解

复杂任务示例: “构建一个实时聊天应用”

系统会自动分解为：

📋 任务分解结果：
├── 🏗️ backend-architect: 设计实时通信架构
├── 🗄️ database-optimizer: 设计消息存储方案  
├── 🔒 security-auditor: 设计认证和权限系统
├── 🎨 frontend-developer: 实现聊天UI组件
├── ⚡ performance-engineer: 优化实时性能
├── 🚀 deployment-engineer: 配置WebSocket集群
└── 🧪 test-automator: 创建端到端测试

2. 条件触发与智能路由

智能路由示例:

# 用户请求: "这个API响应很慢"

# 系统分析后的代理调用链:
1. performance-engineer → 分析性能瓶颈
   ↓ 发现是数据库问题
2. database-optimizer → 优化SQL查询
   ↓ 发现需要架构调整  
3. backend-architect → 重新设计数据访问层
   ↓ 需要缓存策略
4. cloud-architect → 设计Redis缓存方案
   ↓ 需要监控
5. monitoring-specialist → 设置性能监控

3. 渐进式优化策略

阶段一: 快速修复

debugger: 立即解决阻塞问题
performance-engineer: 快速性能调优

阶段二: 架构优化

architect-reviewer: 评估架构债务
backend-architect: 设计改进方案

阶段三: 全面升级

legacy-modernizer: 技术栈升级
cloud-architect: 基础设施现代化

4. 专业领域深度整合

金融科技项目:

quant-analyst + risk-manager + security-auditor + 
legal-advisor + compliance-checker

游戏开发项目:

unity-developer + performance-engineer + 
graphics-optimizer + multiplayer-architect

机器学习项目:

ai-engineer + ml-engineer + mlops-engineer + 
data-engineer + performance-engineer

💡 最佳实践指南

1. 代理选择策略

根据项目规模选择

小型项目 (< 1万行代码):

优先使用通用代理如 general-purpose
按需添加专业代理

中型项目 (1-10万行代码):

建立核心代理团队 (3-5个)
设置自动触发规则

大型项目 (> 10万行代码):

使用完整代理生态
启用 context-manager 协调

根据团队技能选择

新手团队:

多使用指导性代理如 tutorial-engineer
启用详细的代码审查流程

专家团队:

专注于架构和优化类代理
减少基础代码生成，增加设计指导

2. 任务描述最佳实践

✅ 推荐的描述方式

# 具体且明确
"优化这个处理1万条用户数据的Python脚本，目标是将执行时间从30秒降到3秒以内"

# 包含上下文
"在我们的电商系统中，添加一个支持并发的库存管理模块，需要防止超卖问题"

# 指定约束条件  
"使用TypeScript重构这个React组件，要求保持向后兼容且提高类型安全性"

❌ 避免的描述方式

# 过于模糊
"帮我写个程序"

# 缺少上下文
"修复这个bug"

# 没有明确目标
"优化一下性能"

3. 协作流程优化

并行工作流

迭代改进流程

1. 快速原型 → general-purpose
2. 架构审查 → architect-reviewer  
3. 专业实现 → [对应语言专家]
4. 质量保证 → code-reviewer + test-automator
5. 性能优化 → performance-engineer
6. 安全审查 → security-auditor
7. 生产部署 → deployment-engineer

4. 错误处理与恢复

常见问题及解决方案

问题: 代理选择不当

解决方案: 使用 general-purpose 重新分析需求
备选方案: 明确指定所需的专业代理

问题: 上下文丢失

解决方案: 启用 context-manager 管理长期项目
预防措施: 在重要节点保存项目状态

问题: 代理间冲突

解决方案: 使用 architect-reviewer 协调冲突
标准流程: 建立明确的代理优先级规则

🚀 进阶使用指南

1. 自定义工作流

创建项目模板

# 项目: 微服务API开发
workflow_template:
  name: "microservice-api"
  agents:
    - backend-architect: 
        role: "primary"
        triggers: ["project_start"]
    - security-auditor:
        role: "reviewer" 
        triggers: ["code_commit"]
    - test-automator:
        role: "automation"
        triggers: ["feature_complete"]
  
  quality_gates:
    - coverage_threshold: 80%
    - security_scan: "passed"
    - performance_test: "< 200ms"

设置自动化规则

# 性能监控触发
if response_time > 500ms:
    trigger_agents([
        "performance-engineer",
        "database-optimizer",
        "cloud-architect"
    ])

# 安全事件触发
if security_alert:
    trigger_agents([
        "incident-responder", 
        "security-auditor",
        "legal-advisor"
    ])

2. 企业级集成

CI/CD集成

# .github/workflows/claude-agents.yml
name: Claude Agents Integration

on: [push, pull_request]

jobs:
  code-review:
    steps:
      - uses: actions/checkout@v3
      - name: Code Review
        run: |
          claude-agent code-reviewer \
            --files="${{ github.event.pull_request.changed_files }}" \
            --standards="./code-standards.yml"
  
  security-scan:  
    steps:
      - name: Security Audit
        run: |
          claude-agent security-auditor \
            --scan-type="comprehensive" \
            --report-format="sarif"

监控集成

// 实时性能监控
const claudeMonitoring = {
  performance: {
    threshold: 200, // ms
    agent: 'performance-engineer'
  },
  errors: {
    threshold: 0.01, // 1% error rate  
    agent: 'debugger'
  },
  security: {
    events: ['auth_failure', 'injection_attempt'],
    agent: 'incident-responder'
  }
};

3. 团队协作模式

代码审查流程

1. 开发者提交PR
2. code-reviewer 自动审查
3. 如有问题，相关专家介入
4. architect-reviewer 审查架构影响
5. security-auditor 检查安全问题  
6. 通过后合并代码

知识传承系统

senior-developer + tutorial-engineer → 
    生成新人培训材料
    
expert-team + docs-architect →
    创建技术文档和最佳实践库

🔍 常见问题与解决方案

Q: 如何选择合适的代理？

A: 遵循以下原则：

任务匹配: 选择专业领域最匹配的代理
复杂度评估: 简单任务用通用代理，复杂任务用专业代理
时间权衡: 紧急任务可能需要多代理并行工作
质量要求: 高质量要求建议使用完整的代理流水线

Q: 代理给出的建议不符合项目需求怎么办？

A: 可以采用以下策略：

提供更多上下文: 详细描述项目背景、技术栈、约束条件
明确指定代理: 如果知道需要特定专业知识，直接指定代理类型
迭代优化: 基于初步建议提出改进要求
组合使用: 多个代理协作可能得到更好的解决方案

Q: 如何管理长期项目的代理协作？

A: 建议使用以下方法：

启用 context-manager: 专门处理长期项目的上下文管理
设置里程碑: 在关键节点总结和保存项目状态
建立标准流程: 为常见任务建立标准的代理调用流程
定期评估: 定期使用 architect-reviewer 评估整体架构

Q: 如何确保代理建议的安全性？

A: 安全保障措施：

自动安全审查: security-auditor 会主动审查涉及安全的代码
多层验证: 重要功能会有多个代理交叉验证
最佳实践集成: 代理内置了行业最佳实践和安全标准
人工审核: 关键决策仍建议人工最终确认

📚 扩展阅读与资源

官方文档

社区资源

培训资料

🎯 总结

Claude Code的68个专业智能代理构成了一个完整的开发生态系统。通过合理选择和组合使用这些代理，你可以：

✅ 提高开发效率: 专业代理处理专业问题，避免通用方案的局限性
✅ 保证代码质量: 多层次的审查和优化机制
✅ 降低技术风险: 内置最佳实践和安全标准
✅ 加速团队成长: 通过代理协作学习先进的开发模式

这份完整的使用手册涵盖了Claude Code智能代理系统的所有核心概念、使用方法、最佳实践和高级技巧。希望能帮助你充分利用这个强大的AI开发助手生态系统！