implementation

Compare original and translation side by side

🇺🇸

Original

English

🇨🇳

Translation

Chinese

Implementation Orchestration

实施编排

Execute implementation plans by orchestrating specialized engineering agents, ensuring quality through expert consultation, and maintaining comprehensive tracking throughout the build process.

通过协调专业工程Agent来执行实施计划，在构建全程通过专家咨询保障质量，并保持全面的进度追踪。

What This Skill Provides

本Skill提供的能力

This skill enables executing implementation plans through:

Agent orchestration - Coordinate specialized agents (frontend, backend, security, etc.)
Task breakdown and tracking - Create comprehensive todo lists from plans
Parallel execution - Run independent tasks simultaneously for efficiency
Quality assurance - Security, performance, and code quality reviews
Execution management - Track implementation progress and completion

本Skill可通过以下方式执行实施计划：

Agent编排 - 协调专业Agent（前端、后端、安全等）
任务拆解与追踪 - 根据计划创建完整的待办事项列表
并行执行 - 同时运行独立任务以提升效率
质量保障 - 安全、性能与代码质量评审
执行管理 - 追踪实施进度与完成情况

When to Use This Skill

何时使用本Skill

Use this skill when:

User requests implementation of a plan (from extended-planning session)
Coordinating multiple specialized agents
Building complex features requiring expert consultation
Want to ensure quality throughout implementation

在以下场景使用本Skill：

用户要求实施计划（来自扩展规划环节）
协调多个专业Agent
构建需要专家咨询的复杂功能
希望在实施全程保障质量

Core Implementation Workflow

核心实施工作流

Follow this six-phase workflow to execute implementation plans:

遵循以下六阶段工作流来执行实施计划：

Phase 1: Plan Analysis & Task Breakdown

阶段1：计划分析与任务拆解

Analyze complexity of each section:

Simple tasks →
```
@junior-engineer
```
Frontend tasks →
```
@frontend-engineer
```
Backend tasks →
```
@backend-engineer
```
Complex tasks →
```
@architect
```
then engineer

Identify critical aspects:

Security implications → Always
```
@security-expert
```
Performance-critical code → Always
```
@performance-engineer
```
Architectural decisions → Always
```
@architect
```

Create task list using TodoWrite:

Break plan into discrete tasks
Mark dependencies
Prioritize based on plan order

See references/agent-selection.md
for detailed agent assignment rules.

分析各部分复杂度：

简单任务 →
```
@junior-engineer
```
前端任务 →
```
@frontend-engineer
```
后端任务 →
```
@backend-engineer
```
复杂任务 → 先咨询
```
@architect
```
再分配给工程师

识别关键环节：

安全相关 → 必须咨询
```
@security-expert
```
性能关键代码 → 必须咨询
```
@performance-engineer
```
架构决策 → 必须咨询
```
@architect
```

使用TodoWrite创建任务列表：

将计划拆解为独立任务
标记依赖关系
根据计划顺序确定优先级

详见**

references/agent-selection.md

**中的详细Agent分配规则。

Phase 2: Orchestration Strategy

阶段2：编排策略

Parallel execution for independent tasks:

Multiple frontend components simultaneously
Independent backend services in parallel
Tests written while implementation ongoing

Sequential execution for dependent tasks:

Database schema before API implementation
Core services before dependent features
Architectural decisions before implementation

See references/parallel-execution.md
for coordination patterns.

独立任务并行执行：

同时开发多个前端组件
并行构建独立后端服务
实施过程中同步编写测试用例

依赖任务顺序执行：

先设计数据库Schema再实现API
先开发核心服务再构建依赖功能
先确定架构决策再开展实施

详见**

references/parallel-execution.md

**中的协调模式。

Phase 3: Execution Workflow

阶段3：执行工作流

For each task in the plan:

1. Pre-Implementation Consultation

For complex/sensitive tasks:

Consult
```
@architect
```
for design approach
Consult
```
@security-expert
```
if security-related
Consult
```
@performance-engineer
```
if performance-critical
Get approval before proceeding

2. Task Assignment

Assign to appropriate agent:

Simple tasks →
```
@junior-engineer
```
UI/frontend →
```
@frontend-engineer
```
APIs/backend →
```
@backend-engineer
```

3. Skill Loading

Load appropriate skills based on technology:

TypeScript/JavaScript →
```
typescript-style
```
or
```
javascript
```
skill
Python →
```
python
```
skill
Go →
```
go
```
skill
CSS/Tailwind →
```
css
```
or
```
tailwind-css
```
skill
HTML →
```
html
```
skill

4. Documentation & Research

Use web search for:

Official framework documentation
Library API references
Best practices
Known issues or gotchas

5. Implementation

