Rust元认知并行分析工具 - 三层并行认知分析解决编程问题

meta-cognition-parallel by zhanghandong/rust-skills

499 周安装量

941 GitHub Stars

GitHub

安装命令

npx skills add https://github.com/zhanghandong/rust-skills --skill meta-cognition-parallel

开发系统架构 Rust

🇨🇳中文介绍

元认知并行分析（实验性）

状态： 实验性 | 版本： 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 开发者，精准高效

联系我们

代理模式（插件安装）- 并行执行

当所有层分析器文件都存在于 ../../agents/ 时：

步骤 1：解析用户查询

从 $ARGUMENTS 中提取：

原始问题
任何代码片段
领域提示（交易、Web、嵌入式等）

步骤 2：启动三个并行代理

关键：在单条消息中启动所有三个 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
)

步骤 3：收集结果

等待所有三个代理完成。每个代理返回结构化分析。

步骤 4：跨层综合

获得所有三个结果后，按照下面的模板进行综合。

内联模式（仅技能安装）- 顺序执行

当层分析器文件不可用时，直接执行分析：

步骤 1：解析用户查询

与代理模式相同 - 从 $ARGUMENTS 中提取问题、代码和领域提示。

步骤 2：执行第 1 层 - 语言机制

分析涉及的 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]

所有权规则（移动、复制、借用）
生命周期注解
借用规则（共享 vs 可变）
错误代码及其含义

步骤 3：执行第 2 层 - 设计选择

分析设计模式和权衡：

## 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]

智能指针选择（Box, Rc, Arc）
内部可变性模式（Cell, RefCell, Mutex）
所有权转移 vs 共享
克隆 vs 引用

步骤 4：执行第 3 层 - 领域约束

分析领域特定需求：

## 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]

行业需求（金融科技法规、Web 可扩展性等）
性能约束
安全性和正确性要求
该领域的常见模式

步骤 5：跨层综合

结合所有三层：

## 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)

测试 1：交易系统 E0382

/meta-parallel 交易系统报 E0382，trade record 被 move 了

预期：L3 识别金融科技约束 → L2 建议共享不可变 → L1 推荐 Arc<T>

测试 2：Web API 并发

/meta-parallel Web API 中多个 handler 需要共享数据库连接池

预期：L3 识别 Web 约束 → L2 建议连接池 → L1 推荐 Arc<Pool>

测试 3：CLI 工具配置

/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

代理模式： 并行执行，更快但需要插件安装
内联模式： 顺序执行，较慢但随处可用
跨层综合质量取决于结果结构
可能比简单的单层分析有更高的延迟

这是实验性功能。请报告问题和建议以改进三层分析方法。

🇺🇸English

Meta-Cognition Parallel Analysis (Experimental)

Status: Experimental | Version: 0.2.0 | Last Updated: 2025-01-27

This skill tests parallel three-layer cognitive analysis.

Concept

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

Usage

/meta-parallel <your Rust question>

Example:

/meta-parallel 我的交易系统报 E0382 错误，应该用 clone 吗？

Execution Mode Detection

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.md

Agent Mode (Plugin Install) - Parallel Execution

When all layer analyzer files exist at../../agents/:

Step 1: Parse User Query

Extract from $ARGUMENTS:

The original question
Any code snippets
Domain hints (trading, web, embedded, etc.)

Step 2: Launch Three Parallel Agents

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
)

Step 3: Collect Results

Wait for all three agents to complete. Each returns structured analysis.

Step 4: Cross-Layer Synthesis

With all three results, perform synthesis per template below.

Inline Mode (Skills-only Install) - Sequential Execution

When layer analyzer files are NOT available, execute analysis directly:

Step 1: Parse User Query

Same as Agent Mode - extract question, code, and domain hints from $ARGUMENTS.

Step 2: Execute Layer 1 - Language Mechanics

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:

Ownership rules (move, copy, borrow)
Lifetime annotations
Borrowing rules (shared vs mutable)
Error codes and their meanings

Step 3: Execute Layer 2 - Design Choices

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:

Smart pointer choices (Box, Rc, Arc)
Interior mutability patterns (Cell, RefCell, Mutex)
Ownership transfer vs sharing
Cloning vs references

Step 4: Execute Layer 3 - Domain Constraints

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:

Industry requirements (FinTech regulations, web scalability, etc.)
Performance constraints
Safety and correctness requirements
Common patterns in the domain

Step 5: Cross-Layer Synthesis

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]

Output Template

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

zhanghandong/rust-skills

GitHub Stars

929

First Seen

Jan 21, 2026

Security Audits

Gen Agent Trust HubFail SocketPass SnykPass

Installed on

opencode456

codex446

gemini-cli439

github-copilot426

amp384

kimi-cli381

React 组合模式指南：Vercel 组件架构最佳实践，提升代码可维护性

106,200 周安装

Rust元认知并行分析工具 - 三层并行认知分析解决编程问题

🇨🇳中文介绍

元认知并行分析（实验性）

概念

用法

相关 Skills

执行模式检测

代理模式（插件安装）- 并行执行

步骤 1：解析用户查询

步骤 2：启动三个并行代理

步骤 3：收集结果

步骤 4：跨层综合

内联模式（仅技能安装）- 顺序执行

步骤 1：解析用户查询

步骤 2：执行第 1 层 - 语言机制

步骤 3：执行第 2 层 - 设计选择

步骤 4：执行第 3 层 - 领域约束

步骤 5：跨层综合

输出模板

测试场景

测试 1：交易系统 E0382

测试 2：Web API 并发

测试 3：CLI 工具配置

错误处理

限制

反馈

🇺🇸English

Meta-Cognition Parallel Analysis (Experimental)

Concept

Usage

Execution Mode Detection

Agent Mode (Plugin Install) - Parallel Execution

Step 1: Parse User Query

Step 2: Launch Three Parallel Agents

Step 3: Collect Results

Step 4: Cross-Layer Synthesis

Inline Mode (Skills-only Install) - Sequential Execution

Step 1: Parse User Query

Step 2: Execute Layer 1 - Language Mechanics

Step 3: Execute Layer 2 - Design Choices

Step 4: Execute Layer 3 - Domain Constraints

Step 5: Cross-Layer Synthesis

Output Template

最新 Skills