meta-cognition-parallel by zhanghandong/rust-skills
npx skills add https://github.com/zhanghandong/rust-skills --skill meta-cognition-parallel状态: 实验性 | 版本: 0.2.0 | 最后更新: 2025-01-27
此技能测试并行的三层认知分析。
此技能不采用顺序分析,而是启动三个并行分析器——每个对应一个认知层——然后综合它们的结果。
User Question
│
▼
┌─────────────────────────────────────────────────────┐
│ meta-cognition-parallel │
│ (Coordinator) │
└─────────────────────────────────────────────────────┘
│
├─── Layer 1 ──► Language Mechanics ──► L1 Result
│
├─── Layer 2 ──► Design Choices ──► L2 Result
│ ├── Parallel (Agent Mode)
│ │ or Sequential (Inline)
└─── Layer 3 ──► Domain Constraints ──► L3 Result
│
▼
┌─────────────────────────────────────────────────────┐
│ Cross-Layer Synthesis │
│ (In main context with all results) │
└─────────────────────────────────────────────────────┘
│
▼
Domain-Correct Architectural Solution
广告位招租
在这里展示您的产品或服务
触达数万 AI 开发者,精准高效
/meta-parallel <你的 Rust 问题>
示例:
/meta-parallel 我的交易系统报 E0382 错误,应该用 clone 吗?
关键:首先检查代理文件可用性以确定执行模式。
尝试读取层分析器文件:
../../agents/layer1-analyzer.md../../agents/layer2-analyzer.md../../agents/layer3-analyzer.md当所有层分析器文件都存在于 ../../agents/ 时:
从 $ARGUMENTS 中提取:
关键:在单条消息中启动所有三个 Task 以实现并行执行。
Read agent files, then launch in parallel:
Task(
subagent_type: "general-purpose",
run_in_background: true,
prompt: <content of ../../agents/layer1-analyzer.md>
+ "\n\n## User Query\n" + $ARGUMENTS
)
Task(
subagent_type: "general-purpose",
run_in_background: true,
prompt: <content of ../../agents/layer2-analyzer.md>
+ "\n\n## User Query\n" + $ARGUMENTS
)
Task(
subagent_type: "general-purpose",
run_in_background: true,
prompt: <content of ../../agents/layer3-analyzer.md>
+ "\n\n## User Query\n" + $ARGUMENTS
)
等待所有三个代理完成。每个代理返回结构化分析。
获得所有三个结果后,按照下面的模板进行综合。
当层分析器文件不可用时,直接执行分析:
与代理模式相同 - 从 $ARGUMENTS 中提取问题、代码和领域提示。
分析涉及的 Rust 语言机制:
## Layer 1: Language Mechanics
**Error/Pattern Identified:**
- Error code: E0XXX (if applicable)
- Pattern: ownership/borrowing/lifetime/etc.
**Root Cause:**
[Explain why this error occurs in terms of Rust's ownership model]
**Language-Level Solutions:**
1. [Solution 1]: description
2. [Solution 2]: description
**Confidence:** HIGH | MEDIUM | LOW
**Reasoning:** [Why this confidence level]
关注领域:
分析设计模式和权衡:
## Layer 2: Design Choices
**Design Pattern Context:**
- Current approach: [What pattern is being used]
- Problem: [Why it conflicts with Rust's rules]
**Design Alternatives:**
| Pattern | Pros | Cons | When to Use |
|---------|------|------|-------------|
| Pattern A | ... | ... | ... |
| Pattern B | ... | ... | ... |
**Recommended Pattern:**
[Which pattern fits best and why]
**Confidence:** HIGH | MEDIUM | LOW
**Reasoning:** [Why this confidence level]
关注领域:
分析领域特定需求:
## Layer 3: Domain Constraints
**Domain Identified:** [trading/fintech | web | CLI | embedded | etc.]
**Domain-Specific Requirements:**
- [ ] Performance: [requirements]
- [ ] Safety: [requirements]
- [ ] Concurrency: [requirements]
- [ ] Auditability: [requirements]
**Domain Best Practices:**
1. [Best practice 1]
2. [Best practice 2]
**Constraints on Solution:**
- MUST: [hard requirements]
- SHOULD: [soft requirements]
- AVOID: [anti-patterns for this domain]
**Confidence:** HIGH | MEDIUM | LOW
**Reasoning:** [Why this confidence level]
关注领域:
结合所有三层:
## Cross-Layer Synthesis
### Layer Results Summary
| Layer | Key Finding | Confidence |
|-------|-------------|------------|
| L1 (Mechanics) | [Summary] | [Level] |
| L2 (Design) | [Summary] | [Level] |
| L3 (Domain) | [Summary] | [Level] |
### Cross-Layer Reasoning
1. **L3 → L2:** [How domain constraints affect design choice]
2. **L2 → L1:** [How design choice determines mechanism]
3. **L1 ← L3:** [Direct domain impact on language features]
### Synthesized Recommendation
**Problem:** [Restated with full context]
**Solution:** [Domain-correct architectural solution]
**Rationale:**
- Domain requires: [L3 constraint]
- Design pattern: [L2 pattern]
- Mechanism: [L1 implementation]
### Confidence Assessment
- **Overall:** HIGH | MEDIUM | LOW
- **Limiting Factor:** [Which layer had lowest confidence]
两种模式产生相同的输出格式:
# Three-Layer Meta-Cognition Analysis
> Query: [User's question]
---
## Layer 1: Language Mechanics
[L1 analysis result]
---
## Layer 2: Design Choices
[L2 analysis result]
---
## Layer 3: Domain Constraints
[L3 analysis result]
---
## Cross-Layer Synthesis
### Reasoning Chain
L3 Domain: [Constraint] ↓ implies L2 Design: [Pattern] ↓ implemented via L1 Mechanism: [Feature]
### Final Recommendation
**Do:** [Recommended approach]
**Don't:** [What to avoid]
**Code Pattern:**
```rust
// Recommended implementation
Analysis performed by meta-cognition-parallel v0.2.0 (experimental)
/meta-parallel 交易系统报 E0382,trade record 被 move 了
预期:L3 识别金融科技约束 → L2 建议共享不可变 → L1 推荐 Arc<T>
/meta-parallel Web API 中多个 handler 需要共享数据库连接池
预期:L3 识别 Web 约束 → L2 建议连接池 → L1 推荐 Arc<Pool>
/meta-parallel CLI 工具如何处理配置文件和命令行参数的优先级
预期:L3 识别 CLI 约束 → L2 建议配置优先级模式 → L1 推荐构建器模式
| 错误 | 原因 | 解决方案 |
|---|---|---|
| Agent files not found | Skills-only install | Use inline mode (sequential) |
| Agent timeout | Complex analysis | Wait longer or use inline mode |
| Incomplete layer result | Agent issue | Fill in with inline analysis |
这是实验性功能。请报告问题和建议以改进三层分析方法。
每周安装数
498
代码仓库
GitHub 星标数
929
首次出现
Jan 21, 2026
安全审计
安装于
opencode456
codex446
gemini-cli439
github-copilot426
amp384
kimi-cli381
Status: Experimental | Version: 0.2.0 | Last Updated: 2025-01-27
This skill tests parallel three-layer cognitive analysis.
Instead of sequential analysis, this skill launches three parallel analyzers - one for each cognitive layer - then synthesizes their results.
User Question
│
▼
┌─────────────────────────────────────────────────────┐
│ meta-cognition-parallel │
│ (Coordinator) │
└─────────────────────────────────────────────────────┘
│
├─── Layer 1 ──► Language Mechanics ──► L1 Result
│
├─── Layer 2 ──► Design Choices ──► L2 Result
│ ├── Parallel (Agent Mode)
│ │ or Sequential (Inline)
└─── Layer 3 ──► Domain Constraints ──► L3 Result
│
▼
┌─────────────────────────────────────────────────────┐
│ Cross-Layer Synthesis │
│ (In main context with all results) │
└─────────────────────────────────────────────────────┘
│
▼
Domain-Correct Architectural Solution
/meta-parallel <your Rust question>
Example:
/meta-parallel 我的交易系统报 E0382 错误,应该用 clone 吗?
CRITICAL: Check agent file availability first to determine execution mode.
Try to read layer analyzer files:
../../agents/layer1-analyzer.md../../agents/layer2-analyzer.md../../agents/layer3-analyzer.mdWhen all layer analyzer files exist at../../agents/:
Extract from $ARGUMENTS:
CRITICAL: Launch all three Tasks in a SINGLE message to enable parallel execution.
Read agent files, then launch in parallel:
Task(
subagent_type: "general-purpose",
run_in_background: true,
prompt: <content of ../../agents/layer1-analyzer.md>
+ "\n\n## User Query\n" + $ARGUMENTS
)
Task(
subagent_type: "general-purpose",
run_in_background: true,
prompt: <content of ../../agents/layer2-analyzer.md>
+ "\n\n## User Query\n" + $ARGUMENTS
)
Task(
subagent_type: "general-purpose",
run_in_background: true,
prompt: <content of ../../agents/layer3-analyzer.md>
+ "\n\n## User Query\n" + $ARGUMENTS
)
Wait for all three agents to complete. Each returns structured analysis.
With all three results, perform synthesis per template below.
When layer analyzer files are NOT available, execute analysis directly:
Same as Agent Mode - extract question, code, and domain hints from $ARGUMENTS.
Analyze the Rust language mechanics involved:
## Layer 1: Language Mechanics
**Error/Pattern Identified:**
- Error code: E0XXX (if applicable)
- Pattern: ownership/borrowing/lifetime/etc.
**Root Cause:**
[Explain why this error occurs in terms of Rust's ownership model]
**Language-Level Solutions:**
1. [Solution 1]: description
2. [Solution 2]: description
**Confidence:** HIGH | MEDIUM | LOW
**Reasoning:** [Why this confidence level]
Focus areas:
Analyze the design patterns and trade-offs:
## Layer 2: Design Choices
**Design Pattern Context:**
- Current approach: [What pattern is being used]
- Problem: [Why it conflicts with Rust's rules]
**Design Alternatives:**
| Pattern | Pros | Cons | When to Use |
|---------|------|------|-------------|
| Pattern A | ... | ... | ... |
| Pattern B | ... | ... | ... |
**Recommended Pattern:**
[Which pattern fits best and why]
**Confidence:** HIGH | MEDIUM | LOW
**Reasoning:** [Why this confidence level]
Focus areas:
Analyze domain-specific requirements:
## Layer 3: Domain Constraints
**Domain Identified:** [trading/fintech | web | CLI | embedded | etc.]
**Domain-Specific Requirements:**
- [ ] Performance: [requirements]
- [ ] Safety: [requirements]
- [ ] Concurrency: [requirements]
- [ ] Auditability: [requirements]
**Domain Best Practices:**
1. [Best practice 1]
2. [Best practice 2]
**Constraints on Solution:**
- MUST: [hard requirements]
- SHOULD: [soft requirements]
- AVOID: [anti-patterns for this domain]
**Confidence:** HIGH | MEDIUM | LOW
**Reasoning:** [Why this confidence level]
Focus areas:
Combine all three layers:
## Cross-Layer Synthesis
### Layer Results Summary
| Layer | Key Finding | Confidence |
|-------|-------------|------------|
| L1 (Mechanics) | [Summary] | [Level] |
| L2 (Design) | [Summary] | [Level] |
| L3 (Domain) | [Summary] | [Level] |
### Cross-Layer Reasoning
1. **L3 → L2:** [How domain constraints affect design choice]
2. **L2 → L1:** [How design choice determines mechanism]
3. **L1 ← L3:** [Direct domain impact on language features]
### Synthesized Recommendation
**Problem:** [Restated with full context]
**Solution:** [Domain-correct architectural solution]
**Rationale:**
- Domain requires: [L3 constraint]
- Design pattern: [L2 pattern]
- Mechanism: [L1 implementation]
### Confidence Assessment
- **Overall:** HIGH | MEDIUM | LOW
- **Limiting Factor:** [Which layer had lowest confidence]
Both modes produce the same output format:
# Three-Layer Meta-Cognition Analysis
> Query: [User's question]
---
## Layer 1: Language Mechanics
[L1 analysis result]
---
## Layer 2: Design Choices
[L2 analysis result]
---
## Layer 3: Domain Constraints
[L3 analysis result]
---
## Cross-Layer Synthesis
### Reasoning Chain
L3 Domain: [Constraint] ↓ implies L2 Design: [Pattern] ↓ implemented via L1 Mechanism: [Feature]
### Final Recommendation
**Do:** [Recommended approach]
**Don't:** [What to avoid]
**Code Pattern:**
```rust
// Recommended implementation
Analysis performed by meta-cognition-parallel v0.2.0 (experimental)
---
## Test Scenarios
### Test 1: Trading System E0382
/meta-parallel 交易系统报 E0382,trade record 被 move 了
Expected: L3 identifies FinTech constraints → L2 suggests shared immutable → L1 recommends Arc<T>
### Test 2: Web API Concurrency
/meta-parallel Web API 中多个 handler 需要共享数据库连接池
Expected: L3 identifies Web constraints → L2 suggests connection pooling → L1 recommends Arc<Pool>
### Test 3: CLI Tool Config
/meta-parallel CLI 工具如何处理配置文件和命令行参数的优先级
Expected: L3 identifies CLI constraints → L2 suggests config precedence pattern → L1 recommends builder pattern
---
## Error Handling
| Error | Cause | Solution |
|-------|-------|----------|
| Agent files not found | Skills-only install | Use inline mode (sequential) |
| Agent timeout | Complex analysis | Wait longer or use inline mode |
| Incomplete layer result | Agent issue | Fill in with inline analysis |
## Limitations
- **Agent Mode:** Parallel execution, faster but requires plugin install
- **Inline Mode:** Sequential execution, slower but works everywhere
- Cross-layer synthesis quality depends on result structure
- May have higher latency than simple single-layer analysis
## Feedback
This is experimental. Please report issues and suggestions to improve the three-layer analysis approach.
Weekly Installs
498
Repository
GitHub Stars
929
First Seen
Jan 21, 2026
Security Audits
Gen Agent Trust HubFailSocketPassSnykPass
Installed on
opencode456
codex446
gemini-cli439
github-copilot426
amp384
kimi-cli381
React 组合模式指南:Vercel 组件架构最佳实践,提升代码可维护性
106,200 周安装