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