Skills
- Writes quotes
- Chases leads
- Drafts emails
- Files reports
- Cleans up data
Four steps to turn Claude into an assistant that knows your business, runs your tools, and remembers what you tell it. Work down this page in order. Everything you need is on it.
A paid Claude plan and the desktop app. The free plan will not run the assistant, and the website on its own cannot install anything on your computer.
Claude Pro is the entry point. Claude Max gives you far more headroom, and is what we recommend if the assistant is going to do real work for you every day.
Your kit is stored privately on GitHub. You need a free account, then you tell us its username using the form below, and we add you to the kit. Most people will not have a GitHub account yet, and that is normal.
Pick a username and write it down. You need it in a moment. Verify your email when GitHub asks, because access cannot be granted to an unverified account.
This form is what gives you access. Nothing on GitHub itself grants it. Type the username you just picked, press the button, and your account is added to the kit straight away.
GitHub emails you an invitation the moment that form succeeds. Open it and click Accept invitation. If it has not arrived, check spam, or use the button below while signed in to GitHub.
Do not skip this. An invitation you have not accepted looks exactly like no access at all, and Step 3 will fail. Invitations also expire after seven days, in which case come back here and submit the form again.
One short prompt, so the big one in Step 3 runs straight through instead of stopping to sort out sign-in. Paste this into Claude Code first.
Wait for it to say you are connected before moving to Step 3. It finishes by checking you can actually reach the kit, so if that passes, the next prompt will not get stuck on sign-in.
Copy everything in the box, open the Claude desktop app, go to the Code tab, paste it in and press Enter. Any folder is fine. This one prompt does the rest: it installs what is missing, downloads your kit, wires it into Claude and checks its own work.
It is the same prompt whether this is your first time or an update months from now, so you never have to work out which one you need. Keep this page.
Around twenty to thirty minutes, most of it downloads. Two moments need you, and both catch people out, so here they are in advance.
Expected. It opens a browser, gives you a short code to paste, and carries on by itself.
On Mac, press Command + Q. On Windows, click the small up-arrow near the clock, right-click the Claude icon and choose Quit. Closing the window is not enough, the app keeps running. Reopen Claude, come back to the same chat, and type done.
When it reports that setup is complete, start a new Code session in any folder and type hi. It reads its instructions at startup, so a fresh session is what brings it to life. It will introduce itself and take you from there.
Four things separate this from a chat window.
I am setting up (or updating) my Claude Code AI Business Assistant with StrongIQ.
Do these steps one at a time, telling me what you are doing in plain English.
Detect whether I am on Mac or Windows and use the right commands throughout.
This works from any folder — do not ask me to move anywhere or create a
workspace folder.
Talk to me like I am not technical. Plain English, one step at a time.
**Downloads are the slow part.** For EVERY download below (Node, git, the kit,
anything fetched from the internet): tell me first that it can take several
minutes on slow wifi and may look frozen without being frozen (you cannot talk
to me while a command runs, so say it BEFORE you start); prefer command forms
that print progress; give every slow command a generous timeout so a dead
download fails loudly instead of hanging; confirm afterwards that it worked or
tell me plainly what failed.
### Step 0 — Preflight
Run these checks up front so the common problems surface in the first minute:
1. **Internet sanity** — a preflight check that cannot hang. Hit both places
this setup downloads from, each with a hard timeout:
- Mac/Linux:
```
curl -m 10 -sI https://github.com/ && curl -m 10 -sI https://registry.npmjs.org/
```
- Windows PowerShell:
```
Invoke-WebRequest -Uri "https://github.com" -Method Head -TimeoutSec 10; Invoke-WebRequest -Uri "https://registry.npmjs.org" -Method Head -TimeoutSec 10
```
If either errors or crawls, tell me plainly: the wifi is struggling, downloads
will be slow, and a phone hotspot is my backup. Then carry on.
2. **Node** — run `node --version`. If it prints a version, skip ahead. If not,
install it now (this is part of setup, not homework I missed):
- **Mac/Linux** — via nvm (home-folder install, never needs admin):
```
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
export NVM_DIR="$HOME/.nvm" && [ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"
nvm install --lts && nvm use --lts
```
- **Windows** — via winget, then refresh PATH in THIS session (both halves in
ONE PowerShell invocation — a fresh shell loses the refreshed PATH):
```
winget install --id OpenJS.NodeJS.LTS -e --source winget
```
```
$env:Path = [System.Environment]::GetEnvironmentVariable('Path','Machine') + ';' + [System.Environment]::GetEnvironmentVariable('Path','User'); node --version
```
That PATH refresh changes this process only — nothing permanent. Prepend the
same `$env:Path = ...;` refresh to every later PowerShell command in this
setup. Only if `node --version` still fails after the refresh: have me fully
quit and reopen Claude Desktop, then confirm when I am back.
- If neither package manager works, open https://nodejs.org in the browser
and download the LTS installer for me. Never make me click through a
download myself.
3. **Git** — run `git --version`. If it prints a version, skip ahead. If not:
- **Mac** — run `xcode-select --install` (an Apple dialog appears; I click
Install) or, if that is unavailable, `brew install git` when Homebrew
exists. Wait for the install to finish before continuing.
- **Windows** — `winget install --id Git.Git -e --source winget`, then the
same one-invocation PATH refresh as the Node step, ending in `git --version`.
### Step 1 — Read my current state (before anything changes)
Nothing on my machine changes during this step. Read only.
**1.1 Pick the mode.** Look for `~/.claude/selr-kit-manifest.json`. Tell me which
mode you picked in one line, in plain words ("this is a fresh setup" / "I'm
updating your existing assistant" / "I'm moving your assistant to the new
setup"):
- Manifest exists → **UPDATE**. Keep its full contents in hand — the skill sync
in Step 5 needs its skill fingerprints, and `onboarded` carries over.
- No manifest, but an older install is detected → **MIGRATE** (move me onto the
current setup, keep everything I have learned and customised, no
re-onboarding). Detect this if EITHER is true:
- a `CLAUDE.md` exists at any of these two paths — the **older-setup folders**
(the kit's own docs call these the legacy-workspace candidate list):
`~/Desktop/my-assistant` and `~/my-assistant`; or
- StrongIQ kit skills are already sitting in `~/.claude/skills/`.
Do not check the contents of anything here — presence is enough. Do not go
hunting anywhere else for a folder I may have renamed or moved.
- Neither → **FRESH** (first-ever install).
**1.2 MIGRATE only — snapshot the old kit before it is overwritten.** An older
install has no manifest, so there is no record of which skills I edited myself.
Rebuild that record now, from the old kit still on my disk. Do it in THIS step:
Step 2 overwrites the old kit folder, so after Step 2 the evidence is gone.
Look for the old kit in both places it may have been installed
(check every one — either of them may be the real one):
- `~/workshop-kit/skills/`
- `~/claude-workshop-kit/skills/`
Then, for every skill folder already in `~/.claude/skills/`:
- If its `SKILL.md` is byte-identical to the same-named skill's `SKILL.md` in
ANY of the old kit folders you found, I never touched it → record its content
hash in an in-memory list. Call this list the **rebuilt fingerprints**; Step 5
uses it exactly as UPDATE uses a real manifest.
- Otherwise — different content, or the skill is in no old kit folder at all —
record NO fingerprint for it. Step 5 then treats it as customised and keeps my
version.
If none of the three old kit folders survived, nothing can match, so every kit
skill counts as customised and every one is kept. That is deliberate: keeping a
file I might have edited is safe, and Step 5's report tells me how to take the
kit's version of any of them whenever I want.
Never ask me which skills I customised. I cannot know, and this step works it
out.
Keep the rebuilt fingerprints in this session only — do not write them to disk.
If this session dies before Step 5, the next run finds the old kit already
replaced, matches nothing, and keeps every skill. That is the safe outcome, and
the report tells me how to take the kit's version of anything I want refreshed.
### Step 2 — Get the kit
Tell me only "Downloading your kit now — this can take a few minutes and may
look frozen without being frozen." Which door the download comes through is
plumbing I never need to know about.
First, silently probe the kit repository — a cheap check that fails fast
instead of hanging on a password prompt:
- Mac/Linux: `GIT_TERMINAL_PROMPT=0 git ls-remote https://github.com/strongiq/claude-workshop-kit.git HEAD`
- Windows PowerShell: `$env:GIT_TERMINAL_PROMPT = "0"; git ls-remote https://github.com/strongiq/claude-workshop-kit.git HEAD`
Give it a generous timeout. Three outcomes, three doors:
**A. The probe succeeds → clone from GitHub. Kit home: `~/claude-workshop-kit`.**
We ALWAYS take a fresh copy — never update-in-place — so what is on disk
exactly matches the kit as published:
1. If `~/claude-workshop-kit` already exists, check it really is a kit download
before removing it: it must contain BOTH `skills/` and
`my-assistant/CLAUDE.md`. If it does, delete it — a kit download folder is a
pure download area, nothing of mine lives in it, and my customisations live
in `~/.claude/`, which this never touches. If it does NOT look like a kit,
stop and tell me: "There's already a folder at `~/claude-workshop-kit` that
doesn't look like the kit, so I haven't touched it." Never delete a folder
on its name alone.
2. Clone, still with prompting disabled:
- Mac/Linux:
```
GIT_TERMINAL_PROMPT=0 git clone --depth 1 https://github.com/strongiq/claude-workshop-kit.git ~/claude-workshop-kit
```
- Windows PowerShell:
```
$env:GIT_TERMINAL_PROMPT = "0"; git clone --depth 1 https://github.com/strongiq/claude-workshop-kit.git "$HOME\claude-workshop-kit"
```
**B. The probe is refused (authentication error / repository not found) → I do
not have access to the kit yet. Kit home once access is sorted:
`~/claude-workshop-kit`.** This is an access problem, not a wifi problem. Do NOT
retry the clone in a loop, and do NOT ask me for a GitHub password — GitHub has
not accepted passwords for git since 2021, so a password prompt is always a
dead end. Instead:
1. Tell me plainly: "The StrongIQ kit is a private repository, so GitHub needs
to know who you are before it will hand it over."
2. Ask me whether I have a GitHub account and whether StrongIQ has already
invited me to the repository. If I am unsure, have me check my email for a
GitHub invitation (subject like "StrongIQ has invited you to collaborate on
StrongIQ/claude-workshop-kit") and accept it — an unaccepted invite expires
after 7 days and looks exactly like no access at all.
3. Once I have accepted the invite, sign me in to GitHub from the command line
so git stops being refused. Install the GitHub CLI if it is missing, then
authenticate — this opens a browser and gives me a short code to paste:
- Mac: `brew install gh`
- Windows: `winget install --id GitHub.cli -e --source winget`
- Both: `gh auth login` — choose GitHub.com, HTTPS, and "Login with a web browser"
- Then wire git to it: `gh auth setup-git`
4. Re-run the probe from the top of Step 2. If it now succeeds, carry on through
Door A as normal.
5. If it is still refused after I have accepted an invite and signed in, the
access has not actually been granted on StrongIQ's side. That is not
something you and I can fix from here — tell me to contact StrongIQ at
tim@strongiq.au and stop. Show me the real, unedited error when you do.
**C. The probe times out or fails like a network problem → it is the wifi, not
access.** Never send me down the access branch from here, and never ask me for
any token. Have me check I am online (hotspot as backup), then probe again — no
limit on retries.
Whichever door it came through, verify before anything else:
`<kit home>/my-assistant/CLAUDE.md` and `<kit home>/skills/` must both exist.
If only some of them arrived, that is a partial download — say so plainly rather
than treating a missing path as success. Show me the real, unedited output and
loop on the fix with me until both exist. STOP here if they never do:
Do not run any of steps 3 onwards against a kit that is not on disk — a failed
download must stop the setup, not cascade through it. **From here on, "the kit
home" means the absolute path this step decided — every later step uses it.**
### Step 3 — Point Claude at the kit (the pointer block)
The assistant lives in my global Claude config, so it works from ANY folder —
there is no workspace folder anymore.
1. **Copy the persona out of the kit** so deleting the kit folder never breaks
the assistant: copy `<kit home>/my-assistant/CLAUDE.md` to
`~/.claude/selr-assistant.md`, overwriting any previous copy.
2. **Write the managed block** into `~/.claude/CLAUDE.md` (create the file if it
does not exist; if a previous StrongIQ block is already there between the same
markers, replace the block in place; never touch anything outside the
markers):
```
<!-- selr-kit:begin -->
## StrongIQ Business Assistant
Kit home: <ABSOLUTE PATH TO THE KIT HOME>
Install details: ~/.claude/selr-kit-manifest.json
@<ABSOLUTE PATH TO ~/.claude/selr-assistant.md>
<!-- selr-kit:end -->
```
Write REAL absolute paths, not `~` — resolve my home folder and substitute it
(the `@` import line especially must be an absolute path so it loads on
Windows too). Nothing model-facing goes inside the HTML-comment markers —
Claude strips comments; the markers only fence the block for updates and
uninstall.
3. **In MIGRATE mode, also retire the old wiring.** Check BOTH older-setup
folders from Step 1.1 — `~/Desktop/my-assistant` and `~/my-assistant`. Both
can be retired in the same run.
For each one that exists, first check it really is the kit's: open its
`CLAUDE.md` and confirm the **first line is exactly**
`# Your AI Business Assistant`.
- It matches → rename that `CLAUDE.md` to `CLAUDE.md.pre-migration` (kept as
a backup, no longer read), and delete that same folder's
`.first-run-pending` if it has one. Everything else in the folder is mine
and stays untouched.
- It does NOT match → leave the whole folder completely alone and TELL me:
"There's a folder at `<path>` that isn't the assistant's, so I've left it
exactly as it is." Never rename or delete anything on a folder that fails
this check, and never skip it silently.
4. **In MIGRATE mode, clear out the old kit download folder.** Only
`~/workshop-kit`, and only when it is definitely the old kit and not a folder
of mine that happens to share the name: it must contain a `skills/` folder AND at least one
of the old kit's own files (`my-assistant/CLAUDE.md` or
`skills/SKILLS-LIST.md`). If it qualifies, delete it and tell me in one line.
If it does not, leave it alone and say so.
Leave the other two old locations exactly where they are, whether or not this
run happened to touch them. `~/workshop-kit` is the only one to remove: it
belongs to a distribution that no longer exists, while the other two are the
current kit homes for the two live doors, so deleting either could delete the
kit this run just installed.
### Step 4 — Write the manifest (the install's receipt)
Write `~/.claude/selr-kit-manifest.json` fresh on every run (Step 5 fills in
its `skills` map as it syncs):
```json
{
"kitHome": "<the absolute kit home from Step 2>",
"installPath": "github",
"kitVersion": "<run `git -C <kit home> rev-parse HEAD` and paste what it
prints. If the command fails because kit home has no .git
(it was not cloned), omit this field entirely — never guess
a commit, and never copy one from earlier in the chat>",
"installedAt": "<ISO timestamp>",
"installMode": "fresh | update | migrate",
"onboarded": <false on FRESH; true on MIGRATE; carry the old value on UPDATE>,
"skills": {}
}
```
Step 5 fills `skills` with one entry per kit skill, in exactly this shape — other
parts of the kit (orientation, uninstall) read these keys by name, so do not
rename them:
```json
"skills": {
"<skill-name>": { "hash": "<SKILL.md content hash>", "customised": true }
}
```
`customised` is present only on a skill whose version I edited and you kept.
`onboarded` is the assistant's only first-run signal: `false` makes the next
session run orientation; orientation flips it to `true` when done. The old
`.first-run-pending` marker file is dead — never create it.
### Step 5 — Sync the skills (respecting my customisations)
Skills install to `~/.claude/skills/` (create it if missing), one folder per
skill, copied from `<kit home>/skills/` (folders only — skip `SKILLS-LIST.md`
and any loose files).
- **FRESH:** copy every skill folder in. No questions.
- **UPDATE and MIGRATE:** identical from here on. UPDATE uses the old manifest's
fingerprints (read in Step 1.1); MIGRATE uses the rebuilt fingerprints from
Step 1.2. Either way, for each kit skill:
- my installed copy matches its fingerprint (I never touched it) → overwrite
silently with the new version. "Overwrite" means replace the kit's own files
in place — never empty the folder first, because anything in there the kit
did not ship is mine (notes, a script) and the fingerprint only covers
`SKILL.md`;
- it does not match, or it has no fingerprint at all → I have customised it →
KEEP my version, skip the overwrite, and add it to a report list;
- the skill is new in the kit and not on my disk → simply copy it in.
Anything in `~/.claude/skills/` that is not a kit skill is mine — never touch
it, and never list it in the manifest.
Never ask me a blanket "refresh everything or keep everything?" question in any
mode. The fingerprints answer it skill by skill.
A skill you decided to keep stays kept for the rest of the run. If a copy is
slow, hangs, or has to be retried, never widen the retry to cover it and never
copy over it "just to be sure" — that is my work, and re-running the sync must
leave it exactly where it is.
As you sync, record every kit skill into the new manifest's `skills` map: the
fingerprint (content hash of the skill's `SKILL.md` as installed), and for a
kept-customised skill record the KIT version's hash marked
`"customised": true` (so a later "update X anyway" knows what the kit shipped,
and the next update can heal anything I later let go).
At the end of this step, if any customised skills were kept, show the report:
> "Kept your customised versions of: X, Y. Say 'update X anyway' any time to
> take the kit's version."
### Step 6 — Plugins and tools (safe to re-run; all BEFORE the one restart)
1. **Claude CLI** — `claude --version`; if missing, `npm install -g @anthropic-ai/claude-code`
and re-verify (Mac fallback: `export PATH="$(npm prefix -g)/bin:$PATH"`).
2. **Routine packager plugin** — register the marketplace and install, using the
kit home from Step 2:
```
claude plugin marketplace remove selrai-workshop-kit
claude plugin marketplace add <kit home>
claude plugin install routine-installer-plugin@selrai-workshop-kit
```
`selrai-workshop-kit` is the marketplace's real registered name — it is the
`name` field inside the kit's own `.claude-plugin/marketplace.json`, not
something to rebrand. Change it and the install fails.
Remove first (ignore the error if there was nothing registered): a machine
whose kit home moved would otherwise keep pointing at the old folder and
quietly serve stale content.
"Already added / already installed" is success, but an already-installed
plugin does NOT pick up new content by itself — in UPDATE and MIGRATE mode
follow with:
```
claude plugin marketplace update selrai-workshop-kit
claude plugin update routine-installer-plugin
```
3. **Browser automation (Playwright — the assistant's primary browser tool,
non-negotiable).** Re-adding an existing entry errors, so remove first —
ignore the error if there is nothing to remove — then add with the
persistent login profile:
- Mac/Linux:
```
claude mcp remove --scope user playwright || true
claude mcp add playwright --scope user -- npx -y @playwright/mcp@latest --user-data-dir "$HOME/.cache/playwright-mcp-profile"
```
- Windows PowerShell — same two commands, but PowerShell has no `|| true`, so
let the remove fail quietly on its own:
```
claude mcp remove --scope user playwright 2>$null
claude mcp add playwright --scope user -- npx -y @playwright/mcp@latest --user-data-dir "$HOME\.cache\playwright-mcp-profile"
```
Verify `playwright` appears in `claude mcp list`. If not, fallback:
`npm install -g @playwright/mcp` then re-run the add. If it still will not
register, stop and tell me honestly — every connector in this kit needs it.
4. **Power-user skills** — same command on Mac and Windows, safe to re-run
(it overwrites cleanly):
```
npx -y skills@latest add mattpocock/skills -g -a claude-code -s grill-me -s handoff -s diagnosing-bugs -s teach -y --copy
```
Then check the disk: `~/.claude/skills/{grill-me,handoff,diagnosing-bugs,teach}/SKILL.md`
must all exist. If any are missing, list what the repo offers now
(`npx -y skills@latest add mattpocock/skills -l`), match the missing skill by
name/description (repos rename things), re-run with the resolved names, and
re-check. One healing pass, then report per-skill status.
### Step 7 — The one restart
Everything is installed; now Claude Desktop needs one full restart to load the
browser tool. Say to me exactly:
> "Nearly there — one restart and we're done.
>
> 1. Right-click the Claude Desktop icon in your dock (Mac) or system tray
> (Windows) and choose **Quit** — Cmd+Q on Mac also works. Just closing the
> window is NOT enough.
> 2. Reopen Claude Desktop.
> 3. Come back to THIS same chat and type **done**.
>
> When you say done, I'll test the browser and finish up."
Then stop and wait. Do not narrate anything else in the meantime.
### Step 8 — Browser smoke test (after I come back)
When I am back: warn me first that the very first page load downloads the
browser itself (a few hundred MB) — it can take a few minutes on slow wifi and
may look frozen without being frozen; after this first time it opens in a
second. Then, in this exact order:
1. `mcp__playwright__browser_navigate` to `https://example.com` — a tiny page.
A small browser window opens visibly on my screen.
2. `mcp__playwright__browser_snapshot` — it must contain "Example Domain". If
it does not, Playwright is installed but not loading pages; stop and
diagnose with me.
3. `mcp__playwright__browser_close` — I see the window close.
If the `mcp__playwright__*` tools are not visible at all, I did not fully quit
— closing the window is not quitting. Repeat the quit instructions from Step 7
and wait again. Do not continue until this smoke test passes.
### Step 9 — Verify gate
Do not declare success until every line passes. Check and show me a tick list:
- `~/.claude/CLAUDE.md` contains exactly one `<!-- selr-kit:begin -->` block
- `~/.claude/selr-assistant.md` exists and is non-empty
- `~/.claude/selr-kit-manifest.json` exists, parses, and its `skills` map is
populated
- `~/.claude/skills/` contains the kit skills (spot-check 3 named folders) and
the 4 power-user skills
- `claude mcp list` shows `playwright`, and the smoke test passed
- `claude plugin list` runs CLEAN and shows `routine-installer-plugin`.
Clean means no manifest or schema errors printed for ANY plugin, not
just that the one name appears. A malformed `.claude-plugin/plugin.json`
anywhere in the kit surfaces here and nowhere else — if the command
prints an error alongside a good result, that is a FAIL, not a pass.
Show me the command's real output, not a summary of it.
Anything failing: fix it with me now, re-check, and only then continue. No limit
on attempts; never paper over a failed line.
### Step 10 — Done
In MIGRATE mode, first tell me this (two lines, once, never again):
> "Your assistant has moved: it now works in EVERY Claude Code session, from any
> folder — you no longer need the my-assistant folder to talk to it."
Then print exactly this block (diagram in a fenced code block, banner below,
nothing after it):
Here's what your assistant can now do for you:
```
┌───────────────────────┐
│ CLAUDE CODE │
│ your AI assistant │
└───────────┬───────────┘
│
┌────────────────────┬───────────┴───────────┬────────────────────┐
▼ ▼ ▼ ▼
┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│ SKILLS │ │ CONNECTORS │ │ BROWSER │ │ MEMORY │
│ │ │ │ │ │ │ │
│ Saves hours on: │ │ Plugs into: │ │ On the web: │ │ Learns you: │
│ │ │ │ │ │ │ │
│ • Writes quotes │ │ • Your email │ │ • Connects apps │ │ • Your style │
│ • Chases leads │ │ • Your calendar │ │ • Creates ads │ │ • Your clients │
│ • Drafts emails │ │ • Slack/Teams │ │ • Pulls quotes │ │ • Your projects │
│ • Files reports │ │ • Your CRM │ │ • Fills forms │ │ • Your team │
│ • Cleans data │ │ • Cloud files │ │ • Tests apps │ │ • No repeating │
└─────────────────┘ └─────────────────┘ └─────────────────┘ └─────────────────┘
```
## ✅ Setup complete
### Do this next
1. **Start a new Code session** — any folder is fine
2. **Type "hi"** and press Enter
Your assistant will introduce itself and take it from there.
---
*Why a new session? Your assistant's instructions were installed during this
session — a fresh session reads them at startup.*
---
## Before workshop day
If you are coming to a workshop, having **Node.js** installed before you arrive saves everyone ten minutes of venue wifi. Grab the LTS installer from [nodejs.org](https://nodejs.org) and run it. If you do not get to it, the prompt installs Node for you - it is just slower on the day.
## If something goes wrong
Ask your assistant directly, in the same session: *"Something broke. Here's the error: [paste the error]. Help me fix it."* The prompt is written to diagnose and retry with you rather than give up. If that does not sort it, see [troubleshoot.md](../troubleshoot.md).
## What comes after
Start a new session and say hi - your assistant runs a short orientation the first time, then you are into [use/](../use/README.md).
---
*Built by StrongIQ - strongiq.au*
Connect my GitHub account to this computer so Claude can download my StrongIQ kit.
Do this one step at a time, in plain English, and tell me what you are doing.
Detect whether I am on Mac or Windows and use the right commands throughout.
Do not download the kit in this prompt - a later one does that.
1. Check whether the GitHub CLI is installed: `gh --version`.
If it prints a version, move on. If not, install it:
- Mac: `brew install gh`. If Homebrew is missing, install Homebrew first.
- Windows: `winget install --id GitHub.cli -e --source winget`, then refresh
PATH inside the SAME PowerShell call, because a fresh shell loses it:
`$env:Path = [System.Environment]::GetEnvironmentVariable('Path','Machine') + ';' + [System.Environment]::GetEnvironmentVariable('Path','User'); gh --version`
2. Sign me in: run `gh auth login`. Choose GitHub.com, then HTTPS, then
"Login with a web browser". It prints a short one-time code. Read the code
out to me, open the browser, and wait for me to say I have finished before
you carry on. Do not ask me for a password - GitHub has not accepted
passwords for git since 2021.
3. Wire git to that login so downloads stop being refused:
`gh auth setup-git`
4. Prove it worked. Run:
`gh api repos/StrongIQ/claude-workshop-kit --jq .full_name`
- It prints `StrongIQ/claude-workshop-kit` - say to me: "You're connected and
you have access to the kit. Go back to the page and copy the big setup
prompt." Then stop.
- It says `Not Found` - I have access granted but have not accepted it yet,
or the form has not been submitted. Tell me to check my email for the
GitHub invitation, or open
https://github.com/StrongIQ/claude-workshop-kit/invitations
while signed in to GitHub, accept it, then run step 4 again.
- Anything else - show me the real, unedited output, tell me plainly what
failed, and work through it with me. Never skip ahead on a failure.
Stop as soon as step 4 passes.