Onboarding

One paste. ~20 minutes mostly silent. ≤3 clicks at the end. A fresh Mac, Windows, or Linux laptop becomes a fully provisioned databayt environment — every tool installed, every repo cloned, every Claude surface working.

This is the single source of truth for joining databayt. It covers every OS, every Claude surface, every dotfile, every external account.

Ran this on a real machine? Hit Report an issue in the footer of any kun.databayt.org page and describe what you saw — what worked, what broke, what to change. It files a GitHub issue (no account-juggling, works mid-install from the browser). See Issue pipeline.

The one-liner

Paste in a terminal. The wizard takes over.

macOS / Linux

Copycurl -fsSL https://kun.databayt.org/install | bash

Windows (PowerShell or cmd.exe)

Copypowershell -ExecutionPolicy Bypass -Command "iwr https://kun.databayt.org/install.ps1 | iex"

The bootstrap URL auto-detects your OS and dispatches to the right installer. No need to pick. Re-run anytime — it auto-resumes from where it left off via a state file.

What You Get

Running the bootstrap line leaves your machine in this state. The deliverables, how to verify each one, how to change what's delivered, and what the baseline is for your profile.

Deliverables

Verify what you got

Provisioning lands in seven layers. Run these to confirm each — all green means fully provisioned for your profile:

bash ~/.claude/scripts/health.sh is the authoritative config gate but only audits ~/.claude/ — pair it with the other rows for a complete check.

Modify what's delivered

Want a different result? Edit the source, then re-run the bootstrap (idempotent):

All installer scripts live in ~/kun/.claude/scripts/. Print any backend's flags with no args (e.g. bash ~/kun/.claude/scripts/onboarding-mac.sh).

Every machine is a full autonomous worker

Config is universal — the machine, not the person, is the unit of capability. Every machine gets all agents, all skills, the full MCP fleet, all hooks, and the entire org's repos. Any machine can run any task. Your role is just a label + a secrets-trust tier — it does not limit what your computer can do.

What still varies (and why):

• Secrets — scoped, not by config but by which Gist you're handed. A machine only holds the keys it's trusted with; an MCP server without its key simply doesn't connect (harmless). Full config everywhere, contained blast radius.
• Linux: Claude Desktop doesn't exist on Linux — surfaces are the CLI, claude.ai/code in the browser, and the IDE plugins. A Linux box with those is complete; don't expect the Chat/Cowork/Code tabs.
• No Pro/Max: Desktop tabs are unavailable — Claude Code can still bill through an ANTHROPIC_API_KEY, or upgrade to Pro/Max for the Desktop surfaces.

Three paths

Pick the one that fits.

The wizard — three acts

The wizard runs in three acts. Most is silent; you click only when a human is unavoidably needed.

Act 1 — Pre-flight (~30 seconds, 4 dialogs)

The wizard asks four things. Everything else is auto-detected, derived after auth, or skipped silently.

All answers persist in a state file. Re-runs skip questions already answered.

What's no longer asked (and why):

Act 2 — Silent batch (~15-20 minutes, progress notifications)

Eight phases run in the background. You can minimize the terminal and do other work — the wizard fires native OS notifications as each phase advances.

Each phase emits PROGRESS:N/8:label to stderr; wrappers parse this and fire osascript display notification (Mac), zenity --notification (Linux), or NotifyIcon balloon (Windows).

Act 3 — Manual finishing (~3 clicks)

What's left needs a human at the keyboard. Auto-polling OAuth means the only manual clicks are:

The wizard uses deep links so each action button drops you exactly where you need to act:

Before you sit down — admin checklist

What the inviter needs to grant or hand over before paste-time:

• GitHub — invite to the databayt org (Phase 3 hard-gates on membership; without it the install can't clone private repos)
• Anthropic account — Pro/Max sub for the full Desktop + CLI experience
• Anthropic API key — only if not on Pro/Max (Claude Code can bill via API key)
• Anthropic mobile app — installed on the teammate's phone, signed in with the same account (native PushNotification dispatch from Claude Code)
• Secrets Gist ID — handed over out-of-band (Signal, Notes, 1Password). Powers ~/.claude/.env (MCP keys + cross-cutting tokens).
• Vercel — team invite to databayt (every role, not just engineer) — needed for vercel env pull to populate per-product .env files
• Neon — project access for any product whose DATABASE_URL_* you'll touch (engineer)
• Slack — invite to hogwarts-wve9301
• AWS IAM — hogwarts-s3-uploader keys (engineer role only)

If something's missing the wizard skips that step and lists it under "things to do later" at the end.

Which repos you get

Every machine clones the full databayt org to your chosen directory (~/, ~/databayt/, or custom) — any machine can touch any repo:

kun (engine config), hogwarts (multi-tenant LMS), codebase (patterns, agents, blocks), shadcn (UI library), radix (UI primitives), souq (e-commerce), mkan (rentals), shifa (medical), swift-app (iOS/Swift), distributed-computer (infra), marketing (landing pages).

When you pick a custom directory, the wizard symlinks ~/kun, ~/hogwarts, etc. back to it so all existing tooling that hard-codes ~/kun keeps working.

To clone only the essentials (kun, hogwarts, codebase): pass --essentials-only (Mac/Linux) or -EssentialsOnly (Windows).

The seven Claude surfaces

After install you have seven Claude surfaces, each with a sweet spot:

Cowork and Claude Code share ~/.claude/ — same brain, two modes. Handoff happens via ~/.claude/bridge.md and GitHub Issues. See Cowork ↔ Code bridge.

Claude Desktop's three tabs share the same MCP fleet as the CLI because the wizard symlinks claude_desktop_config.json to ~/.claude/mcp.json.

Mobile (iOS + Android)

After Claude Desktop is signed in, install the Claude mobile app and sign in with the same Anthropic account — your projects, conversations, and Cowork sessions are available everywhere.

Mobile is read-friendly for reviewing Cowork output on the go. For driving anything (typing prompts, kicking off agents), the desktop surfaces are still best.

WebStorm Settings Sync

To share team-standardized editor settings (code style, keymaps, inspection profiles, file templates):

1. Open WebStorm → top-right account icon → Sign in to your JetBrains Account
2. Sign in (your personal JetBrains account, or use the team account if you have one)
3. Settings → Backup and Sync → Enable Settings Sync → choose what to sync

Your settings then follow you to any machine where you sign in to the same JetBrains account. The team uses this for consistent code style across reviews — no need to re-configure per machine.

Recommended sync scope: Code style, Inspection profiles, Live templates, Plugins, Keymaps. Skip system settings (per-machine).

Remote control & async — native Anthropic surfaces

No Tailscale, no Apple Notes. The mobile app + claude.ai/code + computer-use give you the same primitives natively — no extra services to install, no tokens to manage, same Anthropic account you already signed in with.

Sign in to the mobile app with the same Anthropic account as Desktop/CLI — your projects, Cowork sessions, and ~/.claude/bridge.md handoffs follow you everywhere.

Script path (engineer)

If you'd rather skip the wizard and run the silent backend directly:

Copy# Mac
git clone https://github.com/databayt/kun.git ~/kun && \
  bash ~/kun/.claude/scripts/onboarding-mac.sh engineer <GIST_ID>
 
# Linux
git clone https://github.com/databayt/kun.git ~/kun && \
  bash ~/kun/.claude/scripts/onboarding-linux.sh engineer <GIST_ID>
 
# Windows (PowerShell)
git clone https://github.com/databayt/kun.git $env:USERPROFILE\kun
& $env:USERPROFILE\kun\.claude\scripts\onboarding-windows.ps1 -Role engineer -GistId <GIST_ID>

Useful backend flags (Mac + Linux):

PowerShell equivalents: -Quiet, -GitName, -GitEmail, -ReposDir, -EssentialsOnly, -HogwartsDev.

Re-run anytime; idempotent.

Path B — Script-driven (engineer-friendly)

For learning what the wizard does, or if both other paths fail. Pick your OS.

macOS

Copy# Side-tools
brew install git node pnpm gh
brew install --cask google-chrome webstorm visual-studio-code claude
 
# Claude Code CLI
curl -fsSL https://claude.ai/install.sh | sh
 
# Shell helpers
cat >> ~/.zshrc <<'EOF'
# Claude Code
function c  { claude --dangerously-skip-permissions "$@"; }
function cc { claude "$@"; }
export PATH="$HOME/.local/bin:$PATH"
[ -f "$HOME/.claude/.env" ] && set -a && . "$HOME/.claude/.env" && set +a
EOF
. ~/.zshrc
 
# GitHub auth + SSH
ssh-keygen -t ed25519 -C "you@databayt"
gh auth login -p ssh -w
gh ssh-key add ~/.ssh/id_ed25519.pub --title "databayt-$(hostname -s)"
 
# Repos
git clone git@github.com:databayt/kun.git ~/kun
git clone git@github.com:databayt/hogwarts.git ~/hogwarts
git clone git@github.com:databayt/codebase.git ~/codebase
 
# Kun config + secrets
cd ~/kun && bash .claude/scripts/setup.sh engineer
bash ~/kun/.claude/scripts/secrets.sh <GIST_ID>
 
# Desktop MCP parity
ln -sf ~/.claude/mcp.json "$HOME/Library/Application Support/Claude/claude_desktop_config.json"
 
# Verify
claude doctor
bash ~/.claude/scripts/health.sh

Linux (Debian/Ubuntu shown — adapt for your distro)

Copy# Side-tools
sudo apt update && sudo apt install -y git curl build-essential ca-certificates
 
# Node 24 LTS via nvm
curl -fsSL https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.4/install.sh | bash
export NVM_DIR="$HOME/.nvm"; . "$NVM_DIR/nvm.sh"
nvm install --lts && nvm use --lts
npm install -g pnpm
 
# GitHub CLI (Debian/Ubuntu)
curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | sudo tee /etc/apt/sources.list.d/github-cli.list
sudo apt update && sudo apt install -y gh
 
# IDEs (snap)
sudo snap install code --classic
sudo snap install webstorm --classic
 
# Claude Code CLI (Claude Desktop NOT available on Linux)
curl -fsSL https://claude.ai/install.sh | sh
 
# Shell helpers
cat >> ~/.bashrc <<'EOF'
# Claude Code
function c  { claude --dangerously-skip-permissions "$@"; }
function cc { claude "$@"; }
export PATH="$HOME/.local/bin:$PATH"
[ -f "$HOME/.claude/.env" ] && set -a && . "$HOME/.claude/.env" && set +a
EOF
. ~/.bashrc
 
# GitHub auth + SSH
ssh-keygen -t ed25519 -C "you@databayt"
gh auth login -p ssh -w
gh ssh-key add ~/.ssh/id_ed25519.pub --title "databayt-$(hostname -s)"
 
# Repos
git clone git@github.com:databayt/kun.git ~/kun
git clone git@github.com:databayt/hogwarts.git ~/hogwarts
git clone git@github.com:databayt/codebase.git ~/codebase
 
# Kun config + secrets
cd ~/kun && bash .claude/scripts/setup.sh engineer
bash ~/kun/.claude/scripts/secrets.sh <GIST_ID>
 
# Verify (no Claude Desktop on Linux — CLI + browser + IDE plugins)
claude doctor
bash ~/.claude/scripts/health.sh

Windows (PowerShell)

Copy# Side-tools
winget install Git.Git OpenJS.NodeJS.LTS GitHub.cli Microsoft.PowerShell Google.Chrome
winget install JetBrains.WebStorm Microsoft.VisualStudioCode
npm install -g pnpm
 
# Claude Code CLI (official)
winget install Anthropic.ClaudeCode
claude    # browser sign-in
 
# Shell helpers — append to $PROFILE
@'
 
# Claude Code
function c  { claude --dangerously-skip-permissions $args }
function cc { claude $args }
if (Test-Path "$env:USERPROFILE\.claude\.env") {
    Get-Content "$env:USERPROFILE\.claude\.env" | ForEach-Object {
        if ($_ -and -not $_.StartsWith("#")) {
            $parts = $_ -split "=", 2
            if ($parts.Length -eq 2) {
                [Environment]::SetEnvironmentVariable($parts[0], $parts[1], "Process")
            }
        }
    }
}
$env:Path = "$env:USERPROFILE\.claude\bin;" + $env:Path
'@ | Add-Content $PROFILE
. $PROFILE
 
# GitHub auth + SSH
ssh-keygen -t ed25519 -C "you@databayt"
gh auth login -p ssh -w
gh ssh-key add "$env:USERPROFILE\.ssh\id_ed25519.pub" --title "databayt-$env:COMPUTERNAME"
 
# Repos
git clone git@github.com:databayt/kun.git $env:USERPROFILE\kun
git clone git@github.com:databayt/hogwarts.git $env:USERPROFILE\hogwarts
git clone git@github.com:databayt/codebase.git $env:USERPROFILE\codebase
 
# Kun config + secrets
cd $env:USERPROFILE\kun; & .\.claude\scripts\setup.ps1 -Role engineer
& $env:USERPROFILE\kun\.claude\scripts\secrets.ps1 -GistId <GIST_ID>
 
# Desktop MCP parity (needs admin or Developer Mode for the symlink; falls back to copy)
New-Item -ItemType SymbolicLink -Path "$env:APPDATA\Claude\claude_desktop_config.json" -Target "$env:USERPROFILE\.claude\mcp.json" -Force
 
# Verify
claude doctor
& $env:USERPROFILE\.claude\scripts\health.ps1

For hogwarts, your team contact shares the .env out-of-band — there is no .env.example.

Verify everything

Copy# Kun config (cross-platform, ~5 sec)
bash ~/.claude/scripts/health.sh         # Mac/Linux
& $env:USERPROFILE\.claude\scripts\health.ps1     # Windows
 
# Claude CLI
claude doctor
 
# Hogwarts (engineer)
cd ~/hogwarts && pnpm dev
# Open http://localhost:3000 — login: admin@kingfahad.edu / 1234

health.sh --report posts your config status to a shared GitHub issue (databayt/kun, label config-health) so the team can see drift across machines.

Daily entry points

Full keyword list: keywords.

Auto-resume

The wizard persists every choice to a state file so re-runs skip what's done:

To reset and start fresh: delete the state file, then re-run the bootstrap.

Troubleshooting

For anything else, file an issue at https://github.com/databayt/kun/issues.

Where to go next

This page is the front door. Once your machine is provisioned, branch out from here:

Set up & verify

• Claude Code — CLI install detail + config
• MCP — the server fleet + /mcp-doctor browser recovery
• Secrets — Gist-based provisioning (which keys your machine holds)
• Self-hosting — tmux / Docker (optional, server use)

Daily use

• Keywords — the full vocabulary, one word → a workflow
• Captain — decisions, delegation, the weekly rhythm
• Cowork ↔ Code — same brain, two modes

Understand the engine

• Configuration — universal-config blueprint
• Architecture — the 5 layers
• Agents — the 40-agent fleet
• Team — the 6 humans + roles

Contribute

• Issue pipeline — "Report an issue" (footer) → GitHub → optional auto-fix
• Repositories — full org map
• Contributing — issue → branch → PR → merge

External

• Apps — Claude in Slack/Figma/Asana · Connectors — MCP catalog · Anthropic Directory