Give agents clear, specific instructions:

Task: [Specific task from plan]
Context: [Relevant context]
Requirements:
  - [Requirement 1]
  - [Requirement 2]
Files to modify/create:
  - [File path 1]
Success criteria:
  - [How to verify completion]

6. Verification

After each task:

Run relevant tests
Check for type errors
Verify functionality
Run linter/formatter
Check security implications
Mark todo as completed

See references/execution-workflow.md
for detailed implementation steps.

针对计划中的每个任务：

1. 实施前咨询

对于复杂/敏感任务：

咨询
```
@architect
```
获取设计方案
若涉及安全，咨询
```
@security-expert
```
若为性能关键任务，咨询
```
@performance-engineer
```
获得批准后再推进

2. 任务分配

分配给合适的Agent：

简单任务 →
```
@junior-engineer
```
UI/前端 →
```
@frontend-engineer
```
API/后端 →
```
@backend-engineer
```

3. 加载Skill

根据技术栈加载对应Skill：

TypeScript/JavaScript →
```
typescript-style
```
或
```
javascript
```
Skill
Python →
```
python
```
Skill
Go →
```
go
```
Skill
CSS/Tailwind →
```
css
```
或
```
tailwind-css
```
Skill
HTML →
```
html
```
Skill

4. 文档与调研

通过网络搜索获取：

官方框架文档
库API参考
最佳实践
已知问题或注意事项

5. 实施

向Agent提供清晰、明确的指令：

Task: [计划中的具体任务]
Context: [相关上下文]
Requirements:
  - [需求1]
  - [需求2]
Files to modify/create:
  - [文件路径1]
Success criteria:
  - [验证完成的方式]

6. 验证

每个任务完成后：

运行相关测试
检查类型错误
验证功能正确性
运行代码检查/格式化工具
检查安全影响
标记待办事项为已完成

详见**

references/execution-workflow.md

**中的详细实施步骤。

Phase 4: Quality Assurance

阶段4：质量保障

Security Review:

Before committing security code, get
```
@security-expert
```
review
Verify input validation
Check authentication/authorization
Review data handling

Performance Review:

Before committing performance-critical code, get
```
@performance-engineer
```
review
Check query efficiency
Verify caching implementation
Review resource usage

Code Quality:

Follow style guide (use loaded skills)
Maintain consistency
Add appropriate comments
Update documentation

See references/quality-assurance.md
for comprehensive QA guidelines.

安全评审：

提交安全相关代码前，需经
```
@security-expert
```
评审
验证输入校验
检查认证/授权机制
评审数据处理流程

性能评审：

提交性能关键代码前，需经
```
@performance-engineer
```
评审
检查查询效率
验证缓存实现
评审资源使用情况

代码质量：

遵循编码风格指南（使用已加载的Skill）
保持代码一致性
添加适当的注释
更新文档

详见**

references/quality-assurance.md

**中的全面QA指南。

Phase 5: Testing & Validation

阶段5：测试与验证

Run tests according to plan's testing strategy:

bash

git status
npm test || pytest || go test ./...

If tests fail:

Analyze failures
Assign fixes to appropriate agent
Re-run tests
Repeat until passing

根据计划的测试策略运行测试：

bash

git status
npm test || pytest || go test ./...

若测试失败：

分析失败原因
将修复任务分配给合适的Agent
重新运行测试
重复直至测试通过

Phase 6: Final Steps & Documentation

阶段6：最终步骤与文档

1. Documentation

Update README if needed
Add/update code comments
Generate API docs if applicable
Update user documentation

2. Git Status Check

bash

git status
git diff --stat

3. Implementation Summary

Display completion status:

✅ Implementation completed
📊 Summary:
- Tasks completed: <count>
- Files changed: <count>
- Tests: <passing/total>

See references/completion-workflow.md
for final step details.

1. 文档更新

必要时更新README
添加/更新代码注释
若适用，生成API文档
更新用户文档

2. Git状态检查

bash

git status
git diff --stat

3. 实施总结

展示完成状态：

✅ 实施已完成
📊 总结：
- 已完成任务：<数量>
- 修改文件：<数量>
- 测试：<通过数/总数>

详见**

references/completion-workflow.md

**中的最终步骤详情。

Agent Selection Quick Reference

Agent选择速查表

Task Type	Primary Agent	Consult	Skills to Load
Simple bug fix	@junior-engineer	-	Language skill
UI component	@frontend-engineer	-	Frontend skills
API endpoint	@backend-engineer	@architect	Language skill
Authentication	@backend-engineer	@security-expert, @architect	Security patterns
Performance optimization	@backend-engineer	@performance-engineer	-
Architecture change	@architect	-	-
Database schema	@backend-engineer	@architect	-

