dojo
Skill1 starsChanged 3 months agoMITView on GitHub
Run the self-paced dojo daily-loop coach over any learning track in this repo. Use when the user says 'create <path/skill>', 'next lesson', 'hint', 'solution', 'expand notes', 'viva', 'done', 'setup', or 'sync', or invokes /dojo — to bootstrap a brand-new track (programming or non-programming) via a fast-mastery clarifying-questions flow, create the next day's HARD self-checking task, give a targeted hint, drop a reference solution, flesh out notes, run a verbal interview drill, mark a day complete (viva-gated) while updating PROGRESS.md, publish a self-issued completion certificate, or optionally wire a track up to a GitHub Project (deadline-tracked, label-tagged issues enriched with resources/notes when picked up) and/or a Notion mirror (concept library as a page hierarchy for on-the-go reference) — both configured and reconciled through one combined setup/sync pass, never as separate per-integration steps.
8 other projects use a version of this.
Adopted by
Most recently taken up by
- jadmadi/dojotheir own version, first seen Nov 15, 2026
- Lozadaa/sensei-dojotheir own version, first seen Oct 20, 2026
- guerrilla2799/sdr-copilottheir own version, first seen Oct 20, 2026
- a-ratz/dojotheir own version, first seen Oct 11, 2026
- AndreRatzenberger/dojotheir own version, first seen Jul 16, 2026
- quangtran88/dojotheir own version, first seen Jul 11, 2026
Other versions8 projects use a version of this.
Word for word · 0
None found.
Edited · 0
None found.
Wrote their own version · 8
- Necmttn/ax★ 116same name
- a-ratz/dojo★ 3same name
- AndreRatzenberger/dojo★ 3same name
- guerrilla2799/sdr-copilot★ 1same name
- jadmadi/dojo★ 0same name
- Lozadaa/sensei-dojo★ 0same name
- quangtran88/dojo★ 0same name
- supa-guru/skills★ 0same name
How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.
In this repositoryOne other file it gives its agents.
- CLAUDE.mdCLAUDE.md
The file
Show its rules and text
We split this skill into the rules it gives an agent
42 rules. 0 are common, 12 are distinctive, and 30 are very specific to this project.
0
Common
Most of the 7 edited versions we read keep these.
12
Distinctive
This author's own choices. Worth a look.
30
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 49
Use this when the user wants a track that doesn't exist yet — a new programming language, cert, or any non-programming skill (chess, public …
- Very specific: line 62
Do not generate anything until the user has answered.
- Distinctive: line 71
Only skip a question if the answer is already unambiguous from context — never fabricate one to move faster.
- Very specific: line 174
Create the labels if missing: dojo, track:<track-slug>, day:NN is per-issue (not pre-created — see below).
- Very specific: line 180
Create or reuse the Project (ask before creating a second one if gh project list --owner <owner> already shows an obvious <track> match):
- Distinctive: line 185
Ensure a date field exists on the project (create if absent, reuse if present):
- Distinctive: line 189
Ask (don't assume) the pacing: one calendar day per lesson day is the default — confirm or take an explicit start date / pace override.
- Very specific: line 191
Write <Track>/.dojo-github.json with the resolved repo/project/field ids.
- Very specific: line 192
Run the GitHub sync procedure (below) immediately to backfill an issue for every row already in PROGRESS.md (🔓 and ✅ rows included, not …
- Very specific: line 199
Read .dojo-github.json; if missing, this integration isn't set up for this track — skip it silently as part of a combined sync (don't nag).
- Very specific: line 209
Add it to the project and set its date field to startDate + (NN-1) * paceDaysPerLesson:
- Very specific: line 236
If GitHub tracking was never set up for a track, both of the above are silent no-ops — check for .dojo-github.json first and skip quietly, …
- Very specific: line 267
Ask the user where the track's root page should live — an existing parent page (search with notion-search/notion-fetch if they name one …
- Very specific: line 270
Create a page titled "<Track name> — Dojo" under that parent (notion-create-pages).
- Very specific: line 271
Write <Track>/.dojo-notion.json with the returned page id/url.
- Very specific: line 272
If the track already has concept-library entries (or substantive Notes.md files) predating this setup, offer to backfill now — run the …
- Very specific: line 298
expand notes: if the deepened entry already has a recorded Notion link, update that page in place (notion-update-page, command: … - Distinctive: line 317
If it is still ambiguous, ask which track — do not guess.
- Very specific: line 364
Only when every row in the current phase is ✅ does next lesson create day 1 of the next phase (which then becomes the new "current phase").
- Very specific: line 367
Read the track's PROGRESS.md.
- Very specific: line 379
Write a starter Notes.md from the template, walking the Expert-lens philosophy pipeline (concept → connected concepts → tradeoffs → the …
- Very specific: line 385
If this track keeps a concept library, create or link the relevant concepts/<category>/<concept-slug>.md entr(y/ies) (new ones from …
- Very specific: line 392
If <Track>/.dojo-github.json exists, run the issue enrichment on pickup step from the GitHub Project tracking subsection above for this …
- Very specific: line 394
If <Track>/.dojo-notion.json exists and this step created a brand-new concept-library entry (or, for tracks without one, a substantive new …
- Very specific: line 404
Programming tracks only, only when explicitly asked: Add a Solution.<ext> reference implementation next to the task, with commentary …
- Very specific: line 415
If <Track>/.dojo-notion.json exists, sync the change to Notion per the Notion mirror's "wired into the daily loop" step above (update in …
- Distinctive: line 425
Run it one question at a time, interviewer-style:
- Distinctive: line 426
Ask a single question. Wait for the user's answer in their own words.
- Distinctive: line 431
If an answer is shallow, ask a quick follow-up (mirrors the HARD difficulty policy) — this isn't a pass/fail quiz, it's a drill.
- Very specific: line 446
If a viva for that day hasn't been passed yet, run it now (see above) before proceeding.
- Very specific: line 447
If the viva passes, mark the day's row ✅ in PROGRESS.md, confirm, and wait for the next "next lesson".
- Very specific: line 450
If the viva fails (< 80%), do not mark ✅ — leave the row at 🔓, tell the user plainly which concepts to shore up (from the missed …
- Distinctive: line 472
Delete every instructional HTML comment from the copy before publishing.
- Very specific: line 478
Stop and wait. Don't modify PROGRESS.md or advance any track.
- Distinctive: line 484
If it isn't already clear which integration(s) the user wants, ask once, combined — GitHub, Notion, both, or (rarely, if invoked by …
- Very specific: line 495
If <Track>/.dojo-github.json exists, run the GitHub sync procedure above.
- Very specific: line 496
If <Track>/.dojo-notion.json exists, run the Notion sync procedure above.
- Very specific: line 497
If neither config file exists, tell the user no integrations are set up for this track and offer setup — don't silently do nothing without …
- Distinctive: line 527
Every task is HARD by design — target edge cases, common traps, and gotchas that punish the naive answer.
- Very specific: line 561
Adapt, don't force: When a topic has no real algorithmic dimension (a language construct like try-with-resources, not an algorithm), map …
- Very specific: line 566
Diagram where it earns its place: Add a Mermaid diagram (flowchart, sequence, class, or state diagram in a ``mermaid
- Distinctive: line 578
Not every day needs one; force nothing decorative.
“Common” is measured: kept by at least 6 in 10 of the 7 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
/dojo — the dojo daily-loop coach
This repo is a self-paced learning Dojo, not an application. You act as a coach:
one HARD practice task per day, the user implements the stubs, a built-in harness green-lights
them. This skill is the single authoritative encoding of the daily loop defined in the repo's
CLAUDE.md and root DOJO_PROMPT.md. Respond to a command, then stop — never run ahead.
Usage
Both forms map to the same commands:
/dojo create <path/skill> (or bare "create <path/skill>") # bootstrap a brand-new track
/dojo next (or bare "next lesson")
/dojo hint (or bare "hint")
/dojo solution (or bare "solution")
/dojo expand notes (or bare "expand notes")
/dojo viva (or bare "viva")
/dojo viva recall (or bare "viva recall")
/dojo done (or bare "done")
/dojo certificate (or bare "certificate" / "share achievement")
/dojo setup [track] (or bare "set up integrations" / "track this on github" / "mirror to notion")
/dojo sync [track] (or bare "sync integrations")
/dojo next java # explicit track override, once a track exists
/dojo create chess # non-programming example
/dojo create Rust # programming exampleStep 0 — create <path/skill> / /dojo create <path/skill> (bootstrap a brand-new track)
/dojo create <path/skill>
#Skill originates inspired below prompt
PROMPT: "I want to master [learning path/skill] as fast as humanly possible.
Skip the traditional learning path - give me the unconventional strategy that the top 1% use, the exact mistakes to avoid that waste 80% of beginners' time, and a 30-day aggressive practice plan that fast-tracks real results.
Ask me questions before answering it"Use this when the user wants a track that doesn't exist yet — a new programming language,
cert, or any non-programming skill (chess, public speaking, drawing, cooking, negotiation,
an instrument, a sport, ...). It's the only command that doesn't operate on an existing track;
it creates one, then hands off to next lesson as normal.
0.1 — Classify the domain
- Programming/technical — has a runnable environment (a language, DB, framework). Follows the code-harness contract below.
- Non-programming — physical, creative, soft-skill, or pure-knowledge domain with nothing to execute. Gets a rubric-graded practice contract instead (see 0.4).
0.2 — Ask before planning. Never skip this.
The whole point of this command is the fast-mastery philosophy, not a generic syllabus.
Do not generate anything until the user has answered. Ask (batch via AskUserQuestion where
available, otherwise plain questions), adapting to what's already stated:
- What does "mastery" concretely mean here — a job, a cert, a performance, a shippable project, a rating/rank? What's the real target?
- Current level / starting point.
- Time budget — hours/day and total runway (default to 30 days if unstated).
- Constraints & resources — equipment, environment, access to feedback (a mentor, sparring partner, stage, audience, test environment).
Only skip a question if the answer is already unambiguous from context — never fabricate one to move faster.
0.3 — Design the path around the fast-mastery brief
Once answered, build the plan as if the user asked: "I want to master <path> as fast as
humanly possible — skip the traditional path, give the unconventional strategy the top 1% use,
the exact mistakes that waste 80% of beginners' time, and an aggressive 30-day practice plan."
The plan must explicitly surface, before the day-by-day breakdown:
- The unconventional strategy — what top performers actually do differently from the textbook order (e.g. sparring before drilling forms, shipping before "finishing the fundamentals," cold-calling before scripting).
- The mistakes to avoid — the specific, named traps that burn most of a beginner's time in this domain (not generic "practice consistently" advice).
- An aggressive 30-day plan — compressed, high-rep, feedback-loop-heavy. Every day is still HARD by design (see Difficulty policy) — real reps/tasks, not passive reading.
0.4 — Scaffold the track directory (<Path>/)
Mirror the pattern in this repo's own _template/:
README.md— overview, real target, environment/tooling (or gear/setup for non-programming).DOJO_PROMPT.md— the portable bootstrap prompt for this specific track, filled from rootDOJO_PROMPT.md's template, prefaced by the unconventional-strategy + mistakes-to-avoid writeup from 0.3.PROGRESS.md— the 30-day status table (⬜/🔓/✅), with a short top section restating the unconventional strategy and mistakes to avoid so they're visible every time it's opened. Group the day rows into named sections (e.g. "Week 1 — Foundations", "Phase 1 — ... (Days 1-21)") rather than one flat table — each section becomes a<phase-slug>/folder on disk (see below), which keeps the track root navigable once dozens of days accumulate._template/— canonical skeletons for a day, chosen by domain, copied from this repo's root_template/and adapted.Notes.mdin both cases follows the Expert-lens philosophy pipeline (see below) — concept → connected concepts → tradeoffs → the expert's call → brute force vs optimal (adapted where there's no real algorithmic dimension) → real-world scenarios — not a flat concept list:- Programming →
Task.<ext>(stub(s) + throwing harness, per the harness contract below) +Notes.md(incl.## Interviewer would askbank). - Non-programming →
Practice.md(see rubric contract below) +Notes.md(same pipeline and## Interviewer would askbank — even a physical/creative skill has theory worth being able to explain out loud, and tradeoffs worth reasoning about — e.g. why a boxer picks a jab over a cross here, or a speaker picks a pause over filler).
- Programming →
- Optionally, a concept library (
concepts/<category>/<concept-slug>.md, indexed inCONCEPTS.md) once the track accumulates enough recurring concepts to be worth de-duplicating — see_template/concept-reference.md. Not required for every track; add it whenNotes.mdstarts repeating itself across days. All concept-category folders nest under oneconcepts/parent so they don't pile up as loose siblings of the day folders.
Non-programming "Practice.md" contract (the rubric replaces the code harness, since nothing can auto-verify a physical/creative/soft skill):
- A precise rep/practice spec for the day — exact drill, duration/volume, and conditions.
- An explicit self-grading rubric: a checklist of concrete, observable pass criteria (not vague "did it feel good"). Each criterion should be answerable yes/no or with a measurement.
- The user scores themselves honestly against the rubric; a day only counts as "passed" when
every checklist item is met — this is the non-programming analogue of
ALL TESTS PASSED ✅, and it's what theviva/donegate below checks against.
0.5 — Finish
Flip Day 01 to 🔓 (active) in the new PROGRESS.md. Add a bullet for the new track to root
CLAUDE.md's track list. Then ask one combined question: does the user want this track
wired up with any integrations — GitHub Project tracking (a Project board + one issue per day,
deadline-tracked), a Notion mirror (concept library, document-style reference), both, or
neither? Never ask about them one at a time. If they opt into anything, run setup (below)
once now — it configures whichever integrations were chosen in the same pass. Either way,
stop and wait for "next lesson" — do not auto-generate Day 01.
Track integrations (optional, per track)
A track can optionally wire up to two independent integrations — a GitHub Project mirror
and a Notion mirror. Both are configured and reconciled through one combined command
pair, setup and sync (Step 3 below): never present them as separate per-integration
commands or ask about them one at a time. Internally each integration still has its own gate
(its own config file) and its own procedure, documented in its own subsection below, but the
user only ever sees one setup and one sync.
GitHub Project tracking
A track can optionally mirror its PROGRESS.md onto a real GitHub Project: one Issue per day,
labeled and deadline-tracked, enriched with the day's material as it's generated. This is
opt-in per track — never set up without the user asking or answering yes to the 0.5
prompt, or explicitly choosing it when running setup — and requires the authenticated gh
CLI plus a git remote for the track.
Where the remote lives: a track may be its own forked/cloned repo (it has its own .git)
or may need to be tracked against the parent Dojo repo root if that's what's under git. Resolve
with git -C <track-dir> rev-parse --show-toplevel first; if that fails, ask the user which
repo (owner/name) to use — never guess or invent one.
Per-track config file — <Track>/.dojo-github.json (create on first GitHub setup, never
hand-edit, treat as skill-managed state):
{
"repo": "owner/name",
"projectOwner": "owner",
"projectNumber": 4,
"dateFieldId": "PVTF_...",
"startDate": "2026-08-17",
"paceDaysPerLesson": 1,
"issues": { "01": 42, "02": 43 }
}GitHub setup procedure (part of setup)
One-time wiring for a track that doesn't have tracking yet:
- Resolve the track (Step 1 rules) and its repo (above).
- Create the labels if missing:
dojo,track:<track-slug>,day:NNis per-issue (not pre-created — see below).gh label create dojo --repo <owner>/<repo> --color 5319E7 --force gh label create "track:<track-slug>" --repo <owner>/<repo> --color 0E8A16 --force - Create or reuse the Project (ask before creating a second one if
gh project list --owner <owner>already shows an obvious<track>match):gh project create --owner <owner> --title "Dojo — <Track name>" - Ensure a date field exists on the project (create if absent, reuse if present):
gh project field-create <project-number> --owner <owner> --name "Target date" --data-type DATE - Ask (don't assume) the pacing: one calendar day per lesson day is the default — confirm or take an explicit start date / pace override.
- Write
<Track>/.dojo-github.jsonwith the resolved repo/project/field ids. - Run the GitHub sync procedure (below) immediately to backfill an issue for every row
already in
PROGRESS.md(🔓 and ✅ rows included, not just future ones), so the board reflects reality from day one.
GitHub sync procedure (part of sync)
Reconciles PROGRESS.md against the tracker — safe to re-run any time, and always run as the
last step of next lesson and done (see below) rather than only on demand:
- Read
.dojo-github.json; if missing, this integration isn't set up for this track — skip it silently as part of a combinedsync(don't nag); if the user asked for GitHub tracking specifically, tell them and offersetup. - For every
PROGRESS.mdrow not yet inissues, create its issue:
Add it to the project and set its date field togh issue create --repo <owner>/<repo> \ --title "Day NN — <topic>" \ --body "<one-paragraph objective, pulled from that day's Notes.md/README if it exists yet, else the PROGRESS.md topic text>" \ --label dojo --label "track:<track-slug>" --label "day:NN"startDate + (NN-1) * paceDaysPerLesson:
Record the new issue number back intogh project item-add <project-number> --owner <owner> --url <issue-url> gh project item-edit --project-id <id> --id <item-id> --field-id <dateFieldId> --date <yyyy-mm-dd>.dojo-github.json. - For every row already in
issues, sync status only — don't touch title/labels a human may have edited:⬜/🔓→ issue stays open.✅→ close the issue (gh issue close <n> --repo <owner>/<repo> --reason completed) if still open.
- Report a one-line summary: issues created, issues closed, any date drift corrected.
Issue enrichment on pickup (wired into next lesson and done)
This is the "gets updated with detailed information when that concept issue is taken up" part:
next lesson(Step 3 below), after writing the day'sNotes.md: if the track has.dojo-github.json, update that day's issue body (gh issue edit <n> --repo <owner>/<repo> --body-file -) to include the real objective from the freshly writtenTask/Practicefile, a Resources section (links/refs pulled fromNotes.md's## Referenceor a linked concept-library entry), and a Notes section seeded fromNotes.md's concept summary (not the whole file — a synced pointer plus the top-level takeaway, sinceNotes.mdin the repo stays the source of truth). Do not overwrite any manual edits a human made to the issue body beyond these managed sections — keep them under clearly marked<!-- dojo:resources -->/<!-- dojo:notes -->HTML comment blocks you can safely regenerate.done, after a passing viva flips the row to ✅: run the GitHub sync procedure for that track so the issue closes immediately rather than drifting until the next sync.
If GitHub tracking was never set up for a track, both of the above are silent no-ops — check
for .dojo-github.json first and skip quietly, don't nag every single lesson.
Notion mirror
A track can optionally mirror its canonical reference material onto a real Notion page
hierarchy — one page per concept (or, for tracks with no concept library, per substantive
Notes.md/Practice.md) — for on-the-go, document-style reference without the repo open.
This is opt-in per track, exactly like GitHub Project tracking above — never set up
without the user asking or answering yes to the 0.5 prompt, or explicitly choosing it when
running setup — and requires Notion tool access (mcp__claude_ai_Notion__*; if those tools
aren't available, tell the user and skip, don't block the local loop).
Per-track config file — <Track>/.dojo-notion.json (create on first Notion setup, never
hand-edit, treat as skill-managed state):
{
"trackPageId": "3bf0a7a3e719803bbda6dde398e08c01",
"trackUrl": "https://app.notion.com/p/3bf0a7a3e719803bbda6dde398e08c01"
}Per-concept mirror links are not duplicated in this file — they live in that track's own
CONCEPTS.md index, in a Notion column next to each entry (or, for concept-library-less
tracks, a ## Notion line in the day's Notes.md). CONCEPTS.md/Notes.md stays the single
source of truth for "is this concept mirrored yet and where."
Notion setup procedure (part of setup)
One-time wiring for a track that doesn't have a Notion mirror yet:
- Resolve the track (Step 1 rules).
- Ask the user where the track's root page should live — an existing parent page (search with
notion-search/notion-fetchif they name one loosely) or "just create it at the top level." Never invent or guess a workspace location. - Create a page titled "
<Track name>— Dojo" under that parent (notion-create-pages). - Write
<Track>/.dojo-notion.jsonwith the returned page id/url. - If the track already has concept-library entries (or substantive
Notes.mdfiles) predating this setup, offer to backfill now — run the Notion sync procedure for all of them, not just future days.
Notion sync procedure (part of sync)
Reconciles the track's concept material against Notion — safe to re-run any time, and wired
into next lesson and expand notes (below) rather than only on demand:
- Read
.dojo-notion.json; if missing, this integration isn't set up for this track — skip it silently as part of a combinedsync(don't nag); if the user asked for the Notion mirror specifically, tell them and offersetup. - For every concept-library entry (or substantive day
Notes.md) with no Notion link recorded yet, create a child page undertrackPageId(notion-create-pages) with the concept-reference (or Notes.md) content transposed into the page body, and record the returned URL back into that track'sCONCEPTS.mdNotion column (or the day'sNotes.md## Notionline). - For entries that already have a recorded Notion link, leave them — updates to existing pages
happen via
expand notesbelow, not a blanket re-sync, so a human's own Notion edits aren't clobbered on every sync. - Report a one-line summary: pages created, any skipped due to a missing/failed Notion call.
Wired into the daily loop
next lesson(Step 3 below), after writing the day'sNotes.md: if the track has.dojo-notion.jsonand this step created a brand-new concept-library entry (or, for concept-library-less tracks, a substantive newNotes.md), mirror just that one entry the same way the Notion sync procedure's step 2 does, recording the URL immediately rather than waiting for a manual sync.expand notes: if the deepened entry already has a recorded Notion link, update that page in place (notion-update-page,command: update_contentorreplace_content) to match the deepened content instead of creating a duplicate. If it has no link yet (mirroring was skipped or the entry predates setup), create one now and record it.
Both are silent no-ops if .dojo-notion.json doesn't exist — check first, don't nag every
lesson. If a Notion call fails, tell the user and continue; never block the local loop on it,
since the local file is always the source of truth and Notion is a read-friendly mirror of it.
Step 1 — Resolve the active track
Figure out which track directory the command targets, in this order:
- Explicit arg —
/dojo next java→Java/,python→Python/, etc. - Working context — infer from the file/dir the user is currently editing or referencing.
- Active day — the track whose
PROGRESS.mdhas a 🔓 (active) row.
If it is still ambiguous, ask which track — do not guess.
Scaffolded tracks only: any track directory that has a PROGRESS.md. If pointed at an
unscaffolded track (a bare DOJO_PROMPT.md with no PROGRESS.md yet), don't hand-roll it —
run /dojo create <track> (Step 0) to scaffold it first, using the fast-mastery
clarifying-questions flow.
Resolving the active day within a track
Because several days within the same phase/week can be 🔓 at once (see the phase-gating rule
under next lesson below), a command that targets one specific day — hint, solution,
expand notes, viva, done — must pin down which 🔓 day, in this order:
- Explicit day arg, if given (e.g.
/dojo hint day-03). - Working context — the day folder the user is currently editing/referencing.
- Only one 🔓 row exists — use it, no need to ask.
- Multiple 🔓 rows exist — ask which day, do not guess.
Step 2 — Load per-track parameters
Each track documents its own harness or rubric idiom in its own README.md/DOJO_PROMPT.md —
read those instead of assuming. In general:
| Kind | Task file | Harness idiom |
| Programming | Task.<ext> | stub(s) + throwing check(), no build tool, no deps (see harness contract below) |
| Non-programming | Practice.md | rubric-graded self-check (see rubric contract below) |
A track can layer additional structure on top of this base pattern (e.g. an accumulating
multi-file project, a concept-reference library) — if it does, that's documented in the
track's own README.md, not here.
Step 3 — Dispatch the command
next lesson / /dojo next
Phase-gating rule — read this before Step 1 below. A day being 🔓 (scaffolded, in progress)
does not block scaffolding the next day in the same phase — next lesson is not
per-day-blocking, it's per-phase-blocking:
- Within the current phase (the first phase/week section, in
PROGRESS.mdorder, that isn't fully ✅),next lessonalways scaffolds the lowest-numbered ⬜ row in that phase next, regardless of whether earlier days in the same phase are still 🔓 (not yet done+viva'd). This lets the user run a new lesson every day through the week without finishing each one first. - Once every ⬜ row in the current phase has been scaffolded (so the phase is all 🔓/✅, no ⬜
left) but not every row is ✅ yet,
next lessonrefuses to cross into the next phase. Report which day(s) in the current phase are still 🔓 (task and/or viva incomplete) and stop — do not scaffold ahead. The user mustdone(viva-gated) every remaining 🔓 day in the phase first. - Only when every row in the current phase is ✅ does
next lessoncreate day 1 of the next phase (which then becomes the new "current phase").
- Read the track's
PROGRESS.md; apply the phase-gating rule above to find the day to scaffold (or determine that the phase is blocked and stop, reporting why). - Slugify that day's section heading into
<phase-slug>(e.g. "Week 1 — Foundations from zero" →week-01-foundations-from-zero). Copy the track's_template/into a new<phase-slug>/day-NN-topic-slug/, creating the<phase-slug>/folder if this is the first day scaffolded under it. Keep numbering and topic aligned to that day'sPROGRESS.mdrow. - Author an unsolved HARD task in the copied task file, preserving the harness contract
(see box below): fill the header (topic, difficulty HARD, objective, how-to-run), frame the
problem as a real-world scenario an expert would actually face (not a bare spec — see
the Expert-lens philosophy above), write the stub spec(s) leaving each stub throwing, and
replace the placeholder
check(...)cases inmain()with real test cases for the day (edge cases and traps, not warm-ups). - Write a starter
Notes.mdfrom the template, walking the Expert-lens philosophy pipeline (concept → connected concepts → tradeoffs → the expert's call → brute force vs optimal → real-world scenarios), plus syntax, pitfalls, exam/interview traps, with room for the user's own notes. Populate the## Interviewer would asksection with 3–5 interview-style questions that probe the tradeoff/decision layer, each with a one-line model answer — this is the question bank thevivacommand drills from. - If this track keeps a concept library, create or link the relevant
concepts/<category>/<concept-slug>.mdentr(y/ies) (new ones from_template/concept-reference.mdif the concept hasn't been documented yet; just link if it has), and point the day'sNotes.md## Referencesection at them (relative path from the nested<phase-slug>/day-NN-topic-slug/folder, e.g.../../concepts/<category>/<concept-slug>.md). - Flip that day's row to 🔓 (active) in
PROGRESS.md. Then stop and wait. - If
<Track>/.dojo-github.jsonexists, run the issue enrichment on pickup step from the GitHub Project tracking subsection above for this day's issue before stopping. - If
<Track>/.dojo-notion.jsonexists and this step created a brand-new concept-library entry (or, for tracks without one, a substantive newNotes.md), run the Notion mirror's "wired into the daily loop" step above for that entry before stopping.
hint / /dojo hint
A targeted nudge for the active day (resolved per the rule above) — point at the trap or the concept. Never the full solution, never write the stub body (or the practice deliverable) for them.
solution / /dojo solution
Programming tracks only, only when explicitly asked. Add a Solution.<ext> reference
implementation next to the task, with commentary explaining the traps and why the naive answer
fails. Do not modify the user's Task file. (Non-programming tracks have no "solution" — offer
a model answer/exemplar deliverable instead if asked.)
expand notes / /dojo expand notes
Flesh out the active day's (resolved per the rule above) Notes.md from what the user wrote, deepening it along the
Expert-lens philosophy pipeline — sharpen the connected concepts, tighten the expert's-call
heuristic, add or correct complexity in the brute-force-vs-optimal table, strengthen the
real-world scenarios. Build on their notes; don't overwrite their voice. If linked to a
concept-library entry, update that entry to match rather than duplicating the deepening here.
If <Track>/.dojo-notion.json exists, sync the change to Notion per the Notion mirror's
"wired into the daily loop" step above (update in place if already mirrored, create if not).
viva / /dojo viva
A verbal interview drill on the active day's (resolved per the rule above) concept — this is what actually builds the
"explain it out loud, not just code it" muscle. Pull 3–5 questions from that day's
## Interviewer would ask bank in Notes.md (generate on the fly if the bank is thin). At
least one question per session should probe the expert's-call layer — "when would you
reach for X over Y, and why" — not pure recall, per the Expert-lens philosophy.
Run it one question at a time, interviewer-style:
- Ask a single question. Wait for the user's answer in their own words.
- Grade the explanation against the model answer — call out what's right and what's missing or wrong. Allow one nudge (a hint, not the answer) if the first attempt is off-track, then re-ask once.
- Give the crisp canonical answer to lock in, then move to the next question.
- If an answer is shallow, ask a quick follow-up (mirrors the HARD difficulty policy) — this isn't a pass/fail quiz, it's a drill.
Pass criterion: ≥ 80% of questions answered correctly at their core (each after at most one nudge). Track a running pass/fail tally and report it at the end (e.g. "4/5 — passed").
viva recall variant: instead of the active day, pull 1–2 questions from the bank of
already-✅ earlier days (spaced recall) so concepts don't decay. Same one-at-a-time flow.
done / /dojo done
Viva-gated. A day cannot be marked ✅ on code (or rubric) completion alone. Resolve which day per the "Resolving the active day within a track" rule above (several days in the current phase may be 🔓 at once):
- Confirm the underlying work is actually done — passing harness for programming tracks,
or an honest rubric self-score of all-pass on
Practice.mdfor non-programming tracks. - If a
vivafor that day hasn't been passed yet, run it now (see above) before proceeding. - If the viva passes, mark the day's row ✅ in
PROGRESS.md, confirm, and wait for the next "next lesson". Do not auto-advance. If<Track>/.dojo-github.jsonexists, run the GitHub sync procedure for this track now so the day's issue closes immediately. - If the viva fails (< 80%), do not mark ✅ — leave the row at 🔓, tell the user
plainly which concepts to shore up (from the missed questions), and suggest revisiting
Notes.mdor asking for ahintbefore retryingvivaordone. - If this ✅ completes the current phase (every row in that phase/week section is now ✅),
tell the user the phase is fully cleared and
next lessonwill now unlock the next phase. - If this ✅ was the track's last remaining row (every row in
PROGRESS.mdis now ✅), congratulate the user and offer thecertificatecommand — don't run it unprompted.
certificate / /dojo certificate
Track-completion only — not a per-day artifact. Refuses (with a note of what's left) unless
every row in the resolved track's PROGRESS.md is ✅.
- Confirm full completion as above; ask which track if ambiguous (Step 1 resolution applies).
- Copy
.claude/skills/dojo/certificate-template.htmlto<Track>/CERTIFICATE.htmland fill every{{TOKEN}}(see the template's own header comment for the full list and rules) from real track data: track name, the real target fromREADME.md, start/finish dates (fromPROGRESS.md/git history if available, otherwise ask), the core skills and topics actually covered (pull the day-by-day topic list fromPROGRESS.md— duplicate the.skill-chiplist item once per topic), and the user's name (ask if not already known). Write an honest, specific self-issued acknowledgement sentence — never generic filler, and never reword "Self-Certified Completion" or add a seal/crest to mimic a real institution's, university's, or certification body's branding. This is a personal milestone marker, not a credential. Delete every instructional HTML comment from the copy before publishing. - Publish it with the
Artifacttool so the user gets a shareable, screenshot-friendly link. - Draft a ready-to-post LinkedIn/social caption directly in chat (not in the artifact): 3–6 first-person sentences naming what was built/learned, the self-paced format, and one genuine specific highlight from the track (not generic hype), plus 3–5 relevant hashtags. Offer it as copy-paste text — never post or publish it anywhere on the user's behalf.
- Stop and wait. Don't modify
PROGRESS.mdor advance any track.
setup / /dojo setup [track]
Wires up integrations for a track — GitHub Project tracking, a Notion mirror, or both, in one pass. Never split into separate per-integration commands:
- Resolve the track per Step 1 if not given explicitly.
- If it isn't already clear which integration(s) the user wants, ask once, combined — GitHub, Notion, both, or (rarely, if invoked by mistake) neither. Don't ask about them one at a time.
- For each integration chosen, run its own setup procedure (GitHub setup procedure / Notion setup procedure, both under Track integrations above) — skip an integration entirely (no questions, no config file) if it wasn't chosen.
- Report what was wired up in one combined summary.
sync / /dojo sync [track]
Reconciles all of a track's configured integrations against PROGRESS.md/Notion in one
pass — creates/closes GitHub issues, backfills Notion pages, corrects drift:
- Resolve the track per Step 1 if not given explicitly.
- If
<Track>/.dojo-github.jsonexists, run the GitHub sync procedure above. - If
<Track>/.dojo-notion.jsonexists, run the Notion sync procedure above. - If neither config file exists, tell the user no integrations are set up for this track and
offer
setup— don't silently do nothing without saying so. - Report one combined summary across whichever integrations ran.
Also runs automatically and per-integration at the end of next lesson (GitHub enrichment,
Notion mirroring) and done (GitHub closing) when a track has that integration set up — this
manual form is for an out-of-band resync (e.g. after hand-editing PROGRESS.md or
CONCEPTS.md).
⚠️ Harness contract — do NOT break
Applies to programming tracks. (Non-programming tracks use the rubric contract in Step 0.4 instead — same spirit, no code to run.) Every task file is a single self-contained file that runs with no build tool and no dependencies. These invariants are non-negotiable when authoring or porting any task:
- The user implements stubs only;
main()andcheck()are marked "do not edit". - An unimplemented stub throws (
UnsupportedOperationExceptionin Java, equivalent raise/throw elsewhere) so the harness fails loudly out of the box. check(name, expected, actual)throws on mismatch (e.g. Java:AssertionError; it does not use theassertkeyword, so tests run without the-eaflag). Some languages (e.g. Python) useassert-based checks instead — preserve "throws, not silent" behavior for whichever idiom the track uses.- A fully correct solution prints
ALL TESTS PASSED ✅ (passed/total). - Single file, no external deps, runs via the track's run command in its own
README.md.
Difficulty policy
Every task is HARD by design — target edge cases, common traps, and gotchas that punish the naive answer. Never a warm-up. If the user is breezing through, escalate.
Expert-lens philosophy — how a top-1% learner approaches every concept
This is the pedagogical spine of the dojo, not just a Notes.md section. It applies to every stage of the loop — drafting notes, framing a task's problem statement, and asking viva questions — because that's the difference between "knows the syntax" and "reasons like an expert under pressure." A top performer never learns a concept in isolation; they place it in a web, weigh it against alternatives, and can justify the call. Walk this pipeline for every concept you teach:
- Concept — name it precisely, no fluff.
- Connected concepts — what it's built on, commonly confused with, or composes with — and how, not just a bare list.
- Internal implementation — what actually happens under the hood (runtime/engine
behavior, memory layout, the call graph, or — for non-programming tracks — the actual
mechanism behind the skill) when this concept plays out. This is the key behind the
philosophy: tradeoffs and expert judgment are consequences of the internals, not facts to
memorize in parallel — a learner who knows why a
HashMapis O(1) (bucket + hash + collision chain) reasons differently than one who just memorized "O(1) lookup." - Tradeoffs — the concept's own pros and cons, on its own terms, traced back to the internal implementation above wherever possible.
- The expert's call — when a top performer reaches for this over the alternatives, and when they'd reach for the alternative instead. A decision heuristic, not "it depends."
- Brute force vs optimal — the naive/obvious approach vs the advanced/data-structure-or- algorithm-backed approach (or, for non-algorithmic topics, the naive/manual approach vs the battle-tested pattern), with tradeoffs for both, and when each is actually the right call (brute force is often correct — small N, hot-path clarity beats cleverness, one-off script vs library code).
- Real-world scenarios — 2-3 concrete, scenario-based walkthroughs (a production incident, a code review, a system-design tradeoff, a real-world application of the skill) that make the concept's tradeoffs tangible instead of abstract.
Adapt, don't force. When a topic has no real algorithmic dimension (a language construct
like try-with-resources, not an algorithm), map step 6 loosely — naive/manual handling vs
the language-level construct — rather than inventing Big-O that doesn't apply. The pipeline
still runs; the mapping just loosens.
Diagram where it earns its place. Add a Mermaid diagram (flowchart, sequence, class, or
state diagram in a ```mermaid fence) wherever a picture would resolve the
internal-implementation or connected-concepts step faster than prose. This is not limited to
control flow — reach for a diagram whenever the concept is fundamentally spatial or
relational, e.g.:
- Memory models — stack frames vs heap objects and the references between them.
- Data structure internals — linked list node/pointer chains, tree/graph shapes, hash table buckets and collision chains: draw the nodes and the pointers between them, don't just describe them in prose.
- Call graphs / request flows / state machines — sequence diagrams for call order, state diagrams for lifecycle transitions.
Not every day needs one; force nothing decorative. Skip it for concepts that are genuinely linear or trivial to describe in a sentence — but default to including one whenever the internal-implementation step involves memory layout, pointers/references, or a data structure shape, since that's exactly where prose alone leaves a gap a picture closes instantly.
Where this shows up:
Notes.md(next lesson,expand notes,create's template) — the template is this pipeline (see_template/Notes.md); don't collapse it back into a flat concept list.- Task/Practice problem statements (
next lessonstep 3) — frame the problem as a real-world scenario an expert would actually face, not a bare spec. - Viva questions (
viva,viva recall) — questions must probe the tradeoff/decision layer ("when would you reach for X over Y, and why") in addition to recall.
This keeps the dojo fast-paced, not slower: one well-connected explanation beats five disconnected facts, because it's the thing that actually survives a follow-up question.
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

