Gareth Price

What I build

Software for a rapidly growing data analytics company, using frontier models and a home workstation for local-model inference. The same agent that writes code also administers the machine it runs on.

Agents & harnesses

• Claude Code (current): My main harness by a wide margin. Several hundred sessions a month, from product code to system administration.
• Glass Factory (current): My own orchestrator, a "dark factory" pattern with more transparency. It runs headless against Linear tickets; details under "How I delegate and review".
• Codex CLI (current, light use): A second agent, used a handful of times a week to more depending on who is winning the coding model race.
• opencode (configured): Pointed at a local llama.cpp server instead of a hosted model, with its own set of MCP connections. Uses oh-my-opencode plugin for multi-agent orchestration.
• Aider, pi, hermes, Gemini CLI (installed): Tried along the way; untouched since July or earlier.
• Cursor: Cancelled paid sub when SpaceX bought it, have built more in the terminal these days anyway.

Models

• Claude Fable 5.1, 1M context (current): Default model in Claude Code. Usually have it plan stuff then switch to Opus for implementation if using Claude Code interactively.
• Local quantized model via llama.cpp (configured): A 4-bit quant of Qwen 3.8 27B with vision at 128K context is the sweet spot right now for me. On a 20 GB card I chose context length over precision.
  • Local model changes almost weekly as development is happening so fast. Currently using mradermacher's Swift-Qwen 3.8 27B MTP at i1-IQ4_XS quant for ~30 tok/s, up from ~14 tok/s on stock 27B.
    • Multimodal is worth the overhead for doing screenshot interpretation with chrome-mcp-devtools. The mmproj seems pretty interchangable for model variants that don't ship with one.
  • gemma-4-e4b (70 tok/s) and minicpm-2b (90 tok/s) for simple fast use, haven't quite found a daily use for them yet but I like the speed.
  • Checking model quality and performance with a custom llama-optimizer that self-improves llama.cpp configuration to maximize performance on my hardware, and a custom llama-eval TUI app (loving textual+rich) that runs through question sets and lets me compare prior runs:

Terminal

• tmux over SSH / mosh (current): Agents run in tmux on the workstation; I attach from wherever I am, they keep running if I get disconnected. mosh was game changing for working from flaky wifi on the Amtrak (they can send radio waves to Mars but not to the rail tracks into NYC apparently).
• Ghostty: on MacOS and Linux.

Machines

• HP Z2 Mini G9 (current, headless): Ubuntu 24.04, 96 GB RAM, Nvidia RTX 4000 SFF Ada (20 GB). Runs every agent, the local model server and light training. Snagged the 96GB upgrade for $274 and the whole machine for ~$1,500 back in 2025 - wish I had known how things would go as I should have bought an RTX 6000 when they were (relatively) cheap. Lives in an air-conditioned back closet as it is noisy when the fans ramp up.
• Tailscale (current): How my other devices reach it. Work and personal tailnets run side by side on the same box (pain to set up).
• Sunshine + Moonlight (current): Desktop streaming over Tailscale when I need a GUI, with per-session resolutions including a 3840×1080 ultrawide mode for Xreal One Pro glasses I use while on the road. RustDesk is good for remote desktop too.
• M3 MacBook Pro: Main laptop, wish I'd gotten more than 18GB RAM as I can't run anything over single-digit billion params via mlx without the whole machine choking.
• Samsung S23: DeX is really nice for a basic desktop, I rarely need to take my laptop out while traveling now.

Skills

Personal

