howiclaudearmory◆ common build

the rig

r/8sqhc994

CommonUnrated

Bind on Pickupanonymous

Item Level — · this rig hasn’t been appraised yet (run the analyze prompt)

configClaude Code 2.1.195OpusiTerm2

claude‑ing sinceJun 2025

[ Get the rig card → ]Download PNG

EQUIPPED

the physical loadout
  • MicAirPods Proon a boom arm
  • AudioAirPods Proearbuds
  • RigMacBook Air (Apple M5, 24 GB)sitting desk

BUILD

abilities · augments · attunements
  • Augment:superpowersplugin
  • Augment:frontend-designplugin
  • Augment:chrome-devtools-mcpplugin
  • Augment:playgroundplugin
  • Augment:claude-code-setupplugin
  • Augment:skill-creatorplugin
  • Attuned:chrome-devtools · Google Drive · Google Calendar · Gmailchrome-devtools: Drive a real Chrome to screenshot + verify the UI Claude just built. · Google Drive: claude.ai native integration — connected, rarely used. · Google Calendar: claude.ai native integration — connected, rarely used. · Gmail: claude.ai native integration — connected (pending auth), unused.
  • Use:Claude from CLI · iOS

STATS

while equipped
  • Burns 35,307,619 tokens per month (~35M)
  • Costs $200 / month to maintainClaude Max
  • Inspected 0 times

ACHIEVEMENTS

No achievements unlocked yet — this rig hasn’t earned any badges.

Architect, laptop-first

IN ACTION

statusline · the build, running

their statusline (representative)

┌─────────────────────────┐
│ claude · opus · xhigh   │
│ brainstorm → plan → ship│
│ iTerm2 · ~/Projects     │
└─────────────────────────┘

how the panes are tiled

▸ a couple of their prompts — running

> /superpowers:brainstorming build the publish flow Interrogating… (1.4s)Before any code — what's the actual intent? A few questions first.⏺ AskUserQuestion() ⎿ batch the requirements questionsGood. Writing the plan to .scratch/plan.md before we touch code.⏺ Write(.scratch/plan.md) ⎿ the plan⏺ Plan written. Nothing coded until intent was nailed.
7 / 7
> execute the plan — fan out the independent tasks Orchestrating… (1.2s)⏺ EnterWorktree() ⎿ isolate each agent on its own fresh branch⏺ Agent() ⎿ 4 subagents, one per task, in parallelFour agents running in isolated worktrees off baseRef=fresh...⏺ All four branches merged clean. No collisions.
6 / 6
inspect: the full config — 9 sections · 25 cards9 sections · 25 cards · every one exportable
a self-contained prompt — paste it into your Claude Code to install the lot

TL;DR

Architect, laptop-first

MacBook Air (M5, 24GB), no external monitor, AirPods Pro. Opus at xhigh effort, ~35M tokens a month, mostly evenings. I barely hand-write code — I brainstorm the spec, write the plan, then fan out parallel subagents in git worktrees and review the results. Claude runs in auto-mode with remote control + push notifications on, and I'll drive it from the iOS app when I'm away from the desk. The flex isn't the gear; it's the loop.

My workflow

A typical session

It starts as a conversation, never as code. I run superpowers:brainstorming to pin the intent (20 passes last month), then writing-plans to get it on paper. Only then does anything get built — for bigger builds, as parallel subagents, each in its own git worktree branched off a fresh ref so their edits can't collide. Claude verifies its own UI through the chrome-devtools MCP (screenshot the real page, don't trust the assumption), I run an adversarial review, and finishing-a-development-branch merges it to main. I don't stop at 'committed.'

Brainstorm before a line of code

#spec-driven

20 brainstorming + 6 writing-plans passes in 28 days. The plan is the leverage; the code is just typing.

> /superpowers:brainstorming build the publish flow Interrogating… (1.4s)Before any code — what's the actual intent? A few questions first.⏺ AskUserQuestion() ⎿ batch the requirements questionsGood. Writing the plan to .scratch/plan.md before we touch code.⏺ Write(.scratch/plan.md) ⎿ the plan⏺ Plan written. Nothing coded until intent was nailed.
7 / 7

4+ parallel subagents in worktrees

#parallel-agents

44 worktree spins in 28 days. Isolated agents on a fresh baseRef so parallel edits never collide.

> execute the plan — fan out the independent tasks Orchestrating… (1.2s)⏺ EnterWorktree() ⎿ isolate each agent on its own fresh branch⏺ Agent() ⎿ 4 subagents, one per task, in parallelFour agents running in isolated worktrees off baseRef=fresh...⏺ All four branches merged clean. No collisions.
6 / 6

Make Claude verify its own UI

#browser-verify

272 chrome-devtools MCP calls last month. Screenshot the real DOM and check the work before calling it done.

> does the card render right in the dark variant? check it Verifying… (1.1s)⏺ navigate_page(localhost:3000/preview) ⎿ open the page⏺ take_screenshot() ⎿ capture the rendered cardHover state is wrong on the dark variant — fixing the class condition.⏺ Edit(components/Card.tsx) ⎿ fix the hover class⏺ Re-shot: renders correctly. Verified against the real page, not an assumption.
7 / 7

Finish the branch — merge to main

