Critical Thinking Framework

Triggers: Use this skill when the user requests:

• "build an agent that can self-correct"
• "implement better reasoning"
• "reduce hallucination in AI system"
• "choose between CoT, ToT, or other reasoning methods"
• "add error detection to agent workflow"
• "apply the FCT framework to [document]"
• "critique this output" / "find flaws in this reasoning"

Core Capabilities

1. Reasoning Router

File: references/reasoning_router.md

Detects problem complexity and routes to the optimal reasoning method (CoT/ToT/GoT/Self-Consistency).

Use cases:

• Straightforward task with single solution path → CoT
• Complex task with multiple viable paths → ToT (BFS/DFS)
• Task with interconnected reasoning → GoT
• Critical task requiring verification → Self-Consistency

2. Metacognitive Monitor

File: references/metacognitive_monitor.md

Self-assessment and error detection in the reasoning process. Implements the Producer-Critic pattern for continuous quality control.

Key features:

• Confidence scoring per reasoning step
• Anomaly detection in thought patterns
• Reflection trigger conditions
• Human handoff protocols

3. Self-Verification

File: references/self_verification.md

Implementation of Chain-of-Verification (CoVe) and other self-verification techniques to validate outputs before delivery.

Methods covered:

• Chain-of-Verification (CoVe)
• Self-Refine loops
• Backward verification
• Cross-verification with external sources

4. Bias Detector

File: references/bias_detector.md

Detection of cognitive bias in the reasoning process and mitigation strategies.

Bias types covered:

• Confirmation bias
• Anchoring bias
• Availability heuristic
• Framing effects
• Recency bias

5. Producer-Critic Orchestrator

File: references/producer_critic_orchestrator.md

Pattern for orchestrating Generate-Critique-Refine cycles in agent workflows.

Architecture:

• Master Agent (orchestrator)
• Producer Agent (generation)
• Critic Agent (evaluation)
• Refinement loops with budget constraints

6. Memory Curator

File: references/memory_curator.md

Management of episodic memory with quality weighting to prevent memory pollution from bad episodes.

Features:

• Quality-weighted memory storage
• Experience replay for learning
• Memory consolidation strategies
• Selective retention policies

7. Reasoning Validator

File: references/reasoning_validator.md

Logical consistency checker and structural validation for reasoning chains.

Validation types:

• Logical consistency checks
• Structural completeness
• Assumption validation
• Contradiction detection

8. Reflection Trigger

File: references/reflection_trigger.md

Rule-based triggers to activate self-correction loops based on specific conditions.

Trigger conditions:

• Confidence threshold violations
• Repeated action patterns
• Latency spikes
• Complexity indicators

Default Invocation Behavior

If the user invokes /think-critically with no arguments and no document attached, immediately ask: "What would you like me to evaluate? Share the document, analysis, or response, or describe the system/architecture you want analyzed, and I'll apply the FCT framework." DO NOT explain the two modes. DO NOT describe Mode 1 or Mode 2. Just ask the question above and wait. Default to Mode 1 (direct application) unless the user explicitly mentions building an agent.

Workflow Decision Tree

User Request → Two entry points:

