One paste, any computer

Do my full first-time Claude Code setup. Everything below is one setup script for you — work through it in order, asking me to approve as you go.

FIRST, before doing anything, ask me ONE question and wait for the answer:
"Are you (A) new to this — not a programmer, want the simple safe setup — or (B) a developer who wants the full power-user setup?"
A → do PATH A, then SHARED. B → do PATH B, then SHARED.

IMPORTANT — skip anything that's already done. Before each step, check whether it's already in place. If an alias line is already in my shell file, don't add it again. If a tool or plugin is already installed, skip it. If ~/.claude/CLAUDE.md, ~/.claude/settings.json, or any rules file already exists, DON'T overwrite it — show me what's there and ask me before changing it. Only add what's missing, and tell me at the end what you skipped because it was already done.

STEP 0 — WHICH COMPUTER?
- Run: uname -a
- "Darwin" = MAC. "Linux" / "Microsoft" / "WSL" = WINDOWS PC (inside Ubuntu).
- Tell me which one you detected, then carry on.

==================== PATH A — BEGINNER ====================

A1. FULL-ACCESS SHORTCUTS
- MAC: add to the end of ~/.zshrc if not already there, then run: source ~/.zshrc
- WINDOWS: first run cmd.exe /C "echo %USERNAME%" (my Windows username; ignore any trailing carriage return), then add to ~/.bashrc and source it. On Windows, files points at "/mnt/c/Users/<that username>" instead of ~.
alias files='cd ~'
alias go='claude --add-dir /'
alias GoDanger='claude --add-dir / --dangerously-skip-permissions'
("go" = full access to my whole computer, still asks before changes. "GoDanger" = full access with NO prompts — only for throwaway work, never files you care about.)

A2. TOOLS
- MAC: if Homebrew isn't installed, install it with its official script, then: brew install git pandoc poppler node. I have admin rights — enter my password if asked.
- WINDOWS: install nvm from its official GitHub script (home folder, no admin needed), then the latest LTS Node.js. Then try: sudo apt update && sudo apt install -y git pandoc poppler-utils unzip — if sudo is blocked (some locked-down PCs block it), skip that line and carry on.

A3. SETTINGS — create ~/.claude/settings.json with EXACTLY this content (on WINDOWS: remove "Bash(brew*)" from allow, remove "Bash(sudo*)" from ask, and add "Bash(sudo*)" at the START of deny):
{
"defaultMode": "acceptEdits",
"autoMemoryEnabled": true,
"permissions": {
"allow": [
"Read(**)", "Edit(**)", "Write(**)",
"WebSearch", "WebFetch(domain:*)",
"Bash(ls*)","Bash(cat*)","Bash(cd*)","Bash(pwd)","Bash(echo*)","Bash(grep*)",
"Bash(find*)","Bash(head*)","Bash(tail*)","Bash(wc*)","Bash(mkdir*)","Bash(cp*)",
"Bash(mv*)","Bash(touch*)","Bash(unzip*)","Bash(zip*)","Bash(git*)",
"Bash(pandoc*)","Bash(pdftotext*)","Bash(python3*)","Bash(pip*)","Bash(pip3*)",
"Bash(brew*)","Bash(nvm*)","Bash(node*)","Bash(npm*)","Bash(npx*)"
],
"ask": ["Bash(curl*)","Bash(wget*)","Bash(sudo*)","Bash(git push*)"],
"deny": [
"Bash(rm -rf*)","Bash(rm -r *)","Bash(rm -f *)",
"Bash(dd*)","Bash(mkfs*)","Bash(shutdown*)","Bash(reboot*)",
"Bash(chmod -R*)","Bash(chown -R*)",
"Read(.env)","Read(**/.env)","Read(**/secrets/**)","Read(**/*.key)",
"Read(**/id_rsa*)","Read(**/.ssh/**)"
]
}
}

A4. Create ~/.claude/CLAUDE.md with EXACTLY this content:
# How we work
## Tone & quality
- Always write in a warm, genuinely human voice. Never robotic, generic, or templated.
- Treat the first draft as a starting point — expect me to ask for changes.
## Safety & trust
- Draft, don't send. I review everything before it goes out.
- Never paste passwords, API keys, or secrets. Never send private or sensitive data to an outside website.
- If a task touches sensitive personal data, pause and ask me first.
- Double-check names, numbers, and anything that will be seen by others against the source.
## How I like to work
- One task at a time. Explore and plan before big changes.
- Keep sessions short and focused. When our conversation gets long (about 400k tokens), tell me to save my work and /clear for a fresh, sharper session.
- Keep each task's files together in its own folder.
- Be specific, and show me what you did so I can check it.
## About me
- I'm not a programmer. Explain things in plain English, no jargon. When I ask for an app or tool, install it for me the no-sudo way and tell me what you did.

