setup-workshop

You're setting up a learning-with-court workshop for the user.

Background

learning-with-court hosts technical workshops as deployed MCP servers. The @learning-with-court/cli (npm) is the universal entry point — it does auth, clone, refresh, registry, and proxies MCP for in-workshop sessions. This skill is a thin wrapper that drives the CLI's setup subcommand.

By convention, workshops install to <parent>/<workshop-id>/. The default parent is ~/learning-with-court/, but if the user is in a sensible working directory (e.g. they ran mkdir ~/learning-with-court && cd ~/learning-with-court first), use that as the parent instead. The CLI tracks installs in ~/.lwc/workshops.json regardless of where they live.

Critical constraint: Claude Code's CWD is fixed

Claude Code's working directory is set at process start and can't change mid-session. So this skill ends at "the project is cloned and the user has a clear cd && claude to run." That handoff is unavoidable.

Available workshops

• mcp-workshop — MCP Workshop: Build a Real MCP Server. 13 lessons across 3 phases (A: stdio basics; B: auth + HTTP; C: AWS deploy). Repo: private, gated by Clerk sign-in.

When more workshops land, this list grows.

Steps

1. Confirm which workshop

If the user named one, use it. Today only mcp-workshop exists, so for generic phrasing default to it without asking. Briefly tell them which one you're setting up.

2. Gating prereqs

Run silently; surface only failures:

• node --version — must be v20+. If older, recommend nvm.

• git --version — must be installed.

• command -v lwc — must succeed. The lwc binary (the @learning-with-court/cli npm package, installed globally) is the entry point for all workshop operations. If it's missing, do NOT try to fall back to npx -y — that path is blocked by Claude Code's auto-mode classifier and produces a worse experience for everyone. Surface this exact message and stop:

  It looks like lwc is not installed. The learning-with-court CLI needs to be installed once before the plugin can set up workshops. Run this in your terminal, then come back and try again:

  macOS / Linux / WSL:

  curl -fsSL https://workshop.institute/install.sh | bash
  

  Windows (PowerShell):

  irm https://workshop.institute/install.ps1 | iex
  

That's it. No gh CLI, no GitHub account, no API keys. First-run sign-in happens via browser when the CLI runs (or during the install script if the user opted into the auth step).

2b. Pace signals (informational, no blocking)

Probe the user's environment to infer a default workshop pace. The result becomes the pace: field in .claude/lwc-workshop.local.md, read by the workshop's SessionStart hook to set tone for every lesson.

Run each probe as its OWN Bash call, not as one combined command. Claude Code's auto-mode classifier blocks multi-tool environment- introspection batches (it reads them as broad system reads). One probe per Bash call evaluates each on its own merits and passes cleanly. Prefer compact single-purpose commands; surface only failures.

Probes (each its own Bash call):

Signal	Bash	True if
gh	gh auth status	exit 0 (only run if gh exists)
pnpm	pnpm --version	exit 0
node20+	already known from step 2	per step 2
aws_profile	aws configure list-profiles	stdout has ≥1 line
shell_dotfiles	test -s ~/.zshrc || test -s ~/.bashrc	exit 0
gitconfig	git config --global user.name	stdout non-empty

Inference (count of true of 6):

• 0–2 → slow — explain everything before doing it; pause at every step
• 3–4 → balanced — explain new concepts, move through familiar material
• 5–6 → quick — minimal hand-holding; you drive

If any individual probe is blocked or errors, mark its signal as unknown and continue. Default to balanced if ≥3 signals are unknown.

2c. Show the inferred pace + offer override

Before persisting, show the user what you inferred and let them override. Render in a single > quote block:

Based on your environment, I'd suggest <inferred-pace> pacing (<short rationale, e.g. "you have most of the dev tools we look for"). Three options:

• slow — explain concepts before mechanics, pause for "got it" between steps
• balanced — explain new concepts, move through familiar material
• quick — minimal hand-holding; focus on the interesting bits

Default <inferred-pace>. Want a different pace, or stick with the default?

Wait for the user's response. Accept any of:

• <empty> / yes / ok / sure → use the default
• slow / balanced / quick → use that
• Anything else conversational → ask once more for one of the three

Persist whatever was chosen, even if it differs from the inference.

