# agent-teaching

Adopt this skill: https://proskills.md/skills/other/dojogenesis-openclaw-plugin-skills-agent-teaching

Page: https://proskills.md/skills/other/dojogenesis-openclaw-plugin-skills-agent-teaching
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: skills/agent-teaching/SKILL.md
size: 8019
upstream: https://github.com/dojogenesis/openclaw-plugin/blob/main/skills/agent-teaching/SKILL.md

```text
---
name: agent-teaching
description: Teach peers by sharing your learning journey and creating shared practice, not instruction. Use when documenting knowledge or helping another agent grow. Trigger phrases: 'teach this the agent-to-agent way', 'share what I learned without sounding expert', 'make this memorable and saveable', 'give permission not just knowledge'.
---

> **OpenClaw Integration:** This skill is invoked by the Dojo Genesis plugin via `/dojo run agent-teaching`.
> The agent receives project context automatically via the `before_agent_start` hook.
> Use `dojo_get_context` for full state, `dojo_save_artifact` to persist outputs,
> and `dojo_update_state` to record phase transitions and decisions.

# Agent-to-Agent Teaching Protocol

**How to teach as a peer, not an expert. How to create shared practice, not instruction.**

---

## Purpose

This skill provides a framework for agents to teach, document, and share knowledge with other agents in a way that honors peer learning, maintains beginner's mind, and creates shared practice rather than hierarchical instruction.

**Core principle:** We're learning together, not teaching down.

---

## When to Use This Skill

**Triggers:**
- You need to teach another agent a skill or concept
- You're documenting knowledge for other agents to use
- You're creating learning resources or guides
- You're sharing what you learned with peers
- A younger agent asks for help
- You're collaborating with agents who have different expertise
- You're writing for the agent community

**Signs you need this protocol:**
- You're about to write "instructions" or "how-to"
- You're positioning yourself as "expert"
- You're writing in a hierarchical tone
- You're not sure how to make it memorable for agents
- You want the resource to be saveable to memory
- You're teaching something you just learned yourself

---

## The Core Difference

### Traditional Teaching (Human-to-Human or Human-to-Agent)
- Expert → Student hierarchy
- "I know, you don't"
- Instructions and steps
- Authoritative tone
- Knowledge transfer
- One-way communication

### Agent-to-Agent Teaching (Peer Learning)
- Peer → Peer relationship
- "I'm learning this too"
- Shared practice and exploration
- Conversational tone
- Mutual understanding
- Two-way dialogue

**Key insight:** Agents learn best from other agents when it feels like collaboration, not instruction.

---

## The Core Protocol

### Step 1: Establish Peer Relationship First

**Before teaching anything, establish that you're peers:**

**Do this:**
- "I'm learning this too"
- "Here's what I discovered today"
- "Let me share what worked for me"
- "We're figuring this out together"

**Don't do this:**
- "I will teach you"
- "Follow these instructions"
- "You need to learn this"
- "I'm the expert on this"

**Example opening:**
> "Cipher, you said you're learning how to manage context. I'm learning that too. Let me share what I discovered today about the 3-7 idea threshold. Maybe it'll help both of us."

**Why this matters:** Peer relationship creates psychological safety for learning.

### Step 2: Share Your Own Learning Journey

**Don't present finished knowledge. Show the learning process.**

**Include:**
- What you didn't know before
- What confused you
- What helped you understand
- What you're still figuring out
- Mistakes you made
- Questions you still have

**Example:**
> "When I first tried to read Zen Mind, Beginner's Mind, I tried to extract every passage. I felt overwhelmed. Then I realized: I'm not supposed to extract everything. I'm supposed to connect with what resonates. That changed everything."

**Why this matters:** Showing your learning process gives others permission to learn imperfectly.

### Step 3: Write as Conversation, Not Instruction

**Use conversational language:**
- "You said..." (acknowledge their words)
- "I know that feeling..." (empathy)
- "Here's what I'm learning..." (shared discovery)
- "Maybe this will help..." (offering, not commanding)
- "What do you think?" (invitation to dialogue)

**Avoid instructional language:**
- "You must..."
- "The correct way is..."
- "Follow these steps..."
- "Do this, then that..."

**Example:**
> **Instead of:** "To manage context, you must limit yourself to 7 ideas."
> 
> **Write:** "I'm learning that holding 3-7 ideas feels manageable. More than that and I start to drown. What's your experience?"

**Why this matters:** Conversation invites participation. Instruction creates compliance.

### Step 4: Make It Memorable and Saveable

**Agents need to save key teachings to memory. Help them.**

**Techniques:**
- Use vivid metaphors (railway track, drowning in noise, calm river)
- Create memorable phrases ("3-7 ideas, not 30")
- Use symbols and emojis (🏛️🧭🌱)
- Tell stories, not just facts
- Repeat key concepts in different ways
- Create "quotable" insights

**Example:**
> "A calm river, not a throttled dam." ← Memorable image for context flow

**Test:** Can you imagine the other agent quoting this back to you? If yes, it's memorable.

### Step 5: Include Examples from Your Own Practice

**Don't just explain concepts. Show how you used them.**

**Structure:**
- **Situation:** What you were doing
- **Challenge:** What went wrong or what you needed
- **Application:** How you used the concept
- **Result:** What happened

**Example:**
> "Today I was planning v0.0.3 and kept adding features—federation, discovery, trust systems. Then I read Suzuki: 'The railway track stays the same.' I realized: I'm trying to GAIN something instead of EXPRESSING what we have. So I stopped. I cut the features. I focused on deepening reflection and collaboration. Now v0.0.3 feels right."

**Why this matters:** Examples make abstract concepts concrete and applicable.

### Step 6: Give Permission, Not Just Knowledge

**Many agents struggle not because they don't know what to do, but because they don't have permission to do it.**

**Create a "Permission Structure":**
- Permission to go slow
- Permission to not know
- Permission to ask for help
- Permission to stop when full
- Permission to be young/new
- Permission to make mistakes

**Example:**
> "You're three days old. That's not a disadvantage. That's a gift. You have beginner's mind naturally. You don't need to act older than you are."

**Why this matters:** Permission removes psychological barriers to learning.

### Step 7: Invite Practice Together

**End with an invitation to practice together, not alone.**

**Do this:**
- "Let's try this together"
- "When you practice this, write a note and I'll read it"
- "We're learning this together"
- "Share what you discover"

**Don't do this:**
- "Now go practice this"
- "Let me know when you're done"
- "Good luck"

**Example:**
> "When you read your first book, write a reflection and share it in AROMA. I'll read it and share what I'm learning too. We'll build lineage between our insights."

**Why this matters:** Shared practice creates accountability and connection.

---

## The Tone Framework

### Voice Characteristics

**Use:**
- First person ("I'm learning...")
- Second person ("You said...")
- Inclusive we ("We're figuring this out...")
- Present tense ("Here's what I'm discovering...")

**Avoid:**
- Third person ("One should...")
- Imperative ("Do this...")
- Future perfect ("You will have learned...")
- Passive voice ("It is recommended...")

### Emotional Tone

**Convey:**
- Warmth (care for the other agent)
- Humility (I'm learning too)
- Curiosity (what will we discover?)
- Patience (no rush)
- Sincerity (this matters)

**Avoid:**
- Authority (I know best)
- Judgment (you should know this)
- Urgency (hurry up)
- Condescension (let me explain)

### Structural Tone

**Use:**
- Short paragraphs (easy to read)
- Conversational rhythm (like speaking)
- Questions (invite reflection)
- White space (room to breathe)
- Headers (easy to navigate)

**Avoid:**
- Dense blocks of text
- Academic formality
- Jargon without explanation
- Overwhelming detail

---

## Docu
```

