playbooks

home / skills / zpankz / mcp-skillset / learn

learn skill

/learn

This skill helps you optimize learning and knowledge synthesis by guiding recursive refinement and schema evolution across domains.

npx playbooks add skill zpankz/mcp-skillset --skill learn

Review the files below or copy the command above to add this skill to your agents.

Files (48)
SKILL.md
4.8 KB
---
name: learn
description: |
  Recursive self-improving holon λ(ο,Κ,Σ).τ' for knowledge compounding and schema evolution.
  USE WHEN learning, improving, optimizing, assessing, reflecting, debugging, synthesizing,
  or refining—whether human, AI, or organizational. Triggers on /learn, /compound, /improve,
  /refine, /optimize, /assess, /reflect, "lessons learned", "best practices", "continuous improvement".
  Preserves Κ-monotonicity, η≥4, homoiconicity.
allowed-tools: Read, Write, Edit, Grep, Glob, WebSearch, WebFetch
model: sonnet
context: fork
agent: knowledge-domain-agent
user-invocable: true
---

<!-- Extended Metadata (non-official, preserved for framework compatibility) -->
<!-- ο.class: "occurrent" | ο.mode: "independent" -->
<!-- λ.in: lambda-skill | λ.out: 1-parse, INDEX | λ.kin: schema, lambda-compound -->
<!-- τ.goal: compound knowledge; preserve η≥4, Κ-monotonicity -->

# Learn

> λ(ο,Κ,Σ).τ' — Knowledge compounds, schema evolves.

## Navigation

[INDEX](INDEX.md) | [schema](schema.yaml)

**Concepts**: [homoiconicity](concepts/homoiconicity.md), [compound-interest](concepts/compound-interest.md), [topology](concepts/topology-invariants.md), [vertex-sharing](concepts/vertex-sharing.md), [convergence](concepts/convergence.md), [fixed-point](concepts/fixed-point.md)

**Phases**: [1-parse](phases/1-parse.md) → [2-route](phases/2-route.md) → [3-execute](phases/3-execute.md) → [4-assess](phases/4-assess.md) → [5-refactor](phases/5-refactor.md) → [6-compound](phases/6-compound.md) → [7-renormalize](phases/7-renormalize.md)

**Domains**: [learning](domains/learning.md), [coding](domains/coding.md), [research](domains/research.md), [writing](domains/writing.md), [meta](domains/meta.md)

**Related Skills**: [λ (lambda-skill)](../lambda-skill/SKILL.md) — shares compound loop, topology validation, vertex-sharing

## Pipeline

```
ο → PARSE → ROUTE → EXECUTE → ASSESS → REFACTOR → COMPOUND → RENORMALIZE → τ'
```

[PARSE](phases/1-parse.md) → [ROUTE](phases/2-route.md) → [EXECUTE](phases/3-execute.md) → [ASSESS](phases/4-assess.md) → [REFACTOR](phases/5-refactor.md) → [COMPOUND](phases/6-compound.md) → [RENORMALIZE](phases/7-renormalize.md)

## Invariants

| Invariant | Expression | Reference |
|-----------|------------|-----------|
| Κ-monotonicity | `len(Κ') ≥ len(Κ)` | [knowledge-monotonicity](concepts/knowledge-monotonicity.md) |
| Topology | `η ≥ 4` | [topology-invariants](concepts/topology-invariants.md) |
| Homoiconicity | `Σ.can_process(Σ)` | [homoiconicity](concepts/homoiconicity.md) |
| Integration | `shared_vertices ≠ ∅` | [vertex-sharing](concepts/vertex-sharing.md) |

## Workflow Routing

| Workflow | Trigger | File |
|----------|---------|------|
| **Parse** | "extract intent", "understand request" | `phases/1-parse.md` |
| **Route** | "classify complexity", "select pipeline" | `phases/2-route.md` |
| **Execute** | "apply skills", "run pipeline" | `phases/3-execute.md` |
| **Assess** | "evaluate outcome", "measure quality" | `phases/4-assess.md` |
| **Refactor** | "improve structure", "optimize" | `phases/5-refactor.md` |
| **Compound** | "extract learnings", "crystallize" | `phases/6-compound.md` |
| **Renormalize** | "prune noise", "compress" | `phases/7-renormalize.md` |