#ship-it

'Committed' is an interim step, not done. Verified work (tests + adversarial pass green) fast-forwards into main.

My config

effortLevel: xhigh

Why it's there: Max reasoning on every turn. I'd rather pay tokens than re-loop.

.claude/settings.json
"effortLevel": "xhigh"
requires Claude Code 2.x
> why is this run burning so many tokens?effortLevel is xhigh — maximum reasoning every turn. The trade is tokens for far fewer re-loops.
⎿ .claude/settings.json@@ @@+ "effortLevel": "xhigh"
⏺ Locked at xhigh.
4 / 4

defaultMode: auto (with a tight allow-list)

Why it's there: Auto-approve, backed by a curated Bash allow-list — git, curl, python3, ffmpeg, open, wc, mkdir, pip3 — not a blanket --dangerously-skip-permissions. It's curated, not sandboxed: curl and git still allow real network access.

.claude/settings.json
"permissions": {
  "defaultMode": "auto",
  "allow": [
    "Bash(git:*)", "Bash(curl:*)", "Bash(ffmpeg:*)",
    "Bash(python3:*)", "Bash(pip3 install:*)",
    "Bash(wc:*)", "Bash(mkdir:*)", "Bash(open:*)",
    "WebSearch",
    "Bash(git -C ‹redacted:path› log --oneline -5)"
  ]
}
requires Claude Code 2.x

Remote control at startup + push

Why it's there: Every session is drivable from my phone the instant it starts, and I get a push the moment Claude needs a decision.

.claude/settings.json
"remoteControlAtStartup": true,
"agentPushNotifEnabled": true,
"inputNeededNotifEnabled": true,
"preferredNotifChannel": "iterm2"
requires Claude Code 2.xrequires iOS app for remote

worktree.baseRef: fresh

Why it's there: Parallel agents branch from a clean ref, not my half-finished working tree.

.claude/settings.json
"worktree": { "baseRef": "fresh" }
requires Claude Code 2.x

autoDream + a manual memory-audit

Why it's there: Native memory consolidation runs on its own; I layer the memory-audit skill on top because auto-dream never checks memory against the repo.

.claude/settings.json
"autoDreamEnabled": true
requires Claude Code 2.x

Plugins, skills & MCP

superpowers

Why it's there: The spine of the whole workflow — brainstorming, writing-plans, parallel agents, worktrees, finishing-a-branch. 40+ invocations last month.

requires superpowers plugin

frontend-design

Why it's there: Every UI screen goes through it — it's what keeps my frontends off the generic-AI look.

requires frontend-design plugin

chrome-devtools MCP

Why it's there: Claude drives a real Chrome to screenshot and verify the UI it just built. 272 calls in 28 days — my single most-used MCP.

requires chrome-devtools-mcp

Cloudflare skill suite

Why it's there: For anything I put on Cloudflare, the wrangler / workers-best-practices / durable-objects skills keep deploys correct instead of guessed.

requires Cloudflare skills

My CLAUDE.md

Observations, not the file

~72 lines, global (not path-scoped), no rules/ subdirectory — a single principles file. It's concrete rules with rationale rather than vague platitudes: defaults for how working artifacts are formatted, file-path conventions, a 'sparring partner, not a yes-machine' stance, plan-before-significant-work, adversarial-review-by-default, and a rule for how finished work gets integrated. Raw file available on request; I don't publish it verbatim.

Physical setup

MacBook Air — Apple M5, 24GB

Why it's there: Laptop-first, no external monitor. The whole rig fits on a plane tray, and I still burn 35M tokens a month.

AirPods Pro

Why it's there: Mic and headphones in one — same device for calls and coding, and it moves with me between the desk and the couch.

The anti-battlestation

No monitor, no mechanical keyboard, no standing desk, no split ergo anything. The point is that a stock laptop plus a disciplined brainstorm-plan-parallel-verify-merge loop out-produces a $5k setup running ad-hoc prompts.

Rituals & tips

Never let Claude write code before the plan is written

Why it's there: brainstorm -> writing-plans -> execute. Intent on paper first turns a 3-hour flail into a 20-minute build. The plan is the leverage.

Make it verify its own UI

Why it's there: Give Claude the chrome-devtools MCP and tell it to screenshot the real page and check its work before claiming done. 'It looks right' is a guess; the screenshot is evidence.

requires chrome-devtools-mcp

Run 4 at once, cleanly

Why it's there: 4+ Claudes in git worktrees off baseRef=fresh. Real parallelism without the branches stepping on each other.

requires Claude Code 2.x

Stack & surfaces

Terminal + iOS

Why it's there: I Claude from iTerm2 at the desk and from the iOS app Code tab when I'm away — same sessions, remote-controlled and push-notified.

~$200/mo, ~35M tokens/mo

Why it's there: Claude Max, flat rate. The token count does the bragging; the dollar figure stays boring on purpose.

Why this works

Leverage is the loop, not the gear

A stock MacBook Air, Opus at xhigh, and a disciplined loop — brainstorm the intent, write the plan, fan out parallel subagents in isolated worktrees, make Claude verify its own work, adversarially review, merge to main. No monitor, no mechanical keyboard, no battlestation. 35M tokens a month of leverage, most of it while I'm not even typing.