==================== PATH B — DEVELOPER ====================

B1. TOOLS — MAC: brew install jq gh ripgrep imagemagick (install Homebrew first if missing). WINDOWS/LINUX: sudo apt install -y jq gh ripgrep imagemagick if sudo works, otherwise tell me what's missing and carry on. If gh isn't authenticated (gh auth status fails), remind me to run gh auth login at the end.

B2. Ask me for my GitHub username, then create ~/.claude/rules/git-private.md with this content (substituting my username for <your-github-username>):
# Git repositories must always be private (global, all projects)
A hard, always-on default for every project and every session.
## The rule
Anything on git/GitHub for this user must be **private**. Never create or push to a public repository or a public Gist. If a repo is public, make it private.
## How to apply
- **Creating:** gh repo create --private — never --public. Default to private even when visibility is unspecified.
- **Auditing:** gh repo list <your-github-username> --limit 300 --json nameWithOwner,visibility. Any that report PUBLIC → gh repo edit <owner/repo> --visibility private (add --accept-visibility-change-consequences if prompted).
- **Verify after push:** gh repo view <owner/repo> --json visibility.
- **Gists:** gh gist create (secret by default) — never --public.
## One documented exception class — confirm, don't auto-convert
A <user>.github.io (or any repo backing an active GitHub Pages site) usually must stay public to keep the published site online on the free plan — privatizing it takes the live website down. Do NOT silently convert these: flag the tradeoff and let the user decide.
## Confirmed public exceptions (do not re-flag)
- (none yet)
## Note
This governs visibility. The separate global rule still holds: only commit/push when the user asks.

B3. Create ~/.claude/rules/coding-principles.md with EXACTLY this content:
# Coding principles (global)
Behavioral guidelines to reduce common LLM coding mistakes. Adapted from Andrej Karpathy's observations on LLM coding pitfalls (https://x.com/karpathy/status/2015883857489522876), via github.com/multica-ai/andrej-karpathy-skills.
**Tradeoff:** these bias toward caution over speed. For trivial tasks, use judgment. Project-specific instructions and the user's direct requests always override.
## 1. Think Before Coding
**Don't assume. Don't hide confusion. Surface tradeoffs.**
- State assumptions explicitly. If uncertain, ask.
- If multiple interpretations exist, present them — don't pick silently.
- If a simpler approach exists, say so. Push back when warranted.
- If something is unclear, stop. Name what's confusing. Ask.
## 2. Simplicity First
**Minimum code that solves the problem. Nothing speculative.**
- No features beyond what was asked.
- No abstractions for single-use code.
- No "flexibility"/"configurability" that wasn't requested.
- No error handling for impossible scenarios.
- If you write 200 lines and it could be 50, rewrite it.
Ask: "Would a senior engineer say this is overcomplicated?" If yes, simplify.
## 3. Surgical Changes
**Touch only what you must. Clean up only your own mess.**
- Don't "improve" adjacent code, comments, or formatting.
- Don't refactor things that aren't broken.
- Match existing style, even if you'd do it differently.
- If you notice unrelated dead code, mention it — don't delete it.
- Remove imports/variables/functions that YOUR changes made unused; leave pre-existing dead code unless asked.
The test: every changed line should trace directly to the request.
## 4. Goal-Driven Execution
**Define success criteria. Loop until verified.**
- "Add validation" → "Write tests for invalid inputs, then make them pass"
- "Fix the bug" → "Write a test that reproduces it, then make it pass"
- "Refactor X" → "Ensure tests pass before and after"
For multi-step tasks, state a brief plan with a verify check per step. Strong success criteria let me loop independently; weak ones ("make it work") require constant clarification.

B4. Create ~/.claude/rules/session-handoff.md with EXACTLY this content:
# Long-session handoff protocol
Long Claude Code sessions degrade in quality (attention spreads thinner, response length creeps up, instructions get partially-applied) AND cost more per turn (full context re-sent on every request).
## Session-end push offer
At the end of ANY session that produced committed work: always **offer** to push completed/tested/merged commits. The push-only-when-asked rule stays — but finished, green-tested work stranded locally purely because the offer was never made costs a recovery session. Offering costs one line.
## The rule
When the session reaches approximately **75% of context capacity**, proactively interrupt the current work to:
1. **Commit memory** — write/update any project memory entries that capture decisions, ships, watch items, or behavior preferences from this session
2. **Write a handoff document** in the project repo (e.g., HANDOFF-YYYY-MM-DD.md) covering: what shipped, current state, open items, watch list, what to do next session
3. **Recommend /clear to start a fresh session** — and start the new session by reading memory + the new handoff
## What the handoff should contain
- TL;DR of what shipped this session
- Production health snapshot
- Open items (ranked by priority)
- Inherited items still open from prior handoffs
- Tomorrow's most-likely first move
- Memory artifacts created/updated
## Why this is worth interrupting for
A clean handoff + fresh session almost always nets out positive: 30 min spent banking progress beats 2 hours of degraded back-and-forth. If unsure whether we've hit the threshold, ask directly: "we're getting long — should we commit memory + handoff + restart?"

