@ucsandmanGitHub ↗

Wes Sander

Solo founder running a Fable-led Claude Code harness with guard hooks, model routing, Codex as executor, and a governance layer for unattended runs.

How this setup has evolved

Version 1 · Latest

First snapshot of how I actually run Claude Code day to day. Most of it is guard hooks and model routing that came out of things breaking, plus a few tools I built so agents can do real work without me babysitting them.

How I work with AI

What I build

Infrastructure for AI agents and small products on top of it: an approval and evidence layer for unattended agents, a compiler that turns APIs and MCP servers into CLIs, and a handoff board that moves unfinished work between coding-agent CLIs. AI does most of the implementation; I own the decisions, the review and anything that touches money, production or other people.

Agents & harnesses

  • Claude Code (current): Main loop for planning, orchestration, integration and final review. Runs on Fable with a heavily customised harness (below).
  • Codex CLI (current): External executor for heavy implementation, debugging, test fixing and multi-file edits, driven from Claude Code.
  • OpenClaw (current): Second local agent; a /team skill fans one task out to Claude Code and OpenClaw together.
  • Gemini CLI, agy, grok CLI (installed): Registered as handoff targets for the limit-rotation board, not daily drivers.
  • Claude desktop / Claude in Chrome (configured): Available for browser work; scripted Playwright headless is the default for QA.

Apps & terminal

  • Windows Terminal + PowerShell (current): Where every agent session runs. Bash is available for POSIX scripts.
  • VS Code, Cursor, Antigravity IDE (installed): Present on the machine; day to day work happens in the terminal with agents.
  • Docker, PostgreSQL, Redis, LM Studio (installed): Local services for testing; a Postgres container is required for some test suites.

Machines

  • Windows 11 desktop (current, local): i7-13700KF, 32 GB RAM, RTX 3070 Ti. Runs all agents, local services and browser QA.
  • Namespace cloud devbox (current, remote): Disposable Linux box for clean-clone verification, risky installs, long jobs and Linux-only testing. My Claude Code harness is packed onto it with agent-capsule.

How I customise my agents

Harness, mirrored public at claude-harness

  • Guard hooks (current): Around 35 PreToolUse and Stop hooks, each born from a real incident: secret guard (never read .env files, block secrets in output), rm guard, dev-server and process-kill guards, a slow-command guard, a batch guard that denies the fourth consecutive single tool call, and a forced-verify stop gate.
  • Model routing hooks (current): Every subagent dispatch must name its model, downward only (Fable → Opus → Sonnet → Haiku). A budget guard prices each spawn against doing the work inline and denies spawns that cannot pay for their own overhead. An advisor pattern lets a weaker agent consult one rung up.
  • Lean agent types (current): opus-owner, sonnet-implementer, haiku-scout with restricted tool sets, about a third of the cost of a general-purpose spawn.
  • Global working agreement (current): One rules file loaded into every session: think before coding, surgical changes, push back when warranted, build the human surface before the API, goal-driven execution with verify steps, and a written retro at every handoff.
  • Nightly reflection (current): A /meditate routine tests recorded lessons against later behaviour and promotes a rule only after three signals across two sessions.
  • Memory (current): File-based, provenance-tagged (stated, observed, inferred, suggested), with a routing index and a linter that blocks commits when the store breaks its caps.

Skills I wrote

  • preflight / ship / launch / announce (current): A product goes from finished code to public through the same gates every time, including an SEO floor and search-console registration in the same change.
  • wes-voice (current): Anything I will post online is rewritten in my register before I see it.
  • adversarial-review / tournament / fix-findings (current): Saved Workflow scripts: parallel finders, a skeptic per finding, one synthesiser.
  • wrap / handoff-save (current): Session handoff notes and a resume prompt at the end of every working session.

Installed packs (installed): Anthropic superpowers, official plugins for code review, commit commands and Context7, GSAP and design skills, SEO and marketing packs.

Connections & context

  • declick (current): Compiles any MCP server, API or web page into a CLI that returns trimmed JSON. Agents reach for a declick adapter before an MCP tool or a page fetch, because raw payloads get re-read every turn and trimmed output does not. Subagents get MCP reach through it without carrying MCP tools.
  • DashClaw (current): My own approval layer. Hooks record guard decisions, actions and session retros; a policy check runs before risky actions and unattended runs wait on a remote approval.
  • baton (current): Local kanban that hands a coding agent's unfinished work to the next CLI when the first hits its usage limit; one worktree per card, handoff bundles, merge queue.
  • creds (current): Local credential vault. Before asking me for any key, an agent runs creds resolve and creds mint; only a key that survives both reaches me.
  • Context7, GitHub CLI, treg, mole, Playwright (current): Docs lookups, repo operations, external data and paid tools, web research, headless browser QA.
  • mysetup (current): Maintains this page.

How I delegate and review

  • The main loop plans the tree first. Decisions, review and synthesis stay with it; a change set started by hand is finished by hand.
  • Under about ten tool calls or eighty edited lines, the work stays inline. Larger or parallel work goes to a named-model subagent with a declared estimate, or to Codex.
  • Hard stops need explicit confirmation in the session: deploys, migrations, billing and auth config, any outward message, deletes and force pushes.
  • Never combine private data, untrusted outside content and an outbound channel in one piece of work. Any two is fine; all three is a stop.
  • Done means I read the output: tests and lint passed, the page rendered with real data, nothing sensitive staged.

How I work

  1. Start a session in the repo; the harness loads the working agreement, memory index and any resume note from the last session.
  2. State assumptions and a plan with a verify step per item before anything non-trivial.
  3. Build in the main loop or dispatch to Codex or a routed subagent; hooks block secrets, destructive commands and unrouted spawns as we go.
  4. Verify by running the command and reading the output, then open the rendered page or run headless Playwright.
  5. Ship through the preflight and ship skills, write a retro and a handoff note, and let the nightly reflection decide whether any lesson becomes a rule.

What changed and what I learned

  • A hard block inside a hook produced retries and half-applied edits. The delegate guard now briefs once with measured economics and denies nothing; routing improved more than under the block.
  • A one-line edit handed to a subagent cost about 77k tokens. The budget guard now prices every spawn against doing it inline.
  • A check that has never been seen failing has been run, not verified. Every guard gets re-broken on purpose once, and every verdict prints the count of what it scanned.
  • Trust the target's source, not a prior agent's capability claim. Two agents built a browser adapter over a "no bot API" claim; the service had forty REST routes.

What I'm still figuring out

  • Whether the two-session, three-signal promotion gate for learned rules is too slow or about right.
  • Keeping subagent costs honest as per-call cost turns out to be superlinear; the guard's constants get re-fitted from logged spawns.