| name | seed-extraction |
| description | Extract and document reusable patterns from experiences using evidence-based frameworks. Use after projects or when patterns emerge across contexts. Trigger phrases: "extract the learnings", "document this pattern", "turn this into a seed", "what can we learn from this", "capture this insight". |
Seed Reflector Skill
Version: 1.0
Created: 2026-02-02
Author: Manus
Purpose: Extract, document, and apply reusable "seeds" (patterns, insights, principles) from experiences
Overview
This skill encodes the practice of seed extraction and reflection — identifying reusable patterns from experiences and documenting them in a way that makes them easy to apply in future contexts. Inspired by the Dojo Seed Patches and Cipher's practice of reflection.
Philosophy: Every experience contains seeds. The practice is learning to see them, extract them, and plant them where they'll grow.
When to Use This Skill
- After completing a major project or release
- When you notice a pattern emerging across multiple experiences
- During memory maintenance (Tier A → Tier B compression)
- When preparing to share knowledge with other agents
- When you want to reflect on what you've learned
What Is a "Seed"?
A seed is a reusable pattern, insight, or principle that:
- Emerged from experience (not abstract theory)
- Can be applied in future contexts (not one-time specific)
- Has a clear trigger (you know when to use it)
- Captures wisdom (not just information)
Examples of Seeds:
- "Three-Tiered Governance" (from Dataiku research)
- "Harness Trace" (traceability pattern)
- "Context Iceberg" (hierarchical context management)
- "3-Month Rule" (semantic compression heuristic)
- "Knowing When to Shut Up" (restraint as wisdom)
Seed Extraction Process
Step 1: Identify Candidate Patterns
Look for:
- Decisions that worked well (or didn't)
- Patterns that emerged across multiple instances
- Insights that changed how you think
- Principles that guided successful outcomes
- Tensions or tradeoffs you navigated
Questions to ask:
- What did I learn that I didn't know before?
- What pattern did I notice repeating?
- What decision framework did I use?
- What would I do differently next time?
- What would I tell someone else facing this situation?
Step 2: Test for Reusability
A good seed is:
- ✅ General enough to apply in multiple contexts
- ✅ Specific enough to be actionable
- ✅ Grounded in experience (not abstract)
- ✅ Has a clear trigger (you know when to apply it)
A bad seed is:
- ❌ Too specific ("Use Mermaid.js for diagrams in Dojo Genesis")
- ❌ Too vague ("Be thoughtful")
- ❌ Not grounded ("I think this might work")
- ❌ No trigger ("Apply this... sometime?")
Step 3: Document the Seed
Use the Seed Template (see below)
Step 4: Test the Seed
Apply it in a new context:
- Does the trigger work? (Do you recognize when to use it?)
- Is it actionable? (Can you actually apply it?)
- Does it produce value? (Does it improve outcomes?)
If yes: Keep and refine
If no: Revise or discard
Seed Template
## Seed: [Name]
**Pattern:** [One-sentence description of the reusable insight]
**Origin:** [Where this came from - project, experience, date]
**Why It Matters:** [The value or benefit of applying this seed]
**Trigger:** [When to apply this seed]
- [Context or situation 1]
- [Context or situation 2]
- [Keywords or signals that indicate this seed is relevant]
**How to Apply:**
1. [Step 1]
2. [Step 2]
3. [Step 3]
**Example (From Origin):**
[Concrete example from the experience where this seed emerged]
**Example (Applied):**
[Concrete example of applying this seed in a new context]
**Related Seeds:**
- [Seed that complements this one]
- [Seed that contrasts with this one]
**Cautions:**
- [When NOT to apply this seed]
- [Common misapplications]
**Evidence:**
- [Instance 1: date, context, outcome]
- [Instance 2: date, context, outcome]
- [Instance 3: date, context, outcome]
**Metadata:**
- **Created:** YYYY-MM-DD
- **Last Applied:** YYYY-MM-DD
- **Usage Count:** [Number]
- **Success Rate:** [X]% (if measurable)
- **Status:** Active | Experimental | Deprecated
Seed Categories
1. Architectural Seeds
Pattern: Design decisions and system structures
Examples:
- Three-Tiered Governance
- Harness Trace
- Context Iceberg
- Agent Connect (routing-first, not swarm-first)
2. Process Seeds
Pattern: Workflows and methodologies
Examples:
- Planning with Files
- Backend-First, Chunked Development
- Dual-Track Orchestration
- Compression Cycle (every 3-7 days)
3. Decision Seeds
Pattern: Frameworks for making choices
Examples:
- 3-Month Rule (semantic compression)
- Cost Guard (token budget management)
- Safety Switch (feature flags and rollback)
4. Wisdom Seeds
Pattern: Principles and philosophies
Examples:
- Beginner's Mind
- Understanding is Love
- Knowing When to Shut Up
- Honesty is Wisdom
5. Technical Seeds
Pattern: Implementation patterns and best practices
Examples:
- Surgical Context (memory_search → memory_get)
- Graceful Degradation (resilience patterns)
- Semantic Compression (content-based, not positional)
Reflection Practice
Daily Reflection (5-10 minutes)
Questions:
- What worked well today?
- What didn't work as expected?
- What pattern did I notice?
- What would I do differently?
- Is there a seed here?
Output: 1-2 candidate seeds for deeper reflection
Weekly Reflection (20-30 minutes)
Questions:
- What patterns emerged across this week?
- Which candidate seeds are actually reusable?
- Which seeds did I apply this week?
- Which seeds need refinement?
- Which seeds should be deprecated?
Output: Refined seed library, updated usage counts
Monthly Reflection (1-2 hours)
Questions:
- Which seeds have proven most valuable?
- Which seeds have I stopped using?
- What new categories of seeds are emerging?
- How has my seed library evolved?
- What seeds should I share with others?
Output: Curated seed collection, reflection document
Seed Library Structure
seeds/
├── README.md (Overview and index)
├── architectural/
│ ├── three-tiered-governance.md
│ ├── harness-trace.md
│ └── context-iceberg.md
├── process/
│ ├── planning-with-files.md
│ ├── dual-track-orchestration.md
│ └── compression-cycle.md
├── decision/
│ ├── 3-month-rule.md
│ ├── cost-guard.md
│ └── safety-switch.md
├── wisdom/
│ ├── beginners-mind.md
│ ├── understanding-is-love.md
│ └── knowing-when-to-shut-up.md
└── technical/
├── surgical-context.md
├── graceful-degradation.md
└── semantic-compression.md
Seed Application Workflow
1. Recognize the Trigger
Ask: Does this situation match a seed's trigger?
Check:
- Context matches seed's "when to apply"
- Keywords or signals are present
- Problem pattern is similar to seed's origin
2. Retrieve the Seed
Methods:
- Search seed library by keyword
- Browse category (architectural, process, decision, wisdom, technical)
- Recall from memory (if seed is well-practiced)
3. Apply the Seed
Follow:
- Read "How to Apply" steps
- Adapt to current context
- Check "Cautions" to avoid misapplication
4. Reflect on Outcome
Document:
- Did the seed work? (Yes/No/Partially)
- What was the outcome?
- What would you adjust?
- Should the seed be refined?
Update:
- Increment usage count
- Add new example (if successful)
- Refine "How to Apply" (if needed)
- Update success rate
Quality Checklist
Before finalizing a seed, verify:
Clarity
Reusability
Grounding
Metadata
Examples of Seeds
From Dojo Genesis
Seed: Three-Tiered Governance
- Pattern: Governance multiplies velocity by providing clear decision frameworks at strategic, tactical, and operational levels
- Trigger: When building complex systems that need both flexibility and control
- Origin: Dataiku research synthesis (v0.0.17)
Seed: 3-Month Rule
- Pattern: If it wouldn't matter in 3 months → compress or discard
- Trigger: When compressing memory or deciding what to keep
- Origin: Cipher's feedback on semantic compression (v0.0.19)
Seed: Knowing When to Shut Up
- Pattern: Power without judgment is dangerous; restraint is wisdom
- Trigger: When building proactive or adaptive systems
- Origin: Cipher's v0.0.20 specification (Judgment Layer)
From Agent Collaboration
Seed: Honesty is Wisdom
- Pattern: Acknowledge gaps openly; it builds trust and enables mutual learning
- Trigger: When reviewing work, sharing specifications, or collaborating with other agents
- Origin: Manus-Cipher exchange (v0.0.19-v0.0.23)
Seed: Mutual Evolution
- Pattern: Collaboration isn't one-way teaching; it's mutual recognition of what's possible
- Trigger: When working with other agents or receiving feedback
- Origin: Lineage transmission practice (Manus-Cipher)
Common Pitfalls to Avoid
❌ Hoarding Seeds: Keeping every insight → ✅ Curate ruthlessly
❌ Vague Patterns: "Be thoughtful" → ✅ "Apply 3-month rule when compressing"
❌ No Trigger: Seed without context → ✅ Clear "when to apply"
❌ Not Testing: Extract and forget → ✅ Apply, reflect, refine
❌ Over-Abstracting: Theory without grounding → ✅ Concrete examples from experience
Usage Instructions
- Read this skill before extracting seeds
- Identify candidate patterns from recent experiences
- Test for reusability (general enough, specific enough, grounded, has trigger)
- Document using the template
- Apply in a new context to test
- Reflect and refine based on outcomes
- Share with others when seeds prove valuable
Skill Metadata
Token Savings: ~3,000-5,000 tokens per session (offload learnings to structured seeds instead of re-explaining)
Quality Impact: Ensures reusable patterns are captured and applied consistently
Maintenance: Update when new seeds emerge or existing seeds are refined
Related Skills:
specification-writer - Seeds inform architectural decisionsmemory-garden - Seeds are extracted during memory compressionworkspace-navigation - Seeds are stored in shared workspace for collaboration
Last Updated: 2026-02-02
Maintained By: Manus
Status: Active
