Suggests and loads Dojo Seed Patches as reusable thinking modules, producing a ranked seed recommendation with a full application guide. Use when: 'which seed applies here', 'suggest a seed pattern', 'apply a seed to this', 'what pattern should we use', 'load the seed library'.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
A direct command skips the review prompt. Inspect the source before running it.
Suggests and loads Dojo Seed Patches as reusable thinking modules, producing a ranked seed recommendation with a full application guide. Use when: 'which seed applies here', 'suggest a seed pattern', 'apply a seed to this', 'what pattern should we use', 'load the seed library'.
category
wisdom-garden
triggers
["which seed applies here","suggest a seed pattern","apply a seed to this","what pattern should we use","load the seed library"]
tier
1
agents
["primary"]
tool_dependencies
["file_system"]
inputs
[{"name":"context","type":"string","description":"The current situation or problem context to match against seed patterns","required":true}]
outputs
[{"name":"seed_recommendation","type":"string","description":"Ranked seed recommendation with full application guide for the current context"}]
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.)
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 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
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
Output
A seed recommendation saved to /home/ubuntu/seed-suggestions.md — top 3 ranked seeds with relevance scores and file paths
A seed application guide saved to /home/ubuntu/seed-<seed_id>-applied.md — full seed content, application checklist, and next steps
Usage tracked automatically in /home/ubuntu/.seed-usage.json
Examples
Scenario 1: User says "which seed applies to multi-agent coordination?" → runs suggest_seeds.py multi-agent coordination, returns top 3 (Agent Connect, Three-Tiered Governance, Shared Infrastructure) with relevance scores, saves to seed-suggestions.md.
Scenario 2: User says "apply the Context Iceberg seed" → runs apply_seed.py 03_context_iceberg, loads full seed content, generates application checklist for the current task, saves guide to seed-03_context_iceberg-applied.md.
Edge Cases
If no keywords match any seed triggers, prompt the user for the core problem being solved (cost? coordination? trust?) rather than returning an empty result.
If the user requests a seed by name that does not exist in the library, list the 13 available seeds and ask for clarification.
Anti-Patterns
Suggesting a seed without running the suggestion script — keyword matching is essential for relevance; do not rely on recall alone.
Applying a seed without reading the full seed content — skimming the trigger and skipping "What It Refuses" leads to misapplication.
