分解重建

其他 社区

技能解读

当前原文的自动摘译,尚未人工审校。

工作流程

复制此清单并跟踪您的进度: 步骤 1:定义系统和目标 要求用户描述系统(我们正在分析什么)、当前问题或目标(什么需要改进、理解或重新设计)、边界(什么在范围内,什么在范围外)以及成功标准(什么会“更好”)。清晰的界限可以防止无休止的分解。请参阅范围界定问题以获取澄清提示。

范围界定问题

定义系统:我们正在分析的系统是什么? (具体来说:“结帐流程”而不是“网站”)它从哪里开始和结束? (边界)范围内和范围外的内容是什么? (防止无休止的分解)明确目标:

分解策略

根据系统类型选择:

功能分解

时间:业务流程、软件功能、工作流程 方法:按功能或任务细分 示例:电子商务结账 → 浏览产品 |添加到购物车 |输入运费 |付款|确认

结构分解

时间:架构、组织、物理系统 方法:按组件或模块细分 示例:Web 应用程序 → 前端 (React) | API (Node.js) |数据库(PostgreSQL)|缓存(Redis)

流狐档案 运行与权限由流狐静态检查推断,不代表作者声明或实际测试结果。
领域
通用
作者声明的智能体
未找到明确声明;不据此推断已兼容或已测试
静态检查
88 / 100 · 启发式扫描,不代表运行安全
运行环境证据
未执行;当前没有隔离运行测试证据
作者 / 版本 / 许可证
@lyndonkl · 未声明许可证
上下文用量评级
低消耗
接入复杂程度
需简单配置
是否需要外部接口密钥
不需要
兼容的系统
macOS · Linux · Windows
运行环境要求
Node.js
检测到的文件与系统行为
  • 只读
  • 允许写入 / 修改
  • 命令执行
网络行为
允许外网请求
安装命令数
无(仅作为资料)

需要注意: 未声明工具权限范围;实际权限由运行环境决定。

作者说明文件(原文) SKILL.md

# Decomposition & Reconstruction

## Workflow

Copy this checklist and track your progress:

```
Decomposition & Reconstruction Progress:
- [ ] Step 1: Define the system and goal
- [ ] Step 2: Decompose into components and relationships
- [ ] Step 3: Analyze component properties and interactions
- [ ] Step 4: Reconstruct for insight or optimization
- [ ] Step 5: Validate and deliver recommendations
```

**Step 1: Define the system and goal**

