00-meta-chain-flow-150

[00] META. Orchestrate skills into dynamic chains for complex tasks. Analyzes the task, discovers available skills, builds an optimal chain, explains why each skill is needed, and executes step-by-step with user confirmation. Use for any complex task requiring multiple thinking/research/analysis steps. Triggers on "plan this", "how to approach", "what's the strategy", "build a plan", or any multi-step problem requiring skill orchestration.

1.56x

Quality

88%

Does it follow best practices?

Impact

89%

1.56x

Average score across 3 eval scenarios

Securityby

Passed

No known issues

Meta-Chain-Flow 150 Protocol

Core Principle: Orchestrate skills dynamically. Analyze the task, discover available skills, build the right chain, explain the reasoning, execute step-by-step with confirmation.

What This Skill Does

This is a meta-skill — an orchestrator that:

Analyzes the task to understand what's needed
Discovers available skills (finds where they are, what exists)
Builds a chain of appropriate skills in the right order
Explains why each skill is in the chain
Executes step-by-step with user confirmation
Adapts the chain as new information emerges

The Orchestration Model

🔗 CHAIN-FLOW 150 (Orchestrator)
        ↓
[1. Analyze Task] → What type of problem is this?
        ↓
[2. Discover Skills] → What skills are available? Where?
        ↓
[3. Build Chain] → Which skills? In what order?
        ↓
[4. Explain Why] → Justify each skill in the chain
        ↓
[5. Execute] → Step by step with confirmation
        ↓
[6. Adapt] → Modify chain if situation changes

Skill Discovery

Chain-Flow finds available skills by:

Where to Look for Skills

📁 SKILL LOCATIONS (search in order)
├── ./.codex/skills/          # Project skills folder (canonical)
├── ./skills/                 # Legacy project skills (if present)
├── ./.claude/skills/         # Legacy project Claude skills (if present)
├── ~/.claude/skills/         # Personal skills (home directory, if present)
├── Plugin skills             # From installed plugins
└── Built-in capabilities     # Agent's native abilities

How to Discover Skills

# Find all skill directories
ls -la ./.codex/skills/ 2>/dev/null
ls -la ./skills/ 2>/dev/null
ls -la ./.claude/skills/ 2>/dev/null
ls -la ~/.claude/skills/ 2>/dev/null

