# Claude power setup

Companion to the Claude Guide at [eqctrl.io/claude](https://eqctrl.io/claude) · 2026-06-11 · Free to fork.

The exact commands, paths, and load order behind the guide. The page reads plain on purpose; every claim it softens has its precise twin here. Raw markdown, curl it, fork it.

---

## Changelog

Current as of Jun 2026, Opus 4.8 era. Dated entries, newest first.

- **2026-06-11.** First standalone publication. Extracted from the guide page so the page can stay plain-English. This file is the precision layer: commands, paths, version strings, capability fine print.
- **Jun 2026 state.** Opus 4.8 is the current default model. Adaptive thinking replaced fixed thinking budgets; a preset budget cannot be set in 4.8. Sonnet 4.x is the current mid-tier. Effort levels exposed by the UI and API: `low / medium / high / xhigh / max`, default `high`.

Capability and connector claims below are dated Jun 2026. The product moves; when this file and reality disagree, reality wins and this file gets a new entry.

---

## Per-surface capability matrix

The precise twin of the reach figure on the page. Filled dot ● = can touch. Empty circle ○ = can't. † = with setup.

| | your files | the open internet | your apps | a browser | the clock |
|---|---|---|---|---|---|
| chat & apps | ○ (uploads only) | ● | ● | ○ | ○ |
| desktop app | ●† | ○ | ● | ●† | ○ |
| phone | ○ | ● | ●† | ○ | ○ |
| claude code | ● | ● | ○† | ○† | ●† |
| a rented server | ● (its own) | ● | ○† | ○ | ● |

### Fine print, per surface

**Chat & apps (claude.ai, web and app).** No file access beyond what you upload into the thread. Connectors give it your apps once enabled. No browser control, no schedule. This row also covers Claude behind a chat app (Discord bots, Slack apps, iMessage relays, custom webhooks, all built via the API): those bridges have no long-session context and no wiki or knowledge base by default. Use bridges for quick Q&A, reminders, push-notification workflows, team-channel assistants, always-reachable endpoints.

**Desktop app.** Sandboxed: no arbitrary network, no direct host-machine access. Code interpreter, MCP connectors, and file handling run inside the sandbox; local file access and browser control (Chrome MCP, computer-use) need setup. Use for research, analysis, content work, design, MCP-heavy and connector-driven workflows.

**Phone (iOS, Android).** Thin context, no filesystem, subset of connectors. Cross-session memory travels via your account. Don't ask it to reason about local files; hand structural work to a desk. Use for inbound triage, short drafts, connector queries on the go.

**Claude Code (the terminal).** Full shell access, unrestricted network, filesystem-aware. Hooks fire here. Runs on your laptop. No MCP connectors by default and no browser automation; both are setup, not defaults. Use for system ops, deploys, multi-file refactors, SSH and git workflows, agentic loops, subagent fan-out.

**A rented server (self-host).** Your own VPS or server running the API on a schedule: cron jobs, heartbeat scripts, scheduled briefs, webhooks. It sees its own files, not your laptop's. You pay for the box and the tokens. Use for cron-driven agents, production bots, heartbeat services, scheduled digests, long-running integrations.

---

## Context load order

What Claude wakes up knowing, per door, in load order.

### Code
1. reads `~/.claude/CLAUDE.md` (global)
2. reads `./CLAUDE.md` (project-scoped)
3. PreToolUse hooks fire on first tool call
4. ready

### Desktop
1. loads account Custom Instructions
2. Project context if inside a Project
3. connectors + skills available per account
4. ready

### Phone
1. NO filesystem
2. account Custom Instructions only
3. subset of connectors
4. ready (thin context)

### Self-host
1. reads project-local `CLAUDE.md` if present
2. no sync back to personal config
3. context pulled from repo on deploy

**Drift note.** Drift between global, account, and project-local context is the #1 silent failure mode. Keep one source of truth and treat the rest as views.

---

## The mode ladder, with commands

Seven rungs of autonomy. Pick the lowest rung that fits; the higher you climb, the more spec you front-load and the less you can steer mid-task.

| # | Rung | What you type | Where it works | When you can intervene |
|---|---|---|---|---|
| 1 | chat, back and forth | nothing special, just talk | all surfaces | every turn |
| 2 | a named routine | a skill or slash command: `/review`, `/plan`, `/analyze` | all surfaces | between invocations |
| 3 | several Claudes at once | ask for subagent fan-out: N workers in one turn for independent items, results return to the main thread | Code · Desktop | when results come back |
| 4 | one long task, spec up front | `Shift+Tab` (auto mode): long single task with full spec up front, Claude drives | Code · Max tier | at spec time, or interrupt mid-run |
| 5 | checks in on a timer | `/loop 5m /foo`: fixed cadence, polls or checks on a schedule | Code | between iterations |
| 6 | paces itself | `/loop` with no interval: Claude self-paces via `ScheduleWakeup` | Code · Desktop | when it wakes |
| 7 | runs on a schedule, nobody watching | cron triggers; remote agents fire on their own, no human in the loop | Self-host · scheduler MCP | only by changing the schedule or killing the job |

---

## Effort levels

The level names as the UI and API expose them: `low / medium / high / xhigh / max`.

- `high` is the default and covers most work.
- `xhigh` is for heavy coding and agentic runs.
- `max` tends toward diminishing returns and overthinking. Hard problems only.
- Toggle mid-task to manage spend.

Opus 4.8 uses adaptive thinking: there is no preset budget, and a fixed thinking budget is not supported in 4.8. Claude allocates reasoning where it's actually useful. What you control is the nudge. Copy-paste phrases:

Want more thinking:

> "Think carefully and step-by-step before responding; this problem is harder than it looks."

Want less thinking:

> "Prioritize responding quickly rather than thinking deeply. When in doubt, respond directly."

---

## Model picker and handoffs

Exact model picks, Jun 2026:

| Model | When |
|---|---|
| Opus 4.8 (default) | Everything coding, agentic, complex. `high` default, `xhigh` for heavy agentic work. |
| Sonnet 4.x | Cost-sensitive loops, high-volume batch, light coding. |
| Haiku | Cheapest path: triage, classification, routing. |

Common handoffs:

| From | To | Trigger |
|---|---|---|
| Desktop | Code | Need SSH / push / arbitrary network |
| Code | Desktop | Need MCP connector / browser / OS app |
| Mobile | Any desk | Anything structural or multi-file |
| Any | Self-host | Deploy: ship code, restart service, verify endpoint |
| Bridges | Code / Desktop | Long-form or deep work |

---

## Status line recipe

Claude Code supports a custom status line that renders on every turn. Encode what you want to know at a glance: which surface, which project, whether your context file loaded, which model. It's the simplest forcing function against silent context drift.

The example string:

```
[surface · cwd · project=<name> · context=loaded|missing · model]
```

The slots:

| Slot | Example values |
|---|---|
| surface | Code · Desktop · Mobile · Bridge |
| cwd | current working directory (or `NA` if the surface has no filesystem) |
| project | personal · client-1 · client-2 · work · unknown |
| context | `loaded` if your CLAUDE.md / knowledge base initialized, `missing` otherwise |
| model | which model is handling the session (useful when swapping between Opus / Sonnet / Haiku) |

To set it up, point `statusLine` at a script in `~/.claude/settings.json`:

```json
{
  "statusLine": {
    "type": "command",
    "command": "~/.claude/statusline.sh"
  }
}
```

Then write the script. Claude Code pipes session state as JSON on stdin; this minimal version fills every slot:

```bash
#!/bin/bash
# ~/.claude/statusline.sh  (chmod +x it)
input=$(cat)
cwd=$(echo "$input" | jq -r '.workspace.current_dir')
model=$(echo "$input" | jq -r '.model.display_name')

project="unknown"
case "$cwd" in
  */client-1/*) project="client-1" ;;
  */client-2/*) project="client-2" ;;
  */work/*)     project="work" ;;
  "$HOME"*)     project="personal" ;;
esac

context="missing"
if [ -f "$cwd/CLAUDE.md" ] || [ -f "$HOME/.claude/CLAUDE.md" ]; then
  context="loaded"
fi

echo "[Code · $cwd · project=$project · context=$context · $model]"
```

A status line is not required, but once you have one you stop re-deriving where you are every session, and so does Claude.

---

## Tiebreakers

When the decision path on the page leaves two doors open:

1. **Cross-surface work?** Start in Code. It can write files Desktop can read later, but Desktop can't reach the host directly.
2. **Token-sensitive?** Mobile and Bridges have the thinnest contexts. Use them for narrow asks.
3. **Need your knowledge base loaded?** Desktop or Code only. Mobile gets the account-level seed, nothing richer.
4. **Need browser / OS-level control?** Desktop (Chrome MCP, computer-use) or Code (with a driven browser).
5. **Working across two clients or two projects?** Keep them in separate threads and never let one thread see the other's material.