Ask user to describe the system (what are we analyzing), current problem or goal (what needs improvement, understanding, or redesign), boundaries (what's in scope vs out of scope), and success criteria (what would "better" look like). Clear boundaries prevent endless decomposition. See [Scoping Questions](#scoping-questions) for clarification prompts.

**Step 2: Decompose into components and relationships**

Break system into atomic parts that can't be meaningfully subdivided further. Identify relationships (dependencies, data flow, control flow, temporal ordering). Choose decomposition strategy based on system type. See [Decomposition Strategies](#decomposition-strategies) and [resources/template.md](resources/template.md) for structured process.

**Step 3: Analyze component properties and interactions**

For each component, identify key properties (cost, time, complexity, reliability, etc.). Map interactions (which components depend on which). Identify critical paths, bottlenecks, or vulnerable points. For complex analysis → See [resources/methodology.md](resources/methodology.md) for dependency mapping and critical path techniques.

**Step 4: Reconstruct for insight or optimization**

Based on goal, either: (a) Identify critical components (bottleneck, single point of failure, highest cost driver), (b) Redesign configuration (reorder, parallelize, eliminate, combine components), or (c) Simplify (remove unnecessary components). See [Reconstruction Patterns](#reconstruction-patterns) for common approaches.

**Step 5: Validate and deliver recommendations**

Self-assess using [resources/evaluators/rubric_decomposition_reconstruction.json](resources/evaluators/rubric_decomposition_reconstruction.json) (minimum score ≥ 3.5). Present decomposition-reconstruction.md with clear component breakdown, analysis findings (bottlenecks, dependencies), and actionable recommendations with expected impact.

## Scoping Questions

**To define the system:**
- What is the system we're analyzing? (Be specific: "checkout flow" not "website")
- Where does it start and end? (Boundaries)
- What's in scope vs out of scope? (Prevents endless decomposition)

**To clarify the goal:**
- What problem are we solving? (Slow performance, high cost, complexity, unreliability)
- What would success look like? (Specific target: "reduce latency to <500ms", "cut costs by 30%")
- Are we optimizing, understanding, or redesigning?

**To understand constraints:**
- What can't we change? (Legacy systems, budget limits, regulatory requirements)
- What's the time horizon? (Quick wins vs long-term redesign)
- Who are the stakeholders? (Engineering, business, customers)

## Decomposition Strategies

Choose based on system type:

### Functional Decomposition
**When:** Business processes, software features, workflows
**Approach:** Break down by function or task
**Example:** E-commerce checkout → Browse products | Add to cart | Enter shipping | Payment | Confirmation

### Structural Decomposition
**When:** Architecture, organizations, physical systems
**Approach:** Break down by component or module
**Example:** Web app → Frontend (React) | API (Node.js) | Database (PostgreSQL) | Cache (Redis)

### Data Flow Decomposition
**When:** Pipelines, ETL processes, information systems
**Approach:** Break down by data transformations
**Example:** Analytics pipeline → Ingest raw events | Clean & validate | Aggregate metrics | Store in warehouse | Visualize in dashboard

### Temporal Decomposition
**When:** Processes with sequential stages, timelines, user journeys
**Approach:** Break down by time or sequence
**Example:** Customer onboarding → Day 1: Signup | Day 2-7: Tutorial | Day 8-30: First value moment | Day 31+: Retention

### Cost/Resource Decomposition
**When:** Budget analysis, resource allocation, optimization
**Approach:** Break down by cost center or resource type
**Example:** AWS bill → Compute ($5K) | Storage ($2K) | Data transfer ($1K) | Other ($500)

**Depth guideline:** Stop decomposing when further breakdown doesn't reveal useful insights or actionable opportunities.

## Component Relationship Types

After decomposition, map relationships:

**1. Dependency (A requires B):**
- API service depends on database
- Frontend depends on API
- Critical for: Identifying cascading failures, understanding change impact

**2. Data flow (A sends data to B):**
- User input → Validation → Database → API response
- Critical for: Tracing information, finding transformation bottlenecks

**3. Control flow (A triggers B):**
- Button click triggers form submission
- Payment success triggers order fulfillment
- Critical for: Understanding execution paths, identifying race conditions

**4. Temporal ordering (A before B in time):**
- Authentication before authorization
- Compile before deploy
- Critical for: Sequencing, finding parallelization opportunities

**5. Resource sharing (A and B compete for C):**
- Multiple services share database connection pool
- Teams share budget
- Critical for: Identifying contention, resource constraints

## Reconstruction Patterns

### Pattern 1: Bottleneck Identification
**Goal:** Find what limits system throughput or speed
**Approach:** Measure component properties (time, cost, capacity), identify critical path or highest value
**Example:** DB query takes 80% of request time → Optimize DB query first

### Pattern 2: Simplification
**Goal:** Reduce complexity by removing unnecessary parts
**Approach:** Question necessity of each component, eliminate redundant or low-value parts
**Example:** Workflow has 5 approval steps, 3 are redundant → Remove 3 steps

### Pattern 3: Reordering
**Goal:** Improve efficiency by changing sequence
**Approach:** Identify dependencies, move independent tasks earlier or parallel
**Example:** Run tests parallel to build instead of sequential → Reduce CI time

### Pattern 4: Parallelization
**Goal:** Increase throughput by doing work concurrently
**Approach:** Find independent components, execute simultaneously
**Example:** Fetch user data and product data in parallel instead of serial → Cut latency in half

### Pattern 5: Substitution
**Goal:** Replace weak component with better alternative
**Approach:** Identify underperforming component, find replacement
**Example:** Replace synchronous API call with async message queue → Improve reliability

### Pattern 6: Consolidation
**Goal:** Reduce overhead by combining similar components
**Approach:** Find redundant or overlapping components, merge them
**Example:** Consolidate 3 microservices doing similar work into 1 → Reduce operational overhead

### Pattern 7: Modularization
**Goal:** Improve maintainability by separating concerns
**Approach:** Identify tightly coupled components, separate with clear interfaces
**Example:** Extract auth logic from monolith into separate service → Enable independent scaling

## When NOT to Use This Skill

**Skip decomposition-reconstruction if:**
- System is already simple (3-5 obvious components, no complex interactions)
- Problem is not about system structure (purely execution issue, not design issue)
- You need creativity/ideation (not analysis) - use brainstorming instead
- System is poorly understood (need discovery/research first, not decomposition)
- Changes are impossible (no point analyzing if you can't act on findings)

**Use instead:**
- Simple system → Direct analysis or observation
- Execution problem → Project management, process improvement
- Need ideas → Brainstorming, design thinking
- Unknown system → Discovery interviews, research
- Unchangeable → Workaround planning, constraint optimization

## Common Patterns by Domain

**Software Architecture:**
- Decompose: Modules, services, layers, data stores
- Reconstruct for: Microservices migration, performance optimization, reducing coupling

**Business Processes:**
- Decompose: Steps, decision points, handoffs, approvals
- Reconstruct for: Cycle time reduction, automation opportunities, removing waste

**Problem Solving:**
- Decompose: Sub-problems, dependencies, unknowns, constraints
- Reconstruct for: Task sequencing, identifying blockers, finding parallelizable work

**Cost Optimization:**
- Decompose: Cost centers, line items, resource usage
- Reconstruct for: Identifying biggest cost drivers, finding quick wins

**User Experience:**
- Decompose: User journey stages, interactions, pain points
- Reconstruct for: Simplifying flows, removing friction, improving conversion

**System Reliability:**
- Decompose: Components, failure modes, dependencies
- Reconstruct for: Identifying single points of failure, improving resilience

## Quick Reference

**Process:**
1. Define system and goal → Set boundaries
2. Decompose → Break into components and relationships
3. Analyze → Measure properties, map interactions
4. Reconstruct → Optimize, simplify, or redesign
5. Validate → Check against rubric, deliver recommendations

**Decomposition strategies:**
- Functional (by task), Structural (by component), Data flow, Temporal, Cost/Resource

**Reconstruction patterns:**
- Bottleneck ID, Simplification, Reordering, Parallelization, Substitution, Consolidation, Modularization

**Resources:**
- [resources/template.md](resources/template.md) - Structured decomposition process with templates
- [resources/methodology.md](resources/methodology.md) - Advanced techniques (dependency graphs, critical path analysis, hierarchical decomposition)
- [resources/evaluators/rubric_decomposition_reconstruction.json](resources/evaluators/rubric_decomposition_reconstruction.json) - Quality checklist

**Deliverable:** `decomposition-reconstruction.md` with component breakdown, analysis, and recommendations

讨论

基于 GitHub Discussions。登录 GitHub 即可参与讨论、点赞、订阅更新。