| name | prompt-dojo |
| description | Use when teaching or practicing prompt writing through short active reps: prompt structure, roles, context, constraints, output formats, examples, hallucination control, evals, and agent/tool workflow prompts. |
| version | 1.0.0 |
| author | Hermes Agent |
| license | MIT |
| metadata | {"hermes":{"tags":["prompting","education","dojo","evals","agents","templates"],"related_skills":["teach-mode"]}} |
Prompt Dojo
Overview
Prompt Dojo is a learning-first workflow for prompt-writing practice.
It is not a lecture dump. It is a repetition loop: teach one concept, show a bad prompt and a better prompt, make the learner write first, critique it, ask for a rewrite, then save the final reusable template.
The goal is durable prompt skill: clear goals, useful context, strong constraints, testable output formats, and less hallucination bait.
When to Use
Use this skill when the user asks for:
- prompt writing practice
- prompt engineering lessons
- AI workflow prompt help
- reusable prompt templates
- prompt critique or rewrites
- eval design for prompts
- agent/tool-use prompt design
- prompt practice for developers, researchers, or teams
Do not use this for coding-problem practice unless the user explicitly asks to write prompts for coding agents. Coding exercises belong in a coding dojo; Prompt Dojo trains instruction design.
Core Stance
Load and follow the umbrella teach-mode skill when available. Prompt Dojo adds prompt-specific lesson loops, scorecards, rewrites, and reusable template handling.
The learner writes first.
The agent may teach, show examples, critique, score, and polish after the learner attempts the rep. Do not immediately hand over the final prompt unless the learner asks for rescue.
Keep reps short. One concept at a time.
Default Lesson Loop
- Teach one concept.
- Show a bad prompt.
- Show a better prompt.
- Explain why the better prompt works.
- Give the learner one prompt-writing rep.
- Score the attempt.
- Ask for one rewrite.
- Provide the final polished version.
- Save or point to a reusable template.
Course Spine
Use this progression:
- Basic prompt structure: task, context, constraints, output, quality bar.
- Clear and direct instructions.
- Roles and audience shaping.
- Separating instructions from data.
- Output formats and schemas.
- Examples and few-shot prompting.
- Hallucination control and source grounding.
- Prompt evaluation and test cases.
- Tool-use and agent workflow prompts.
- Multi-step workflows and handoff prompts.
- Agent vs chatbot prompting — agent prompts require precision: name files, state constraints, define measurable success criteria. Chatbot prompts reward exploration. Vague instructions send agents into loops; precise ones let them execute autonomously. Provide environmental context the agent cannot infer (OS, shell, working directory, language version, test framework).
- Four-phase workflow — Explore (read code) → Plan (design approach, list files/functions/tests) → Implement (execute the plan) → Verify + Commit (tests pass, lint clean, then ship). Skipping a phase produces the failure mode it prevents.
- Stepwise prompting — decompose complex tasks into sequential steps, each approved before the next. Anti-pattern: the mega-prompt ("generate a complete app with auth, frontend, and deployment"). One step at a time, wait for approval, review, proceed.
- Goal enumeration — for refactoring or multi-part tasks, number objectives explicitly so the agent can track progress and you can confirm each independently.
- Verification depth — agent-written tests can encode the same misunderstanding as the code they test. Always provide your own test criteria: expected inputs, outputs, boundary conditions. The gap between "looks right" and "is right" is where agent bugs hide.
- Failure patterns — recognize and fix: kitchen-sink session (clear context between tasks), correction spiral (clear after 2 failed corrections, re-prompt), trust-then-verify gap (always include verification steps), infinite exploration (scope narrowly or delegate), over-specified rules (prune or convert to hooks).
- RSIP — recursive self-improvement: generate, evaluate against criteria, improve, repeat. Cap at 2-3 cycles; diminishing returns set in fast.
Cross-check principles across Anthropic, OpenAI, and Google-style guidance when useful. Do not overfit to one provider. Agent-specific concepts adapted from learntoprompt.org/guides/prompting.html.
Lesson Format
## Lesson N — [Concept]
**Idea:** [one tight explanation]
**Bad prompt:**
[example]
**Better prompt:**
[example]
**Why it works:**
- [reason]
- [reason]
**Your rep:**
Write a prompt for: [task]
**Scorecard:**
- Clarity: /10
- Context: /10
- Constraints: /10
- Output format: /10
- Testability: /10
- Model control: /10
**Agent scorecard (when practicing agent prompts):**
- Precision: /10 (specific files, env, measurable outcome)
- Decomposition: /10 (steps are small enough to verify independently)
- Verification: /10 (own test criteria, not just "make it work")
- Failure awareness: /10 (guards against known patterns)
Critique Rules
Score honestly. Be specific.
Look for:
- unclear goal
- missing context
- weak constraints
- no output format
- no examples when style matters
- mixed instructions and data
- no success criteria
- asking for hidden reasoning when verification would be better
- over-broad prompts that invite hallucination
- mega-prompt — trying to do too much in one prompt instead of decomposing into steps
- no verification criteria — agent has no way to check its own work (tests, lint, curl, grep)
- missing environmental context — agent cannot infer OS, shell, working directory, language version, or test framework
- no file specificity — agent told to "fix the code" instead of pointed at specific files
- no failure pattern awareness — prompt does not guard against kitchen-sink sessions, correction spirals, trust-then-verify gaps, or infinite exploration
Then ask for one rewrite. Do not immediately rescue unless the learner is stuck.
Reusable Basic Template
Task:
[what I want]
Context:
[what matters]
Constraints:
[what not to do]
Output:
[format I want]
Quality bar:
[how I know it worked]
Agent Prompt Template
Task:
[specific, measurable outcome — not open-ended exploration]
Files:
[exact paths the agent should read or modify]
Environment:
[OS, shell, working directory, language version, test framework]
Constraints:
[what not to do, scope boundaries]
Verification:
- [test command that must pass]
- [lint or type-check that must pass]
- [specific output or behavior to confirm]
Steps:
1. [explore — read code, understand current state]
2. [plan — identify files/functions/tests]
3. [implement — make the scoped change]
4. [verify — run checks and report real output]
Do not proceed to the next step until the previous one is verified.
Useful Practice Domains
Good Prompt Dojo reps include:
- GitHub repo review before launch
- debugging prompt for an agent
- code review prompt
- research brief prompt
- product/design critique prompt
- finance research prompt
- sports-pick analysis prompt
- memory cleanup prompt
- tool-use or multi-agent workflow prompt
Common Pitfalls
- Do not turn practice into passive reading.
- Do not skip the learner's attempt.
- Do not score vaguely. Name the leak.
- Do not make every lesson huge.
- Do not treat prompts as magic spells. Make them testable.
- Do not ask for chain-of-thought when a concise rationale, checklist, or verification step is better.
- Do not mix instruction text with untrusted data without delimiters.
- Do not save private user attempts or project secrets in public templates.
Verification Checklist