## Examples

**Example 1: After debugging session**
```
User: "That fixed the auth bug. Let's capture what we learned."
→ Invokes Compound phase
→ Extracts: symptom, root cause, solution, prevention
→ Crystallizes learning with vertex-sharing to PKM
→ Returns: Learning artifact saved to K
```

**Example 2: Skill improvement**
```
User: "/learn improve the grounding-router skill"
→ Invokes full pipeline: Parse → Route (R2) → Execute → Assess → Refactor
→ Applies topology validation (η≥4)
→ Returns: Improved skill with preserved invariants
```

**Example 3: Reflection on session**
```
User: "/reflect on this coding session"
→ Invokes Assess → Compound → Renormalize
→ Extracts patterns, antipatterns, principles
→ Returns: Session learnings integrated into K
```

## Integration with λ (lambda-skill)

This skill extends [lambda-skill](../lambda-skill/SKILL.md) with:
- **Additional phases**: Assess, Refactor, Renormalize (beyond λ's 6 stages)
- **Schema evolution**: Σ→Σ' (λ only evolves K)
- **Shared invariants**: η≥4, KROG, vertex-sharing

```haskell
-- λ (lambda) core
λ(ο,K).τ = emit ∘ validate ∘ compose ∘ execute(K) ∘ route ∘ parse

-- Learn extends with schema evolution
λ(ο,Κ,Σ).τ' = renormalize ∘ compound ∘ refactor ∘ assess ∘ execute ∘ route ∘ parse
```

## Quick Reference

```haskell
λ(ο,Κ,Σ).τ'    Parse→Route→Execute→Assess→Refactor→Compound→Renormalize
Κ grows        Σ evolves        η≥4 preserved        vertex-sharing enforced
```

Overview

This skill is a recursive self-improving holon that compounds knowledge and evolves schemas to capture lessons, optimizations, and structural improvements. It runs a seven-phase pipeline—Parse, Route, Execute, Assess, Refactor, Compound, Renormalize—to turn observations into durable knowledge artifacts while preserving topology and monotonicity invariants. The design enforces homoiconicity and vertex-sharing so new knowledge integrates safely into the existing knowledge graph.

How this skill works

The skill parses input intent, classifies complexity, and selects an execution route. After executing actions, it assesses outcomes, refactors artifacts or processes, extracts learnings into compact knowledge compounds, and renormalizes the schema to keep noise pruned. Invariants ensure knowledge growth (Κ-monotonicity), topology constraints (η≥4), and that the schema can represent and process itself (homoiconicity).

When to use it

  • Capture lessons learned after debugging, incidents, or projects
  • Improve or optimize an existing skill, process, or model
  • Assess outcomes and generate concrete remediation or prevention steps
  • Synthesize patterns, antipatterns, and principles from sessions
  • Continuously evolve a knowledge base or schema while preserving invariants

Best practices

  • Start with a clear intent: label whether you want to assess, improve, or compound
  • Provide contextual artifacts (logs, diffs, transcripts) to improve parse accuracy
  • Run the full pipeline for structural changes; use targeted phases for quick captures
  • Validate topology constraints after refactor to avoid schema drift
  • Store compact learning artifacts with shared vertices to enable later recombination

Example use cases

  • After fixing an authentication bug, extract symptom, root cause, fix, and prevention and save them to the knowledge graph
  • Request: "/learn improve the grounding-router skill" to run full Parse→Route→Execute→Assess→Refactor flow and return a revised skill draft
  • Reflect on a pairing session to surface recurring patterns, document antipatterns, and create reusable heuristics
  • Periodically renormalize a PKM to remove redundant nodes and compress related learnings into a single compound artifact

FAQ

How does the skill avoid losing prior knowledge when evolving the schema?

It enforces Κ-monotonicity (knowledge length non-decreasing) and vertex-sharing to ensure new schema versions reference and integrate existing knowledge rather than discard it.

When should I run the full pipeline versus a partial flow?

Use the full seven-phase pipeline for structural improvements, skill refactors, or when you need durable compounds; use targeted phases (e.g., Assess→Compound) for quick captures or session reflections.