任务类型	主要Agent	需咨询	加载的Skill
简单Bug修复	@junior-engineer	-	对应语言Skill
UI组件	@frontend-engineer	-	前端Skill
API端点	@backend-engineer	@architect	对应语言Skill
认证功能	@backend-engineer	@security-expert, @architect	安全模式
性能优化	@backend-engineer	@performance-engineer	-
架构变更	@architect	-	-
数据库Schema	@backend-engineer	@architect	-

Orchestration Best Practices

编排最佳实践

DO:

✅ Use TodoWrite to track all tasks
✅ Run independent agents in parallel
✅ Load relevant skills before implementation
✅ Consult experts (architect, security, performance) early
✅ Web search for documentation and best practices
✅ Mark todos as completed immediately
✅ Run tests frequently
✅ Keep security and performance experts in the loop

DON'T:

❌ Skip plan analysis
❌ Assign complex tasks to junior-engineer
❌ Forget to load appropriate skills
❌ Implement security features without security-expert review
❌ Skip performance review for critical paths
❌ Make architectural decisions without architect consultation
❌ Forget to update tests
❌ Leave todos in "in_progress" state

建议：

✅ 使用TodoWrite追踪所有任务
✅ 并行运行独立Agent
✅ 实施前加载相关Skill
✅ 尽早咨询专家（架构师、安全、性能）
✅ 搜索文档与最佳实践
✅ 立即标记待办事项为已完成
✅ 频繁运行测试
✅ 让安全与性能专家全程参与

禁止：

❌ 跳过计划分析
❌ 将复杂任务分配给junior-engineer
❌ 忘记加载合适的Skill
❌ 在未经过security-expert评审的情况下实现安全功能
❌ 跳过关键路径的性能评审
❌ 在未咨询architect的情况下做出架构决策
❌ 忘记更新测试
❌ 让待办事项停留在“进行中”状态

Error Handling

错误处理

If implementation fails:

Analyze the error: What went wrong? Which component?
Consult appropriate expert: Type errors → Architect, Security → Security Expert
Assign fix: Simple → junior-engineer, Complex → specialist
Verify fix: Run tests, check functionality, update todos

若实施失败：

分析错误：哪里出问题了？哪个组件？
咨询对应专家：类型错误→架构师，安全问题→安全专家
分配修复任务：简单任务→junior-engineer，复杂任务→专业Agent
验证修复：运行测试，检查功能，更新待办事项

Execution Checklist

执行检查清单

Additional Resources

额外资源

Reference Files

参考文件

references/agent-selection.md
- Detailed rules for choosing the right agent for each task type
references/parallel-execution.md
- Strategies for coordinating parallel agent execution
references/execution-workflow.md
- Step-by-step implementation workflow with examples
references/quality-assurance.md
- Comprehensive QA guidelines for security, performance, and code quality
references/completion-workflow.md
- Final steps, status updates, and summary generation

references/agent-selection.md
- 针对各任务类型选择合适Agent的详细规则
references/parallel-execution.md
- 协调Agent并行执行的策略
references/execution-workflow.md
- 带示例的分步实施工作流
references/quality-assurance.md
- 关于安全、性能与代码质量的全面QA指南
references/completion-workflow.md
- 最终步骤、状态更新与总结生成

Quick Start Example

快速入门示例

1. User: "/implement" (after planning session)
2. Create todo list from plan sections
3. Start task 1: Consult @architect
4. Execute task 1: Assign to @backend-engineer
5. Verify task 1: Run tests
6. Mark task 1 complete
7. Continue through all tasks
8. Display summary

1. 用户："/implement"（规划环节之后）
2. 根据计划各部分创建待办事项列表
3. 启动任务1：咨询@architect
4. 执行任务1：分配给@backend-engineer
5. 验证任务1：运行测试
6. 标记任务1为已完成
7. 继续处理所有任务
8. 展示总结

Summary

总结

Use this skill to orchestrate complex implementations by:

Analyzing plan requirements and breaking into tasks
Assigning tasks to appropriate agents based on complexity
Coordinating parallel execution where possible
Consulting experts (architect, security, performance) early
Ensuring quality through comprehensive reviews
Tracking progress with todos
Completing implementation with full documentation and testing

The resulting implementations are production-ready, thoroughly tested, and properly documented.

使用本Skill来编排复杂实施工作：

分析计划需求并拆解为任务
根据复杂度将任务分配给合适的Agent
尽可能协调并行执行
尽早咨询专家（架构师、安全、性能）
通过全面评审保障质量
用待办事项追踪进度
完成实施并生成完整文档与测试

最终的实施结果可用于生产环境，经过全面测试且文档齐全。