• arxiv-digest: n8n workflow that compiles a weekly digest of arXiv papers in our field from RSS sources. It scores each paper (1000+ per week), a review pipeline pulls full text for ~10% of the ones of most interest and it publishes a digest each week to Slack focused on what is of interest to our team.
• china-digest: n8n workflow that compiles a weekly digest of Chinese AI news from RSS sources and translates to English, focused on what differs from the US. Posts to Slack.
• daily-cto-briefing: n8n workflow that crawls through various sources and sends me a morning briefing along with coaching advice and aggressively prioritizing what I should be doing that day. Not too aggressively, had to tone it down as it made me feel bad in the morning when it was mean :(
• MagicMirror LLM Summary: Custom dashboard widget on a Samsung Frame TV in my office running a MagicMirror dashboard that summarizes github and production application activity every few minutes, routed to llama.cpp endpoint.
• Frigate: Using the LLM integration in the open-source NVR to route to llama.cpp endpoint and interpret motion alerts. It recognizes animals (skunks, squirrels, etc), bird species, car makes/models pretty well and in a few seconds a screenshot.

Team skill pack (private repo, symlinked into my skills folder)

• Covers the ticket-to-PR path (user story, plan, implement), git worktrees, standup and end-of-week reports, incident write-ups, plain-language rewrites to ISO 24495-1:2023
• Browser QA that steps through Gherkin feature files (Gherkin syntax was abandoned as it was annoying to hand write but it is great for LLM QA) to generate Playwright tests, logs PASS / FAIL / BLOCKED to CSV and can record the flow to MP4 product demo videos with captions and voiceover.
• pr-review (team skill, run only when I invoke it): Reviews a GitHub PR against our review guide and style guides, fetched from Notion and cached for a day, then prints a structured review (blocking / question / suggestion / nit / praise). The review's own prose is held to our writing guide. Moving this into a Slack interface for initial pass of PR reviews. Ideally, small and low-impact items have an almost entirely automated SDLC, freeing up time for human review of sensitive or complex tasks.

Installed

• oblique-strategies (installed): Uses the card text from Brian Eno and Peter Schmidt's famous card deck to introduce entropy and inspiration to unstick a stuck project through divergent ideation. Spins up isolated branches under different frames, then a separate critic pass. A run costs about ten agent calls, so it is gated; oblique-strategies only runs when I ask for it by name.

MCP connections

• chrome-mcp-devtools (configured): Drives a real browser for QA and debugging. Still feels like magic to watch an AI navigate the web interactively.
• Slack (configured): The plugin handles search, digests and drafting. Separately, a small Socket Mode app I built lets an agent on the headless box post a Yes/No question to Slack and wait for my click, with no public URL or tunnel.
• My company's own MCP server (configured): Lets the agent query data and build dashboards in our product.
• GitHub, Notion, Figma, Google Workspace (configured): claude.ai connectors available inside Claude Code sessions.
• mysetup (current): Maintains this page through my agent.
• Mostly using command line tools instead of dedicated MCPs for dev work - I give the harnesses access to aws, git, a custom CLI wrapped around my company's APIs, etc.

How I delegate and review

Glass Factory (current) is an autonomous delivery line I built to route automated production to multiple models. Labelling a Linear ticket hands it over. Linear has a really nice agentic chat API in it which I can use to interact with an individual task from the context of the ticket, and a custom textual TUI gives me a real time display with a retro aesthetic:

• Pipeline: audit → plan → build → QA → promote, ending in a PR. Each step is routed to an appropriate model, either Claude (using cli tool to use Max subscription), codex, opencode+llama.cpp, openrouter. Each is a fresh headless process in its own git worktree and an ephemeral test environment, and then it exits.
• Deterministic controller: no LLM decides what runs next. A reconcile pass and a simple state machine derives each ticket's state from the Linear lane, the latest marker comment and the GitHub PR, then launches the one step that's due. There is no local database, every step is idempotent, and a human dragging a card is always honored.
• Human gates: plan approval, UAT, PR approval, stage QA and go-live. Gates are conversational: a question gets a grounded answer and the gate stays put, and a change request can only route backward to rework. Only a human moving the card ships anything.
• Checks: QA goes to a model from a different lab than the one that wrote the code, and QA evidence must be screenshots of the running app. Mocked renders are rejected as fabricated. It ran in a log-only shadow mode until a clean end-to-end run.
• Watching it: a live event feed drives a terminal dashboard styled after old "cracktro" aesthetics, Slack digests and handoff cards, alongside a cost ledger and golden evals with a report-only LLM judge.
• Hearing it: A client application on my MacBook consumes the glass-factory activity feed and generates an ambient audio environment that lets me "hear" what it is doing without needing to watch the screen, a low hum of activity that picks up pace with resource consumption with sounds for completion and stop states.
  • Been thinking about ways to hook up YuE2-3B to generate continuous music that ambiently transmits the state of the factory
• Reporting: Shows total token usage, model routing, share distribution, how many advanced to the next stage, overall model quality score for self-optimizing routing: Factory reporting. Very glad those Claude calls go through my flat rate sub, showing the unsubsidized cost is a good reminder why I am working to run more of this stuff locally.

How I work

• Agents live in tmux on the workstation. I attach over SSH or mosh through Tailscale, and switch to Moonlight only when I need a desktop.
• The agent is also the machine's sysadmin. When remote desktop, VPN routing or the GPU misbehaves, Claude Code diagnoses it, and the durable fix goes into its file-based memory with a "why" and a "how to apply". Dead ends are recorded too, such as a note not to retry a hardware encoder that can't work on this box.
• When the agent keeps failing the same way, I promote the fix to my global instructions. The clearest case: its commands run through zsh, where an unquoted variable doesn't word-split, so a loop silently ran once and produced a false "verified identical". The rule now reads: if it loops, splits a string or uses arrays, run it under bash.
• Memories are reconciled to a local wiki that contains context about my work and the company.
• The NVIDIA card is reserved for inference. Remote-desktop encoding stays on the Intel iGPU or NVENC's dedicated encoder block, and local LLM models take turns because they can't share 20 GB.
  • nvtop and btop are good for monitoring system and GPU activity:
• A Moshi hook used to intercept every Claude Code permission request and route it through a local daemon to Moshi on iOS which I use to log in remotely. Lovely terminal app, great tmux integration and frequent updates.
• Also using Termux on a Samsung S23 DeX device with XReal One Pro AR glasses while traveling.

Costs

• Claude Max - $200/mo, best deal in town while it's heavily subsidized. At API cost would be thousands.
• OpenAI Pro - $100/mo
• Local Inference - $0.13/h in electricity at full use (4000 Ada SFF uses a mere 70W), about $2k in hardware (in 2025, would be more now). Still at the "fun hobby" stage, economically cloud APIs make much more sense
• OpenRouter - about $20/mo in API costs for glass-factory experimenting with larger models I can't run locally, will probably increase