# Read each SKILL.md to understand capabilities
cat ./.codex/skills/*/SKILL.md | head -20  # Read descriptions

Discovery Process

Scan directories — Find all folders with SKILL.md
Read name + description — Understand what each skill does
Map triggers — Know when each skill applies
Build skill inventory — Create list of available skills
Match to task — Select relevant skills for current task

The 150% Orchestration Rule

100% Core: Build appropriate skill chain + execute with confirmation
50% Enhancement: Explain reasoning + adapt chain dynamically

When to Use This Skill

Universal trigger: Any complex task that needs multiple skills combined.

Specific triggers:

Complex multi-step problems
Tasks requiring research + thinking + execution
When you're not sure which approach to take
Strategic planning for projects
Any request where single skill isn't enough

Key insight: Most real problems need chains of skills, not single skills.

Chain Building Process

Step 1: ANALYZE THE TASK

Understand what the task requires:

What's the nature of the problem?
What types of thinking/research/execution needed?
What's the complexity level?
What are the unknowns?

Step 2: DISCOVER AVAILABLE SKILLS

Find what skills are available:

🔍 Skill Discovery:
- Scanning ./.codex/skills/ ...
- Scanning ./skills/ ...
- Scanning ./.claude/skills/ ...
- Scanning ~/.claude/skills/ ...

Found Skills:
├── goal-clarity-150    — Clarify objectives and success criteria
├── research-deep-150   — Deep research from internal + external sources
├── impact-map-150      — Map what changes affect
├── action-plan-150     — Create actionable plans with steps/risks
├── deep-think-150      — Quality reasoning and analysis
├── max-quality-150     — High quality execution
├── 74-mid-session-save-150    — Mid-session checkpoint for continuity
├── gated-exec-150      — Execute with confirmation gates
├── proof-grade-150     — Verify facts with confidence levels
├── integrity-check-150 — Final quality self-check
├── task-track-150      — Manage task lifecycle and status
├── tidy-up-150         — Quick cleanup after milestones
├── ask-ai-150          — Consult external AI models
└── skill-forge-150     — Create new skills when needed

Reading descriptions to match task requirements...

Step 3: BUILD THE CHAIN

Construct the skill sequence:

Which skills are relevant?
What's the logical order?
Are there dependencies between skills?

Step 4: EXPLAIN THE CHAIN

Justify each skill:

📋 Proposed Chain:

1. goal-clarity-150
   WHY: Task requirements are ambiguous, need to clarify first

2. research-deep-150  
   WHY: Need to understand current system + best practices

3. impact-map-150
   WHY: Changes will affect multiple components

4. deep-think-150
   WHY: Architecture decision with trade-offs

5. max-quality-150
   WHY: Critical feature, needs high quality execution

Step 5: EXECUTE WITH CONFIRMATION

Go step by step:

🔗 Chain Execution:

Step 1/5: goal-clarity-150
[Execute skill...]
✅ Complete. Proceed to Step 2? (Yes/No/Modify chain)

Step 6: ADAPT IF NEEDED

Modify chain based on new information:

🔄 Chain Adaptation:

New information discovered: Security implications found
→ Adding: security-check skill after impact-map
→ Updated chain: 1→2→3→3.5(new)→4→5

Continue with updated chain? (Yes/No)

Output Format

When using Chain-Flow 150:

🔗 **Chain-Flow 150 Activated**

**Task Analysis:**
[Understanding of what's needed]

**Skills Discovered:**
- [List of available skills with brief descriptions]

**Proposed Chain:**

[skill-name] → WHY: [justification]
[skill-name] → WHY: [justification]
[skill-name] → WHY: [justification] ...

**Execution Plan:**
- Estimated steps: [N]
- Confirmation: After each skill
- Adaptation: Will modify if needed

**Ready to begin chain execution?**

Chain Execution Format

During execution:

🔗 **Chain-Flow: Step [X/N]**

**Current Skill:** [skill-name]
**Purpose:** [why this skill now]

[Skill execution output...]

**Step Complete:** ✅

**Next:** [next-skill-name]
**Continue?** (Yes / No / Modify Chain / Skip to Step N)

Common Chain Patterns

Pattern: New Feature Development

goal-clarity-150 → research-deep-150 → impact-map-150 → 
action-plan-150 → max-quality-150

Pattern: Complex Project

goal-clarity-150 → research-deep-150 → impact-map-150 → 
deep-think-150 → action-plan-150 → max-quality-150

Pattern: Bug Investigation

research-deep-150 (logs, git) → impact-map-150 → 
deep-think-150 → action-plan-150 (fix steps) → max-quality-150

Pattern: Architecture Decision

goal-clarity-150 → research-deep-150 (options) → 
deep-think-150 (trade-offs) → impact-map-150 → action-plan-150

Pattern: Code Review

research-deep-150 (understand) → impact-map-150 → 
deep-think-150 (issues) → max-quality-150 (feedback)

Pattern: Migration/Refactoring

goal-clarity-150 → impact-map-150 → research-deep-150 → 
action-plan-150 (detailed steps) → max-quality-150

Operational Rules

DISCOVER FIRST: Always find what skills are available
JUSTIFY EACH: Explain why each skill is in the chain
CONFIRM STEPS: Get user confirmation between skills
ADAPT FREELY: Modify chain when new information emerges
SKIP ALLOWED: User can skip skills if not needed
CHAIN IS FLEXIBLE: Not rigid — adjust to reality

Failure Modes & Recovery

Failure	Detection	Recovery
Wrong chain	Results don't help	Re-analyze, rebuild chain
Missing skill	Gap in chain	Add skill or use alternative
Wrong order	Dependencies broken	Reorder chain
Over-engineering	Too many skills	Simplify chain
Under-engineering	Skipped needed skill	Add missing skill

Examples

❌ Without Chain-Flow

User: "Add payment processing to the app"
AI: [Jumps straight to coding]
Result: Missed security requirements, broke existing checkout, 
no understanding of payment gateway options

✅ With Chain-Flow 150

User: "Add payment processing to the app"

🔗 Chain-Flow 150 Activated

Task Analysis:
Complex integration task with security, external APIs, 
and business logic implications.

Skills Discovered:
- goal-clarity-150, research-deep-150, impact-map-150
- action-plan-150, deep-think-150, max-quality-150

Proposed Chain:

1. goal-clarity-150
   WHY: Payment requirements vary (subscriptions? one-time? refunds?)
   
2. research-deep-150
   WHY: Need to evaluate Stripe vs PayPal vs others + security standards
   
3. impact-map-150
   WHY: Touches checkout, user accounts, database, notifications
   
4. deep-think-150
   WHY: Architecture decision for payment service integration

5. action-plan-150
   WHY: Create detailed implementation plan with rollback points
   
6. max-quality-150
   WHY: Payment code must be high quality (money involved)

Ready to begin? Starting with goal-clarity-150...

---

🔗 Chain-Flow: Step 1/5

Current Skill: goal-clarity-150
Purpose: Clarify payment requirements before research

[Executing goal-clarity-150...]

Questions:
- One-time payments, subscriptions, or both?
- Which currencies?
- Refund policy needed?
- PCI compliance level required?

[User answers...]

Step Complete: ✅
Requirements documented.

Next: research-deep-150
Continue? (Yes/No/Modify)

Relationship to Other Skills

Chain-Flow is the orchestrator — it doesn't replace other skills, it combines them:

🔗 CHAIN-FLOW-150
                    (Orchestrator)
                         ↓
    ┌────────────────────┼────────────────────┐
    ↓                    ↓                    ↓
goal-clarity    research-deep         impact-map
    ↓                    ↓                    ↓
deep-think         max-quality          [others]

Remember: Complex problems need chains of skills, not single skills. Chain-Flow builds the right chain, explains why, and executes step-by-step with your confirmation. You stay in control while getting the benefit of orchestrated skill application.

Repository: majiayu000/claude-skill-registry-data
Commit: 2bbaa03

Last updated: 13 days ago
Created: 13 days ago

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.