[Direct Application] User provides a document to evaluate
├─ ⚠️  PRE-FLIGHT (DO THIS BEFORE ANY READ TOOL CALL):
│  CATEGORICAL RULE: If the path contains doc_converter/, ALWAYS use Grep first —
│  NEVER call Read on the full file regardless of extension or apparent size.
│  doc_converter/ files are converted spreadsheets/PDFs and are ALWAYS 200-500KB
│  with extremely long lines that GUARANTEE limit failures. This is not a judgment
│  call — it is an absolute rule with no exceptions.
│  For ALL other files: ask yourself: Is the file a converted xlsx/pdf/docx/.csv?
│  Could it exceed 50KB? If YES to ANY of these, STOP — use Grep instead.
│  Full reads of converted documents ALWAYS hit the 256KB byte limit or 25K token
│  limit, wasting turns before any analysis. This guard applies even when the file
│  path looks like a markdown file — converted spreadsheets saved as .md are
│  regularly 300-400KB with extremely long lines.
│  ALSO APPLIES TO: thoughts/shared/plans/ and thoughts/shared/research/ documents.
│  Architecture plans and research documents in thoughts/ are plain markdown but
│  routinely exceed 10K tokens (the per-read limit). ALWAYS use offset/limit or
│  Grep for these files — NEVER attempt a full read without checking size first.
│  NEVER make parallel Read calls on the same large file: if one call would exceed
│  the limit, ALL parallel calls will fail simultaneously, tripling wasted turns.
│  Call Grep first (single call), then Read specific line ranges as follow-up.
│
├─ Step 1: Read the document (targeted reads only per pre-flight above).
│  BATCH YOUR READS: Before calling any Grep or Read, enumerate ALL the sections
│  or fields you need from the document in one pass. Then Grep for them in sequence.
│  Do NOT interleave reads with analysis — gather all evidence first, then synthesize.
│  This avoids returning to the same large file 5-6 times, which wastes turns and
│  context on repeated file overhead.
│  Read ONLY the document the user provided. Do not read other user
│  documents, prior session outputs, or HTML artifacts unless the user explicitly
│  references them or asks for a comparison. (Internal skill references like
│  reasoning_router.md are loaded in later steps — they are not "auxiliary files."
│  EXCEPTION: If the document is a draft produced by another skill (e.g., a demo
│  request, business case, or ROI model), load that skill's SKILL.md and/or
│  references/ files to understand the intended format and quality bar. This
│  context is required to evaluate the draft against the right criteria.)
├─ Step 2: Apply Reasoning Router to select analysis method
│  └─ Multi-part interconnected doc → GoT
│  └─ Single linear argument → CoT
│  └─ Multiple competing hypotheses → ToT
├─ Step 3: Run Metacognitive Monitor — confidence per claim/section
├─ Step 4: Run Bias Detector — flag hidden assumptions
├─ Step 5: Produce findings: evaluate EVERY claim, metric, and assertion in the
│  document — not just the obviously wrong ones. Partial coverage is the most
│  common failure mode. Produce: what to keep, what to cut, P0/P1 edits.
│  DEPENDENCY ORDERING: When evaluating solution sequencing or phase ordering,
│  present findings as hypotheses — the user may have data dependency knowledge
│  (e.g., "B reads from the store that A populates") that overrides FCT logic.
│  If the user corrects your ordering, defer immediately. Do not re-argue.
│  OUTPUT CONSTRAINTS: If the user specifies a format constraint (single slide,
│  one paragraph, 3 bullets), calibrate output to fit that constraint immediately.
│  Do NOT produce a full draft and then compress; ask or infer the constraint first.
│  YES/NO EVALUATION QUESTIONS: When the question is phrased as a binary check
│  ("does this make sense?", "is this the right approach?", "does the plan make sense?",
│  "is this sound?"), default to answer-first format: direct yes/no verdict, 3-5 key
│  supporting reasons, and an offer to expand. Do NOT default to the full GoT writeup
│  for a yes/no question — save the full analysis for when the user asks for depth.
│  CUSTOMER-FACING REVIEW: If the output is a proposal, deck, or vendor response going
│  back to the customer, apply an extra check: (1) Do not use the customer's own internal
│  escalation language against them ("board-flagged," "exec-escalated," "your team said
│  this is a P0"). Reframe discovery call content as business impact, not leverage.
│  (2) Attribute quotes to the business problem, not the individual ("Resolved cases
│  aren't followed up on" not "Robert said you don't call customers back").
│  CITATION REQUIRED (inline, not in a footnote): For every derived calculation
│  (percentage, total, ratio), embed the citation immediately after the number.
│  Format: "[value] (derived from [field name]: $X / $Y = Z%)". Never present a
│  derived number without this inline trace. This is the most common follow-up
│  question — cite proactively, not on request. For cap table reconstructions
│  specifically, add a standalone "Derivations" block immediately after the table
│  showing every percentage's source math explicitly (e.g., "$5M / $20M
│  post-money = 25%"). Users always verify cap table math — surface it upfront.
└─ Step 6: Apply edits if requested. After writing the file, explicitly list ONLY
   the changes you made (e.g., "I trimmed VO-03 from 95 words to 41"). Do NOT
   comment on or take credit for changes you did not make — if the file was
   modified between your read and write, acknowledge that the user may have
   made concurrent edits and ask what remains.

[Agent Architecture] Build/improve AI agent with critical thinking

├─ Step 1: Analyze Task Complexity
│  ├─ Simple, single-path → Use CoT (Chain-of-Thought)
│  ├─ Complex, multi-path → Use ToT (Tree-of-Thoughts)
│  ├─ Interconnected → Use GoT (Graph-of-Thoughts)
│  └─ Critical, needs verification → Use Self-Consistency
│
├─ Step 2: Implement Metacognitive Layer
│  ├─ Add confidence scoring
│  ├─ Set up reflection triggers
│  └─ Configure human handoff thresholds
│
├─ Step 3: Add Self-Verification
│  ├─ Implement CoVe for factual claims
│  ├─ Add backward verification for math/logic
│  └─ Setup cross-verification if external sources available
│
├─ Step 4: Integrate Bias Detection
│  ├─ Check for confirmation bias
│  ├─ Validate assumption diversity
│  └─ Apply mitigation strategies
│
└─ Step 5: Setup Memory & Learning
   ├─ Configure episodic memory
   ├─ Setup quality weighting
   └─ Implement experience replay

Quick Reference: Reasoning Method Selection

Implementation Example

# Pseudo-code for agent with FCT

class CriticalThinkingAgent:
    def __init__(self):
        self.reasoning_router = ReasoningRouter()
        self.metacognitive_monitor = MetacognitiveMonitor()
        self.self_verifier = SelfVerification()
        self.bias_detector = BiasDetector()

    async def solve(self, problem):
        # Step 1: Route to appropriate method
        method = self.reasoning_router.select(problem)

        # Step 2: Generate with monitoring
        thoughts = []
        for step in method.generate(problem):
            confidence = self.metacognitive_monitor.assess(step)
            if confidence < THRESHOLD:
                step = self.reflect_and_improve(step)
            thoughts.append(step)

        # Step 3: Self-verification
        verified = self.self_verifier.verify(thoughts)

        # Step 4: Bias check
        if self.bias_detector.detect(verified):
            verified = self.bias_detector.mitigate(verified)

        return verified

Resources

references/

Complete documentation for each FCT component:

• reasoning_router.md - Reasoning method selection (P0)
• metacognitive_monitor.md - Self-assessment and monitoring (P0)
• self_verification.md - Output verification techniques (P0)
• bias_detector.md - Bias detection and mitigation (P0)
• producer_critic_orchestrator.md - Generate-critique-refine pattern (P1)
• memory_curator.md - Memory management (P1)
• reasoning_validator.md - Logical validation (P1)
• reflection_trigger.md - Trigger conditions (P1)
• uncertainty_quantifier.md - Confidence calibration (P2)
• fallback_handler.md - Graceful degradation (P2)

Sources:

• Tree of Thoughts: Branching Reasoning for LLMs
• AI Agents: Metacognition for Self-Aware Intelligence - Microsoft
• Self-Verification-Based LLMs
• Cognitive Architecture in AI