Seed Module Library
Manage and apply the 10 Dojo Seed Patches plus 3 field seeds as reusable thinking modules. The core seeds derive from Dataiku research; the field seeds emerged from direct practice. Make enterprise-grade agent patterns accessible, consistent, and evolvable.
When to Use This Skill
Trigger this skill when:
- User asks "What seed applies here?" or "Which pattern should I use?"
- Keywords match seed triggers (governance, multi-agent, cost, context, routing, etc.)
- Architecting new features or systems
- Debugging complex issues
- Optimizing costs or performance
- Building trust through transparency
The 10 Core Seeds
- Three-Tiered Governance - Strategic/Tactical/Operational framework
- Harness Trace - Nested spans + events for traceability
- Context Iceberg - 6x token multiplier, hierarchical loading
- Agent Connect - Routing-first, not swarm-first
- Go-Live Bundles - Reusable artifacts (DojoPacket)
- Cost Guard - Budget for full iceberg (5-10x multiplier)
- Safety Switch - Fallback to conservative mode
- Implicit Perspective Extraction - Extract from constraints/metaphors
- Mode-Based Complexity Gating - 3-question test
- Shared Infrastructure - Build once, reuse everywhere
Meta-Seed: Governance Multiplies Velocity
Field Seeds (From Practice)
- Voice Before Structure - Read design language before writing structural artifacts
- Pointer Directories - Empty directories are references, not gaps
- Granular Visibility - Progress tracking serves the user, not the agent
Core Workflow
1. Suggest Relevant Seeds
Based on keywords or task context:
python3.11 /home/ubuntu/skills/seed-library/scripts/suggest_seeds.py <keywords...>
Example:
python3.11 suggest_seeds.py multi-agent architecture coordination
Output:
- Top 3 relevant seeds ranked by relevance score
- Brief description of each seed
- File path to full seed content
Saved to: /home/ubuntu/seed-suggestions.md
2. Apply a Seed
Load full seed content and application guide:
python3.11 /home/ubuntu/skills/seed-library/scripts/apply_seed.py <seed_id> [session_id]
Example:
python3.11 apply_seed.py 04_agent_connect session_123
Output:
- Full seed content (What It Is, Why It Matters, The Pattern, etc.)
- Application checklist
- Next steps
- Usage tracked automatically
Saved to: /home/ubuntu/seed-<seed_id>-applied.md
Script Reference
suggest_seeds.py
Purpose: Suggest relevant seeds based on keywords
Usage:
python3.11 suggest_seeds.py <keywords...>
How it works:
- Matches keywords to seed triggers
- Calculates relevance score
- Returns top 3 suggestions
Trigger Keywords by Seed:
- 01 (Governance): governance, capabilities, complexity, multi-agent, coordination, policy, standards
- 02 (Trace): debugging, trace, transparency, performance, evaluation, logging, monitoring
- 03 (Context): token, cost, context, window, limit, budget, pruning, memory, overhead
- 04 (Agent Connect): multi-agent, routing, coordination, specialized, handoff, permission, swarm
- 05 (Bundles): export, sharing, reuse, artifact, package, bundle, repeatability, trust
- 06 (Cost Guard): cost, budget, estimation, planning, infrastructure, investment, pricing
- 07 (Safety Switch): fallback, conservative, alert, drift, failure, recovery, validation, error
- 08 (Perspective): perspective, constraint, metaphor, scope, extraction, implicit, natural
- 09 (Complexity): mode, complexity, routing, simple, query, reasoning, adaptive
- 10 (Infrastructure): infrastructure, reuse, duplication, foundation, shared, common, service
- 11 (Voice): voice, philosophy, design-language, manifest, description, ecosystem, grounding, plugin
- 12 (Pointers): empty, missing, pointer, provenance, registry, audit, gap, coverage, directory
- 13 (Visibility): progress, tracking, visibility, todo, granular, steering, trust, delegation
apply_seed.py
Purpose: Load and explain how to apply a seed
Usage:
python3.11 apply_seed.py <seed_id> [session_id]
What it does:
- Loads full seed content from
/seeds/<seed_id>.md
- Generates application guide with checklist
- Tracks usage in
/home/ubuntu/.seed-usage.json
- Saves guide to file
Seed IDs:
01_three_tiered_governance
02_harness_trace
03_context_iceberg
04_agent_connect
05_go_live_bundles
06_cost_guard
07_safety_switch
08_implicit_perspective_extraction
09_mode_based_complexity_gating
10_shared_infrastructure
meta_governance_multiplies_velocity
11_voice_before_structure
12_pointer_directories
13_granular_visibility
Seed Files
All seeds are stored in /home/ubuntu/skills/seed-library/seeds/ as markdown files.
Seed File Structure
---
seed_id: 01
name: Three-Tiered Governance
version: 1.0
created: 2026-01-12
source: Dataiku Research
status: active
---
# Seed Name
## What It Is
{description}
## Why It Matters
{rationale}
## The Pattern
{pattern description}
## Revisit Trigger
{when to apply this seed}
## Dojo Application
{how Dojo uses this pattern}
## What It Refuses
{what this pattern explicitly rejects}
## Checks
- [ ] {validation check 1}
- [ ] {validation check 2}
## Related Seeds
- {seed name}: {relationship}
Usage Tracking
The skill automatically tracks seed usage in /home/ubuntu/.seed-usage.json:
{
"seeds": {
"04_agent_connect": {
"usage_count": 3,
"last_used": "2026-01-29T12:00:00Z",
"sessions": ["session_123", "session_456"]
}
},
"session_seeds": {
"session_123": ["04_agent_connect", "10_shared_infrastructure"]
}
}
Reference Documents
seed_catalog.md
Quick reference to all 10 seeds plus meta-seed:
- One-line descriptions
- Triggers and refusals
- Seed relationships
- Usage patterns (5 common scenarios)
- Maintenance guidelines
Read this when:
- Getting overview of all seeds
- Understanding seed relationships
- Learning usage patterns
Common Use Cases
Use Case 1: Architecting Multi-Agent System
User says: "How should we architect the multi-agent system?"
Workflow:
- Run
suggest_seeds.py multi-agent architecture coordination
- Top suggestions: Agent Connect, Shared Infrastructure, Three-Tiered Governance
- Apply Seed 04 (Agent Connect)
- Follow application checklist
- Track usage
Output:
Based on your query, I recommend Agent Connect (Seed 04). This seed provides a routing-first pattern where the Supervisor acts as a single entry point, routing to specialized agents (Dojo, Librarian, Debugger, Builder) based on context. This prevents agent sprawl and keeps coordination manageable.
Use Case 2: Optimizing Token Usage
User says: "Token usage is spiking, how do we optimize?"
Workflow:
- Run
suggest_seeds.py token cost context optimization
- Top suggestions: Context Iceberg, Cost Guard, Mode-Based Complexity Gating
- Apply Seed 03 (Context Iceberg)
- Implement hierarchical context loading (Tier 1-4)
- Set pruning triggers (80%, 90%, 95%)
Output:
The Context Iceberg pattern (Seed 03) explains the 6x token multiplier from demo to production. Implement hierarchical context loading with 4 tiers, and set pruning triggers at 80% (prune Tier 4), 90% (prune Tier 3), and 95% (alert user).
Use Case 3: Debugging Unexpected Behavior
User says: "Why did Dojo choose Scout instead of Mirror?"
Workflow:
- Run
suggest_seeds.py debugging trace transparency
- Top suggestion: Harness Trace
- Apply Seed 02 (Harness Trace)
- Review trace spans for
mode_selection
- Read
metadata.reasoning
Output:
Use the Harness Trace (Seed 02) to inspect the decision path. Check the mode_selection span in the trace JSON. The metadata.reasoning field will explain why Scout was chosen over Mirror.
Use Case 4: Building Trust with Users
User says: "Users don't understand our recommendations"
Workflow:
- Run
suggest_seeds.py trust transparency trace
- Top suggestions: Harness Trace, Go-Live Bundles, Governance Multiplies Velocity
- Apply Seed 02 (Harness Trace) for transparency
- Apply Seed 05 (Go-Live Bundles) for repeatability
- Apply Meta-Seed for philosophy
Output:
Build trust through Harness Trace (transparency), Go-Live Bundles (repeatability), and the Governance Multiplies Velocity philosophy. Show users the decision path, make sessions exportable and inspectable, and emphasize that governance accelerates delivery.
Use Case 5: Planning New Feature
User says: "Let's plan the Workbench feature"
Workflow:
- Run
suggest_seeds.py planning feature governance
- Top suggestions: Three-Tiered Governance, Cost Guard, Shared Infrastructure
- Apply Seed 01 (Three-Tiered Governance)
- Define strategic (principles), tactical (standards), operational (tools)
- Apply Seed 06 (Cost Guard) to budget for 5-10x multiplier
Output:
Start with Three-Tiered Governance (Seed 01). Define strategic principles (does this align with "no autopilot"?), tactical standards (DojoPacket schema, routing logic), and operational tools (tests, traces). Then apply Cost Guard (Seed 06) to budget for the full iceberg, not just API costs.
Integration with Dojo Agent
When Dojo is reasoning, it can reference seeds:
Example:
"Considering Agent Connect (Seed 04) for this multi-agent architecture. Using Supervisor as router with transparent handoffs."
Example:
"Applying Context Iceberg (Seed 03) to manage token usage. Loading Tier 1 + Tier 2 context for this query."
Seed Relationships
Foundational Seeds (Start Here)
- 01. Three-Tiered Governance - Framework for all other seeds
- Meta. Governance Multiplies Velocity - Philosophy
Operational Seeds (Day-to-Day)
- 02. Harness Trace - Transparency and debugging
- 03. Context Iceberg - Token and cost management
- 07. Safety Switch - Error handling
- 09. Mode-Based Complexity Gating - Query routing
Architectural Seeds (System Design)
- 04. Agent Connect - Multi-agent coordination
- 10. Shared Infrastructure - Reusable services
Delivery Seeds (Shipping)
- 05. Go-Live Bundles - Packaging and reuse
- 06. Cost Guard - Budgeting and planning
UX Seeds (User Experience)
- 08. Implicit Perspective Extraction - Reduce friction
Field Seeds (From Practice)
- 11. Voice Before Structure - Ground in philosophy before writing
- 12. Pointer Directories - Understand provenance before filling gaps
- 13. Granular Visibility - Track progress for the user, not the agent
Seed Maintenance
When to Update a Seed
- Pattern evolves based on new learnings
- Better approach discovered
- User feedback suggests improvement
When to Archive a Seed
- Pattern no longer applies
- Superseded by better approach
- Context has fundamentally changed
Versioning Convention
- 1.0 - Initial version from Dataiku research
- 1.1 - Minor update (clarification, example added)
- 2.0 - Major update (pattern changed)
Update Process
- Identify need for update
- Draft new version
- Test with real scenarios
- Update seed file with "Revised:" section
- Update seed_catalog.md
- Notify users of change
Best Practices
Frequency
- Proactive: Suggest seeds during planning and design
- Reactive: Apply seeds when debugging or optimizing
- Continuous: Track usage to identify most valuable seeds
Application
- Read the full seed before applying (don't just skim)
- Follow the checklist to validate application
- Note what it refuses to avoid anti-patterns
- Track usage to measure effectiveness
Evolution
- Update when patterns evolve (not just for the sake of updating)
- Archive when obsolete (don't hoard outdated seeds)
- Version carefully (breaking changes = major version bump)
Limitations
What This Skill Does
- Suggest relevant seeds based on keywords
- Load and explain how to apply seeds
- Track usage over time
- Provide quick reference to all seeds
What This Skill Doesn't Do
- Automatically apply seeds (you still need to implement)
- Make architectural decisions for you
- Guarantee success (seeds are patterns, not silver bullets)
- Replace deep thinking (seeds guide, they don't replace reasoning)
Quick Reference
| Task |
Command |
| Suggest seeds |
python3.11 suggest_seeds.py <keywords...> |
| Apply seed |
python3.11 apply_seed.py <seed_id> |
| View catalog |
file read references/seed_catalog.md |
| Check usage |
cat /home/ubuntu/.seed-usage.json |
| List all seeds |
ls /home/ubuntu/skills/seed-library/seeds/ |
Success Metrics
- Accessibility: Find relevant seed in < 10 seconds
- Consistency: Seeds applied correctly 90%+ of the time
- Evolution: Seeds updated when patterns improve
- Reuse: Seeds used across multiple sessions
- Learning: New seeds added as patterns emerge
1---2name: seed-library-33description: Access and apply the 10 Dojo Seed Patches plus 3 field seeds as reusable thinking modules. Use when architecting systems, optimizing costs, debugging complex issues, or grounding ecosystem-level work. Trigger phrases include "which seed applies here", "suggest a seed pattern", "apply a seed to this", "what pattern should we use", "load the seed library".4metadata:5 source: https://skillmd.com/skills/dojogenesis/seed-library-36---78# Seed Module Library910Manage and apply the **10 Dojo Seed Patches** plus **3 field seeds** as reusable thinking modules. The core seeds derive from Dataiku research; the field seeds emerged from direct practice. Make enterprise-grade agent patterns accessible, consistent, and evolvable.1112## When to Use This Skill1314Trigger this skill when:15- User asks "What seed applies here?" or "Which pattern should I use?"16- Keywords match seed triggers (governance, multi-agent, cost, context, routing, etc.)17- Architecting new features or systems18- Debugging complex issues19- Optimizing costs or performance20- Building trust through transparency2122## The 10 Core Seeds23241. **Three-Tiered Governance** - Strategic/Tactical/Operational framework252. **Harness Trace** - Nested spans + events for traceability263. **Context Iceberg** - 6x token multiplier, hierarchical loading274. **Agent Connect** - Routing-first, not swarm-first285. **Go-Live Bundles** - Reusable artifacts (DojoPacket)296. **Cost Guard** - Budget for full iceberg (5-10x multiplier)307. **Safety Switch** - Fallback to conservative mode318. **Implicit Perspective Extraction** - Extract from constraints/metaphors329. **Mode-Based Complexity Gating** - 3-question test3310. **Shared Infrastructure** - Build once, reuse everywhere3435**Meta-Seed:** Governance Multiplies Velocity3637### Field Seeds (From Practice)3811. **Voice Before Structure** - Read design language before writing structural artifacts3912. **Pointer Directories** - Empty directories are references, not gaps4013. **Granular Visibility** - Progress tracking serves the user, not the agent4142## Core Workflow4344### 1. Suggest Relevant Seeds4546Based on keywords or task context:4748```bash49python3.11 /home/ubuntu/skills/seed-library/scripts/suggest_seeds.py <keywords...>50```5152**Example:**53```bash54python3.11 suggest_seeds.py multi-agent architecture coordination55```5657**Output:**58- Top 3 relevant seeds ranked by relevance score59- Brief description of each seed60- File path to full seed content6162**Saved to:** `/home/ubuntu/seed-suggestions.md`6364### 2. Apply a Seed6566Load full seed content and application guide:6768```bash69python3.11 /home/ubuntu/skills/seed-library/scripts/apply_seed.py <seed_id> [session_id]70```7172**Example:**73```bash74python3.11 apply_seed.py 04_agent_connect session_12375```7677**Output:**78- Full seed content (What It Is, Why It Matters, The Pattern, etc.)79- Application checklist80- Next steps81- Usage tracked automatically8283**Saved to:** `/home/ubuntu/seed-<seed_id>-applied.md`8485## Script Reference8687### suggest_seeds.py8889**Purpose:** Suggest relevant seeds based on keywords9091**Usage:**92```bash93python3.11 suggest_seeds.py <keywords...>94```9596**How it works:**971. Matches keywords to seed triggers982. Calculates relevance score993. Returns top 3 suggestions100101**Trigger Keywords by Seed:**102103- **01 (Governance):** governance, capabilities, complexity, multi-agent, coordination, policy, standards104- **02 (Trace):** debugging, trace, transparency, performance, evaluation, logging, monitoring105- **03 (Context):** token, cost, context, window, limit, budget, pruning, memory, overhead106- **04 (Agent Connect):** multi-agent, routing, coordination, specialized, handoff, permission, swarm107- **05 (Bundles):** export, sharing, reuse, artifact, package, bundle, repeatability, trust108- **06 (Cost Guard):** cost, budget, estimation, planning, infrastructure, investment, pricing109- **07 (Safety Switch):** fallback, conservative, alert, drift, failure, recovery, validation, error110- **08 (Perspective):** perspective, constraint, metaphor, scope, extraction, implicit, natural111- **09 (Complexity):** mode, complexity, routing, simple, query, reasoning, adaptive112- **10 (Infrastructure):** infrastructure, reuse, duplication, foundation, shared, common, service113- **11 (Voice):** voice, philosophy, design-language, manifest, description, ecosystem, grounding, plugin114- **12 (Pointers):** empty, missing, pointer, provenance, registry, audit, gap, coverage, directory115- **13 (Visibility):** progress, tracking, visibility, todo, granular, steering, trust, delegation116117### apply_seed.py118119**Purpose:** Load and explain how to apply a seed120121**Usage:**122```bash123python3.11 apply_seed.py <seed_id> [session_id]124```125126**What it does:**1271. Loads full seed content from `/seeds/<seed_id>.md`1282. Generates application guide with checklist1293. Tracks usage in `/home/ubuntu/.seed-usage.json`1304. Saves guide to file131132**Seed IDs:**133- `01_three_tiered_governance`134- `02_harness_trace`135- `03_context_iceberg`136- `04_agent_connect`137- `05_go_live_bundles`138- `06_cost_guard`139- `07_safety_switch`140- `08_implicit_perspective_extraction`141- `09_mode_based_complexity_gating`142- `10_shared_infrastructure`143- `meta_governance_multiplies_velocity`144- `11_voice_before_structure`145- `12_pointer_directories`146- `13_granular_visibility`147148## Seed Files149150All seeds are stored in `/home/ubuntu/skills/seed-library/seeds/` as markdown files.151152### Seed File Structure153154```markdown155---156seed_id: 01157name: Three-Tiered Governance158version: 1.0159created: 2026-01-12160source: Dataiku Research161status: active162---163164# Seed Name165166## What It Is167{description}168169## Why It Matters170{rationale}171172## The Pattern173{pattern description}174175## Revisit Trigger176{when to apply this seed}177178## Dojo Application179{how Dojo uses this pattern}180181## What It Refuses182{what this pattern explicitly rejects}183184## Checks185- [ ] {validation check 1}186- [ ] {validation check 2}187188## Related Seeds189- {seed name}: {relationship}190```191192## Usage Tracking193194The skill automatically tracks seed usage in `/home/ubuntu/.seed-usage.json`:195196```json197{198 "seeds": {199 "04_agent_connect": {200 "usage_count": 3,201 "last_used": "2026-01-29T12:00:00Z",202 "sessions": ["session_123", "session_456"]203 }204 },205 "session_seeds": {206 "session_123": ["04_agent_connect", "10_shared_infrastructure"]207 }208}209```210211## Reference Documents212213### seed_catalog.md214215Quick reference to all 10 seeds plus meta-seed:216- One-line descriptions217- Triggers and refusals218- Seed relationships219- Usage patterns (5 common scenarios)220- Maintenance guidelines221222**Read this when:**223- Getting overview of all seeds224- Understanding seed relationships225- Learning usage patterns226227## Common Use Cases228229### Use Case 1: Architecting Multi-Agent System230231**User says:** "How should we architect the multi-agent system?"232233**Workflow:**2341. Run `suggest_seeds.py multi-agent architecture coordination`2352. Top suggestions: Agent Connect, Shared Infrastructure, Three-Tiered Governance2363. Apply Seed 04 (Agent Connect)2374. Follow application checklist2385. Track usage239240**Output:**241> Based on your query, I recommend **Agent Connect** (Seed 04). This seed provides a routing-first pattern where the Supervisor acts as a single entry point, routing to specialized agents (Dojo, Librarian, Debugger, Builder) based on context. This prevents agent sprawl and keeps coordination manageable.242243### Use Case 2: Optimizing Token Usage244245**User says:** "Token usage is spiking, how do we optimize?"246247**Workflow:**2481. Run `suggest_seeds.py token cost context optimization`2492. Top suggestions: Context Iceberg, Cost Guard, Mode-Based Complexity Gating2503. Apply Seed 03 (Context Iceberg)2514. Implement hierarchical context loading (Tier 1-4)2525. Set pruning triggers (80%, 90%, 95%)253254**Output:**255> The **Context Iceberg** pattern (Seed 03) explains the 6x token multiplier from demo to production. Implement hierarchical context loading with 4 tiers, and set pruning triggers at 80% (prune Tier 4), 90% (prune Tier 3), and 95% (alert user).256257### Use Case 3: Debugging Unexpected Behavior258259**User says:** "Why did Dojo choose Scout instead of Mirror?"260261**Workflow:**2621. Run `suggest_seeds.py debugging trace transparency`2632. Top suggestion: Harness Trace2643. Apply Seed 02 (Harness Trace)2654. Review trace spans for `mode_selection`2665. Read `metadata.reasoning`267268**Output:**269> Use the **Harness Trace** (Seed 02) to inspect the decision path. Check the `mode_selection` span in the trace JSON. The `metadata.reasoning` field will explain why Scout was chosen over Mirror.270271### Use Case 4: Building Trust with Users272273**User says:** "Users don't understand our recommendations"274275**Workflow:**2761. Run `suggest_seeds.py trust transparency trace`2772. Top suggestions: Harness Trace, Go-Live Bundles, Governance Multiplies Velocity2783. Apply Seed 02 (Harness Trace) for transparency2794. Apply Seed 05 (Go-Live Bundles) for repeatability2805. Apply Meta-Seed for philosophy281282**Output:**283> Build trust through **Harness Trace** (transparency), **Go-Live Bundles** (repeatability), and the **Governance Multiplies Velocity** philosophy. Show users the decision path, make sessions exportable and inspectable, and emphasize that governance accelerates delivery.284285### Use Case 5: Planning New Feature286287**User says:** "Let's plan the Workbench feature"288289**Workflow:**2901. Run `suggest_seeds.py planning feature governance`2912. Top suggestions: Three-Tiered Governance, Cost Guard, Shared Infrastructure2923. Apply Seed 01 (Three-Tiered Governance)2934. Define strategic (principles), tactical (standards), operational (tools)2945. Apply Seed 06 (Cost Guard) to budget for 5-10x multiplier295296**Output:**297> Start with **Three-Tiered Governance** (Seed 01). Define strategic principles (does this align with "no autopilot"?), tactical standards (DojoPacket schema, routing logic), and operational tools (tests, traces). Then apply **Cost Guard** (Seed 06) to budget for the full iceberg, not just API costs.298299## Integration with Dojo Agent300301When Dojo is reasoning, it can reference seeds:302303**Example:**304> "Considering **Agent Connect** (Seed 04) for this multi-agent architecture. Using Supervisor as router with transparent handoffs."305306**Example:**307> "Applying **Context Iceberg** (Seed 03) to manage token usage. Loading Tier 1 + Tier 2 context for this query."308309## Seed Relationships310311### Foundational Seeds (Start Here)312- **01. Three-Tiered Governance** - Framework for all other seeds313- **Meta. Governance Multiplies Velocity** - Philosophy314315### Operational Seeds (Day-to-Day)316- **02. Harness Trace** - Transparency and debugging317- **03. Context Iceberg** - Token and cost management318- **07. Safety Switch** - Error handling319- **09. Mode-Based Complexity Gating** - Query routing320321### Architectural Seeds (System Design)322- **04. Agent Connect** - Multi-agent coordination323- **10. Shared Infrastructure** - Reusable services324325### Delivery Seeds (Shipping)326- **05. Go-Live Bundles** - Packaging and reuse327- **06. Cost Guard** - Budgeting and planning328329### UX Seeds (User Experience)330- **08. Implicit Perspective Extraction** - Reduce friction331332### Field Seeds (From Practice)333- **11. Voice Before Structure** - Ground in philosophy before writing334- **12. Pointer Directories** - Understand provenance before filling gaps335- **13. Granular Visibility** - Track progress for the user, not the agent336337## Seed Maintenance338339### When to Update a Seed340- Pattern evolves based on new learnings341- Better approach discovered342- User feedback suggests improvement343344### When to Archive a Seed345- Pattern no longer applies346- Superseded by better approach347- Context has fundamentally changed348349### Versioning Convention350- **1.0** - Initial version from Dataiku research351- **1.1** - Minor update (clarification, example added)352- **2.0** - Major update (pattern changed)353354### Update Process3551. Identify need for update3562. Draft new version3573. Test with real scenarios3584. Update seed file with "Revised:" section3595. Update seed_catalog.md3606. Notify users of change361362## Best Practices363364### Frequency365- **Proactive:** Suggest seeds during planning and design366- **Reactive:** Apply seeds when debugging or optimizing367- **Continuous:** Track usage to identify most valuable seeds368369### Application370- **Read the full seed** before applying (don't just skim)371- **Follow the checklist** to validate application372- **Note what it refuses** to avoid anti-patterns373- **Track usage** to measure effectiveness374375### Evolution376- **Update when patterns evolve** (not just for the sake of updating)377- **Archive when obsolete** (don't hoard outdated seeds)378- **Version carefully** (breaking changes = major version bump)379380## Limitations381382### What This Skill Does383- Suggest relevant seeds based on keywords384- Load and explain how to apply seeds385- Track usage over time386- Provide quick reference to all seeds387388### What This Skill Doesn't Do389- Automatically apply seeds (you still need to implement)390- Make architectural decisions for you391- Guarantee success (seeds are patterns, not silver bullets)392- Replace deep thinking (seeds guide, they don't replace reasoning)393394## Quick Reference395396| Task | Command |397|------|---------|398| Suggest seeds | `python3.11 suggest_seeds.py <keywords...>` |399| Apply seed | `python3.11 apply_seed.py <seed_id>` |400| View catalog | `file read references/seed_catalog.md` |401| Check usage | `cat /home/ubuntu/.seed-usage.json` |402| List all seeds | `ls /home/ubuntu/skills/seed-library/seeds/` |403404## Success Metrics405406- **Accessibility:** Find relevant seed in < 10 seconds407- **Consistency:** Seeds applied correctly 90%+ of the time408- **Evolution:** Seeds updated when patterns improve409- **Reuse:** Seeds used across multiple sessions410- **Learning:** New seeds added as patterns emerge