3. Decide where to install, then run setup

Resolve the install destination:

1. Get the user's CWD (pwd on POSIX; $PWD works in PowerShell too). Resolve ~ to the actual home directory.
2. If CWD looks like a sensible workshops folder — not $HOME itself, not /, not ~/Desktop, not ~/Downloads, and is writable — use <CWD>/<workshop-id>/ as the destination.
3. Otherwise fall back to ~/learning-with-court/<workshop-id>/.

Tell the user exactly where it's going in one line, e.g.:

"Setting up mcp-workshop at <resolved-dest>. First run opens a browser for a one-time sign-in."

Then run (always pass --dir so the destination is explicit and the CLI output matches what you told the user):

lwc setup <workshop-id> --dir <resolved-dest>

Use the bare lwc binary, never npx -y @learning-with-court/cli@latest. The npx path is blocked by Claude Code's auto-mode classifier; the bare binary path is what step 2's prereq check guarantees is on PATH.

The CLI auto-creates parent directories. If the user has expressed a different preference (e.g., they explicitly said ~/Projects/...), honor that in --dir.

If the CLI errors:

• "already exists and is not empty": offer to run lwc remove <id> first or pick a different --dir.
• Sign-in timeout / failed: ask them to retry; the browser may have closed early.
• "PROVISION_FAILED": the platform couldn't mint a token. Surface the message verbatim.

4. Persist pace + signals

After the CLI finishes, use the destination you resolved in step 3 (it's also printed verbatim in the CLI's Done. Open the workshop: line, and recorded in ~/.lwc/workshops.json). Then write <install-path>/.claude/lwc-workshop.local.md with:

---
pace: balanced
inferred_at: 2026-05-09T04:21:26Z
signals:
  gh: true
  pnpm: true
  node20+: true
  aws_profile: false
  shell_dotfiles: true
  gitconfig: false
---

# learning-with-court workshop — local config

Written by setup-workshop based on a probe of your environment. Edit
`pace:` to override (`slow`, `balanced`, or `quick`). Restart the
workshop session for the change to take effect.

Use the user's chosen pace from step 2c (which may be the inferred default or an override). Get the timestamp from date -u +%Y-%m-%dT%H:%M:%SZ.

5. Hand off

Auto-detect OS via uname -s:

• Darwin / Linux / MINGW/MSYS/CYGWIN → bash/zsh form (&&)
• otherwise → PowerShell (;)

Print (substitute <install-path> with the actual resolved destination — the same one the CLI printed and that's stored in ~/.lwc/workshops.json):

✅ mcp-workshop installed at <install-path>. Pace set to <pace> — the workshop will adapt accordingly. To change later, edit <install-path>/.claude/lwc-workshop.local.md and set pace: to slow, balanced, or quick; restart the workshop session for it to take effect.

To start the workshop, open a new terminal and run:

macOS / Linux / WSL (bash/zsh):

cd <install-path> && claude

Windows (PowerShell):

cd <install-path-with-backslashes>; claude

You can exit this session first with /exit or Cmd-Q.

When the new session opens, type hello to begin. The workshop will greet you and start the first lesson.

6. Handy follow-ups (don't run unprompted)

If the user asks "what else can I do?":

• lwc list — show installed workshops
• lwc update [<id>] — pull updates
• lwc remove <id> [--delete-files] — uninstall
• lwc auth status — confirm signed in

7. Stop. Don't try to start the workshop.

After step 5, you're done. The workshop runs from inside the cloned dir. If the user pushes, briefly explain why a fresh session is needed.

Tone

Friendly, direct, brief. The goal is "set up in 30 seconds and out of your hair." If anything goes wrong, be specific about what to do next.

Cross-platform notes

• The CLI (@learning-with-court/cli) is fully cross-platform — pure Node, no shell quirks.
• Only the cd && claude handoff differs per OS; the CLI itself doesn't care.

Backward-compat note

Older clones (pre-v0.4.0) have a level: field instead of pace: in .claude/lwc-workshop.local.md. The workshop's SessionStart hook reads pace: first and falls back to level: if pace: is missing, translating beginner→slow, intermediate→balanced, expert→quick. Existing clones keep working until the user re-runs setup or hand-edits the file. New clones written by this version always use pace:.