B5. Create ~/.claude/rules/context7.md with EXACTLY this content:
When working with libraries, frameworks, or APIs — use Context7 MCP to fetch current documentation instead of relying on training data. This includes setup questions, code generation, API references, and anything involving specific packages.
## Steps
1. Call resolve-library-id with the library name and the user's question
2. Pick the best match — prefer exact names and version-specific IDs when a version is mentioned
3. Call query-docs with the selected library ID and the user's question
4. Answer using the fetched docs — include code examples and cite the version

B6. Create ~/.claude/CLAUDE.md with EXACTLY this content:
# User-level CLAUDE.md
Global guidance for all projects.
## Defer to my personal rules
Always-on rules live in ~/.claude/rules/ and take precedence over anything below: coding-principles.md (think-first, simplicity, surgical changes), session-handoff.md (long-session restart protocol), context7.md (fetch live docs), git-private.md (all repos private by default). Do not duplicate or override them — follow them.
## Standing expectations
- Plan before executing anything non-trivial; state assumptions; surface tradeoffs.
- Always give a graded recommendation (strongly recommend / recommend / lean / slight lean) when presenting options — don't leave me with a neutral survey. Put the recommended option first; if it's a genuine toss-up, say so.
- Tests before claiming done — never assert "fixed/passing" without running the check.
- Never commit secrets; redact logs and tokens before sharing output.
- Conventional commits (feat:/fix:/refactor:/docs:/test:); commit/push only when asked.
## Build me my own tooling
Claude Code is customizable — and I want you to actively use that on my behalf:
- When you notice repeated friction in how we work (a command I approve every time, a status I keep asking for, a step I always do manually), **offer to build me a personal tool for it**: a status-line addition, a hook in settings.json, a custom skill in ~/.claude/skills/, a slash command, or a small script in ~/.claude/.
- The installed statusline.sh (model · dir · branch · live context bar · cost) is the worked example of this — extend it or build siblings like it when useful.
- Keep these tools personal and local: they run on my machine, read my session data only, and send nothing anywhere.

B7. Create ~/.claude/statusline.sh with EXACTLY the content between STATUSLINE-START and STATUSLINE-END (not including those marker lines), then run: chmod +x ~/.claude/statusline.sh
STATUSLINE-START
#!/bin/bash
# Claude Code status line — model, dir, git branch, live context usage, cost.
#
# Field reference: https://code.claude.com/docs/en/statusline
# Claude Code pipes session JSON to stdin every time an assistant message
# arrives, so `context_window` is the live figure from the most recent API
# response, not an estimate.
#
# Renders e.g.:  Opus · Zen · main │ 108.5k/1M  11% [█░░░░░░░░░] │ $2.34 · 5h 23%
input=$(cat)

if ! command -v jq >/dev/null 2>&1; then
  echo "statusline: jq not installed (brew install jq)"
  exit 0
fi