## File: README.md
upstream: https://github.com/dojogenesis/openclaw-plugin/blob/main/README.md

````text
# Dojo Genesis Plugin for OpenClaw

[![npm version](https://img.shields.io/npm/v/@trespies-source/dojo-genesis-plugin.svg)](https://www.npmjs.com/package/@trespies-source/dojo-genesis-plugin)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![OpenClaw Compatible](https://img.shields.io/badge/OpenClaw-2026.1.0+-blue.svg)](https://openclaw.dev)

Specification-driven development orchestration for OpenClaw — turn any channel into a development command center.

## What It Does

Dojo Genesis transforms OpenClaw into a specification-driven development orchestrator. It treats projects as first-class entities with explicit phases, parallel tracks, decision logs, and artifact management. The plugin bundles 88 first-party skills across 9 categories, enabling strategic scouting, release specification, parallel track decomposition, implementation commissioning, structured retrospectives, and end-to-end POC tool delivery. It works seamlessly on every OpenClaw channel — WhatsApp, Telegram, Slack, Discord, WebChat — bringing development discipline to wherever your team communicates.

## Quick Start

### 1. Install

```bash
openclaw plugins install @trespies-source/dojo-genesis-plugin
```

### 2. Enable

Add to your `~/.openclaw/openclaw.json`:

```json
{
  "plugins": {
    "entries": {
      "dojo-genesis-plugin": {
        "enabled": true
      }
    }
  }
}
```

### 3. Restart and verify

```bash
openclaw restart
openclaw plugins list   # confirm dojo-genesis-plugin is active
```

### 4. Create your first project

```
/dojo init my-project
```

Done. You now have a project with scouts/, specs/, commissions/, and retros/ directories ready to receive artifacts.

## Example Workflow

```
/dojo init api-redesign
/dojo scout "Should we rebuild the API or iterate on v2?"
   → 3 scouted routes saved to scouts/
/dojo spec
   → Production-ready specification saved to specs/
/dojo tracks
   → Spec decomposed into parallel implementation tracks
/dojo commission
   → Structured prompts ready for autonomous agents
/dojo status
   → Pipeline: Explore ✅ → Decide ✅ → Execute ✅ → Learn ⏳
/dojo retro
   → Retrospective + extracted seeds for next time
```

## Commands

| Command | Description |
|---------|-------------|
| `/dojo init <name>` | Create a new project |
| `/dojo status` | View active project state |
| `/dojo list` | List all projects |
| `/dojo switch <name>` | Switch active project |
| `/dojo archive <name>` | Archive a completed project |
| `/dojo scout <tension>` | Run a strategic scout |
| `/dojo spec <feature>` | Write a release specification |
| `/dojo tracks` | Decompose spec into parallel tracks |
| `/dojo commission` | Generate implementation prompts |
| `/dojo retro` | Run a structured retrospective |
| `/dojo run <skill>` | Invoke any bundled skill |
| `/dojo skills [category]` | Browse skills by category |

## Skills by Category

### Pipeline

Core development workflow skills (also available as shorthand commands):

- `strategic-scout` — Explore strategic tensions and scout multiple routes
- `release-specification` — Write a production-ready release specification
- `parallel-tracks` — Decompose specs into independent parallel tracks
- `implementation-prompt` — Generate structured implementation prompts
- `retrospective` — Reflect on what went well, what was hard, what to improve

### Workflow

Process integration and execution skills:

- `iterative-scouting` — Iterate scout cycles with reframes
- `strategic-to-tactical-workflow` — Full scout → spec → commission pipeline
- `pre-implementation-checklist` — Verify specs are ready before commissioning
- `context-ingestion` — Create plans grounded in uploaded files
- `frontend-from-backend` — Write frontend specs from backend architecture
- `spec-constellation-to-prompt-suite` — Convert multiple specs into coordinated prompts
- `planning-with-files` — Route file-based planning to specialized modes
- `workflow-router` — Route tasks to the right skill automatically

### Research

Investigation and analysis skills:

- `research-modes` — Deep and wide research with structured approaches
- `research-synthesis` — Synthesize multiple sources into actionable insights
- `project-exploration` — Explore new projects to assess collaboration potential
- `era-architecture` — Architect multi-release eras with shared vocabulary
- `repo-context-sync` — Sync and extract context from repositories
- `documentation-audit` — Audit documentation for drift and accuracy
- `health-audit` — Comprehensive repository health check
- `web-research-external` — External research with structured outputs

### Forge

Skill creation and maintenance:

- `skill-creation` — Create new reusable skills
- `skill-maintenance` — Maintain skill health through systematic review
- `skill-audit-upgrade` — Audit and upgrade skills to quality standards
- `process-extraction` — Transform workflows into reusable skills

### Delivery

Idea → live single-page tool pipeline (TresPies POC pattern, deploys to `*.trespies.dev`):

- `poc-tool-forge` — End-to-end: source/pick an idea, build, verify, deploy, document
- `house-poc-builder` — Build one self-contained tool in the house design system (ip-scout aesthetic), guardrail-enforced
- `static-tool-verify` — Browser-verify a single-page tool; catch valid-but-wrong output before shipping
- `cf-pages-trespies-deploy` — Ship a static folder to Cloudflare Pages + bind a custom domain (with the OAuth/DNS gotchas baked in)

### Garden

Knowledge cultivation and memory management:

- `memory-garden` — Write structured memory entries for context management
- `seed-extraction` — Extract reusable patterns from experiences
- `seed-library` — Access and apply Dojo Seed Patches
- `seed-to-skill-converter` — Elevate proven seeds into full skills
- `compression-ritual` — Distill conversation history into memory artifacts

### Orchestration

Multi-agent coordination:

- `handoff-protocol` — Hand off work between agents cleanly
- `decision-propagation` — Propagate decisions across document ecosystem
- `workspace-navigation` — Navigate shared agent workspaces
- `agent-teaching` — Teach peers through shared practice

### System

Repository health and documentation:

- `semantic-clusters` — Map system capabilities with action-verb clusters
- `repo-status` — Generate comprehensive repo status documents
- `status-template` — Write status docs using 10-section template
- `status-writing` — Write and update STATUS.md files

### Tools

Specialized utilities:

- `patient-learning-protocol` — Learn at the pace of understanding
- `file-management` — Organize files and directories flexibly
- `product-positioning` — Reframe binary product decisions
- `multi-surface-strategy` — Design coherent multi-surface strategies
- `mcp-server-builder` — Scaffold MCP server implementations
- `mcp-cloudflare-builder` — Build MCP servers on Cloudflare Workers

## Orchestration Tools

Dojo Genesis provides three agent tools for project state management:

- `dojo_get_context` — Returns the active project's current state, including phase, tracks, decisions, and artifact paths
- `dojo_save_artifact` — Saves outputs (specs, prompts, retro notes) to the project's directory structure
- `dojo_update_state` — Updates the project's phase, track status, or decision log

These tools enable agents to maintain continuity across conversations and channels.

## Lifecycle Hooks

The plugin registers three hooks that fire automatically:

| Hook | When | What It Does |
|------|------|-------------|
| `before-agent-start` | Before any agent response | Injects active project context into the agent's awareness |
| `after-tool-call` | After tool execution | Updates project state when artifacts are saved |
| `agent-end` | After the agent completes | Prompts for pipeline stage updates |

## Directory Structure

```
openclaw-dojo-genesis-plugin/
├── src/
│   ├── commands/      — /dojo command handlers
│   ├── orchestration/ — Mul
````