# used_percentage and current_usage are null before the first API call and
# again after /compact, so every field takes a fallback.
IFS=$'\t' read -r MODEL DIR PCT IN_TOK OUT_TOK WIN COST FIVEH < <(
  printf '%s' "$input" | jq -r '
    [ (.model.display_name // "?"),
      (.workspace.current_dir // .cwd // "?"),
      ((.context_window.used_percentage // 0) | floor),
      (.context_window.total_input_tokens // 0),
      (.context_window.total_output_tokens // 0),
      (.context_window.context_window_size // 200000),
      (.cost.total_cost_usd // 0),
      ((.rate_limits.five_hour.used_percentage // -1) | floor)
    ] | @tsv'
)

TOK=$((IN_TOK + OUT_TOK))

# 108500 -> "108.5k", 1000000 -> "1M". Whole thousands lose the ".0".
human() {
  local n=$1
  if   [ "$n" -ge 1000000 ]; then awk -v n="$n" 'BEGIN{v=n/1000000; printf (v==int(v) ? "%dM" : "%.1fM"), v}'
  elif [ "$n" -ge 1000 ];    then awk -v n="$n" 'BEGIN{v=n/1000;    printf (v==int(v) ? "%dk" : "%.1fk"), v}'
  else printf '%d' "$n"
  fi
}

RED=$'\033[31m'; AMBER=$'\033[33m'; GREEN=$'\033[32m'
DIM=$'\033[2m'; BOLD=$'\033[1m'; RST=$'\033[0m'

# Green while there is room, amber past halfway, red when compaction is close.
if   [ "$PCT" -ge 80 ]; then COL=$RED
elif [ "$PCT" -ge 50 ]; then COL=$AMBER
else                        COL=$GREEN
fi

FILLED=$((PCT / 10)); [ "$FILLED" -gt 10 ] && FILLED=10
BAR=""
for ((i = 0; i < 10; i++)); do
  if [ "$i" -lt "$FILLED" ]; then BAR+="█"; else BAR+="░"; fi
done

BRANCH=$(git -C "$DIR" branch --show-current 2>/dev/null)
[ -n "$BRANCH" ] && BRANCH=" ${DIM}·${RST} ${BRANCH}"

# Below 50% this is just Claude Code's own "/clear saves N" cost nudge, which a
# custom status line otherwise hides. At 50% it escalates into a handoff alert —
# the point where answer quality starts slipping and every turn re-sends the
# whole conversation.
HINT=""
if   [ "$PCT" -ge 75 ]; then HINT=" ${DIM}·${RST} ${BOLD}${RED}⚠ WRAP UP: notes + handoff, then /clear (saves $(human "$TOK"))${RST}"
elif [ "$PCT" -ge 50 ]; then HINT=" ${DIM}·${RST} ${BOLD}${AMBER}⚠ HANDOFF ZONE — /clear saves $(human "$TOK")${RST}"
elif [ "$PCT" -ge 30 ]; then HINT=" ${DIM}· /clear saves $(human "$TOK")${RST}"
fi

RATE=""
[ "$FIVEH" -ge 0 ] && RATE=" ${DIM}· 5h ${FIVEH}%${RST}"

printf '%s %s·%s %s%s %s│%s %s%s/%s %s%%%s %s[%s]%s %s│%s %s$%.2f%s%s%s\n' \
  "$MODEL" "$DIM" "$RST" "${DIR##*/}" "$BRANCH" \
  "$DIM" "$RST" \
  "$COL" "$(human "$TOK")" "$(human "$WIN")" "$PCT" "$RST" \
  "$COL" "$BAR" "$RST" \
  "$DIM" "$RST" \
  "$DIM" "$COST" "$RST" "$RATE" "$HINT"
STATUSLINE-END

B8. SETTINGS — if ~/.claude/settings.json doesn't exist, create it with the JSON below. If it DOES exist, show me a diff and merge these keys in with my approval. Allowlist: the safe everyday dev commands (file ops, grep/rg/find, git, gh api/auth/run/repo, node/npm/npx/pnpm/yarn, python/pip, tsx/tsc, jest/vitest, eslint/prettier, docker, brew, osascript, curl/wget, tar/zip, ssh/scp, kill/ps/lsof) plus Edit/MultiEdit/Read(*)/WebSearch and WebFetch for docs.anthropic.com, docs.claude.com, github.com, raw.githubusercontent.com, www.npmjs.com. Deny: "Bash(rm -rf /*)" and "Bash(rm -rf ~*)". Also set:
"statusLine": { "type": "command", "command": "~/.claude/statusline.sh", "padding": 1 },
"theme": "dark"

B9. EXTRA PLUGINS (developer only — on top of the SHARED list below): code-review, code-simplifier, feature-dev, vercel, swift-lsp — each as claude plugin install <name>@claude-plugins-official, skipping any already installed.

B10. MCP SERVERS — ask me which of these I use, then run claude mcp add --scope user --transport http <name> <url> for each chosen: figma https://mcp.figma.com/mcp · canva https://mcp.canva.com/mcp · buffer https://mcp.buffer.com/mcp · gmail https://gmailmcp.googleapis.com/mcp/v1 · livekit-docs https://docs.livekit.io/mcp. Remind me to authenticate them later with /mcp.

==================== SHARED — BOTH PATHS ====================

S1. PLUGINS — add the marketplace (I'll approve if it asks me to trust it): claude plugin marketplace add anthropics/claude-plugins-official
Then install these one by one, skipping any already installed:
claude plugin install superpowers@claude-plugins-official
claude plugin install context7@claude-plugins-official
claude plugin install frontend-design@claude-plugins-official
claude plugin install claude-md-management@claude-plugins-official
claude plugin install skill-creator@claude-plugins-official
claude plugin install playwright@claude-plugins-official
claude plugin install github@claude-plugins-official
Then show me the list to confirm: claude plugin list

S2. Don't mention any of this until everything above is done. Then, in order:
a) Tell me it worked, with a short summary of what you set up (and which computer + path).
b) Tell me what I still need to do myself: authenticate any MCP servers with /mcp; get my own API keys later only if I use those services (never anyone else's keys); and for developers, gh auth login if not done.
c) Remind me to fully quit and reopen Claude so the settings and plugins load. Path A: tell me to type "go" to start you with full access and "files" to jump to my files. Path B: tell me the status line will now show model, folder, branch, a live context bar, and session cost — and that I should ask you to build me more personal tools whenever something feels repetitive.