Running a one-person studio from the Isle of Jura with Claude Code

Basic Unit is a one-person studio. It works remotely from the Isle of Jura for organisations in the UK and US, and builds and runs its own family of Hebridean island websites — strategy, content, design, code, deployment and monitoring — with Claude Code as the production team. This note describes the system: what it is, how it holds together, and what still breaks.

Lynton Davidson · Published July 2026 · Last updated 14 July 2026

The setting

Jura is a Hebridean island reached by ferry. From it I run Basic Unit's client work — remote information-architecture, interface and strategy engagements for organisations a long way from this island — and, with my wife Pi, a self-catering holiday business across Jura and neighbouring Islay. The studio builds and runs the business's sites, together with the official Isle of Jura destination site. Those island sites matter to this note for one reason: they are the studio's test bed — production sites we own end-to-end, where every method described below is deployed and measured before it goes anywhere near a client.

There is no team, no office on the mainland, and no contractor bench. I have run this pipeline — strategy, copywriting, design, build, deployment — for thirty years, with human teams in London, New York, Paris, Munich, Sydney and Los Angeles, from hand-built HTML in 1996 onward. The job has not changed. The team has: one desk, partnered with Claude, now ships by my estimate several times the output of those teams. That multiple is an estimate — most other claims in this note are measured.

One repository, everything in it

The whole operation lives in a single git monorepo: deployable code under sites/, everything else that makes each project work — brand documents, tone-of-voice specs, content drafts, research, design prototypes — under projects/, and cross-project methodology under shared/. Git is canonical; every machine is a clone.

This is the single most load-bearing decision. An AI collaborator is only as good as the context it can reach, and a monorepo means Claude Code can read the brand voice document, the fact registry, the design system and the deployment config in the same session it edits a page. Nothing about the business lives in my head or in a silo the tooling cannot see. When everything is a file in one tree, everything is context. Client engagements run the same pattern in their own repositories.

Context files are the continuity mechanism

Claude Code sessions start from zero, so continuity has to be engineered. Three layers do it:

• CLAUDE.md at the repo root — the bootstrap. Who I am, what the sites are, where everything lives, the rules that never change. Injected into every session automatically.
• OPS.md — operational law: file placement, commit discipline, how concurrent sessions share a working tree without treading on each other.
• Per-project _context.md — a living state document per site, updated at the end of every working session. The next session, on any device, reads it and carries on.

The continuity mechanism is a file, not a memory feature. That makes it inspectable, versioned, and portable across machines — and it means the quality of the AI's work is a function of how well I maintain the documents, which is a discipline I can control.

The whole pipeline, one desk

A studio is a pipeline, and this one runs all of it. A single guide page on one of the island sites, from nothing to live:

• Strategy. Does the page deserve to exist, which site in a multi-site ecosystem owns the topic, and what is its one primary entity. If a capable model with public-web access could write the page without us, it is not written. These decisions are mine.
• Copy. Drafted against a written tone-of-voice specification and a per-site nuance brief, then gated — wordlist, fact registry, structural checks — before a human eye even starts the edit.
• Design. Two or three throwaway HTML prototypes before anything is built. Sign-off happens on a composition you can open in a browser, so the build copies a decision rather than interpreting a guess.
• Build. Next.js and Sanity: entity facts in typed, structured fields rather than prose, structured data emitted from the same source that renders the page.
• Deployment. Git push, CI, edge. The same commit discipline whether the change is a comma or a schema.
• Measurement. The standing audits pick the page up from its first deploy; the citation probes report when assistants start using it.

The same pair of hands at every stage — mine and Claude's. What I hold is what I held when the teams were human: direction, taste, and the decision about what deserves to exist.

Methodology as executable skills

Anything I found myself explaining twice became a skill — a slash command that packages a repeatable procedure. /content-review runs a gated, multi-layer pre-publish review over any page — voice, facts, structure, agentic-retrieval survival — and returns a go/no-go with specific edits. /geo-watch sweeps the AI-search research landscape weekly and writes a dated digest. /citation-probe asks live AI assistants the questions our customers ask and scores whether our sites are cited in the answers. What each gate checks, and in what order, is the studio's accumulated judgement — described here by effect, not by recipe.

The pattern matters more than the inventory: procedure lives in version control, not in habit. When the procedure improves, it improves for every future session.

Scheduled autonomy

The studio reports to my phone whether or not I have opened a laptop. launchd-scheduled jobs run daily and weekly on the studio machine: a morning job aggregates the previous day's traffic — GA4, Search Console, server log drains — into a digest with auto-raised flags; on Sundays a deeper cycle runs an AI-visibility digest, the research scan, and a weekly review orchestrator that runs the studio's audit scripts, probes AI assistants for citations, checks that the other jobs have been running, and writes a single review with proposed actions. Anything urgent lands on my phone through Pushover.

Each job writes a heartbeat file so that a silent failure is itself detectable — the weekly review checks the pulse of the daily jobs. Monitoring the monitors is not optional in a one-person operation; there is nobody else to notice.

Desktop, phone, ferry

Claude Code runs on the desktop at home and in the browser on a phone. Both work against the same repository, so a session started at the desk can be picked up from the ferry queue — same context files, same branch discipline, commits flowing through the same review. Island life sets the constraint: the work has to be able to pause and resume anywhere. The system is built so that the pause costs nothing.

The methodology layer

Underneath the operation sits a written methodology: an AI-search playbook of thirty-plus versioned modules, updated on evidence — the weekly research scan feeds it, and each change is logged against sources. The island sites are its test bed: every principle in the playbook is deployed and measured on production sites we own.

Its territory, at concept level: how retrieval-augmented and agentic search pipelines — planner, router, retrieval, critic — select content; query fan-out, the ten-to-thirty synthetic sub-queries behind a single prompt, and what domain saturation across them does to citation probability; passage-level retrieval and the fixed-spine section design it rewards; entity consistency and semantic triples for machine-extractable facts; site-level vector coherence, where pages are embedded and measured for cosine drift from the site centroid; and citation measurement across assistants that rotate half or more of their cited sources week to week.

The loop from research to operations is short. When published crawl research showed that AI assistants fetch pages at answer time with hard sub-second timeouts and no retry — so a 499 in the server logs means silent exclusion from the citation pool, invisible to every analytics dashboard — we pulled a week of our own logs the same day. Zero, because the HTML is edge-cached. The check is now one of the standing audits.

To be clear about the boundary: the playbook modules, the gate checklists, the wordlists and the audit tooling are the studio's working assets — a year of measured production experience — and they stay in-house. This note describes the shape of the system, because the shape is the demonstration: what one person and Claude can operate. The contents are what clients engage the studio for.

This page practises what it describes — facts first in an extractable table, one subject per section, machine-readable structure behind the prose, and a home page that stays minimal because the depth lives here, one link away.

Working with a non-technical partner

Pi contributes research and page drafts for the destination site from Google Docs. She does not use git, and should never have to. A triage skill pulls her documents from a shared folder, files them into the right project, commits them on an attributed branch and opens a pull request for review. The collaboration boundary is a folder, not a toolchain — each of us works where we are strongest.

What breaks, and what stays human

A note like this is worthless without the failure modes, so: the system assumes drift and audits for it, because drift is constant.

• Voice drift. Language models reach for intensifiers and self-promoting qualifiers — "genuinely", "stunning", "truly unique". We keep a versioned wordlist of these tells and scan for them at every pre-publish gate; the sweep that created the wordlist stripped a dozen of them from one site's pages. Left unchecked, they would sand the voice off everything.
• Fact drift. Distances, capacities and counts mutate across rewrites, and the wrongness is often subtle. Islay has eleven working distilleries but only ten a visitor can tour — the newest has been distilling since 2024, is not yet open to visitors, and will have no whisky of its own before 2027. "Eleven distilleries to visit" is the kind of wrong only a registry catches, so a fact-drift script checks inline claims against a per-site critical-facts registry before anything ships.
• State drift. With many documents cross-referencing each other, version references go stale. Session-end protocols include a propagation sweep; the audits catch what the protocol misses.
• Concurrency hazards. Two sessions sharing a working tree can change branches under each other. The rule to verify the branch before every commit exists because one didn't.
• Model change. Model updates shift behaviour — sometimes better, occasionally worse in specific, measurable ways. When one frontier-model update dropped from 92% to 59% on a public long-context retrieval benchmark at 256k tokens, it mattered here within days: a corpus of versioned, near-duplicate documents is exactly the shape that failure mode bites. The working rules gained explicit retrieval discipline the same week — pin versions in cross-references, verify cross-document claims by lookup rather than recall.

And some things do not delegate. Judgement about what should exist, which site a piece of content belongs to, what the business will and will not say, and every final word before publish — those stay with me. The AI drafts, audits, builds, monitors and proposes; it does not decide. That boundary is written into the context files, and it is the reason the rest of the system can run as fast as it does.

Questions

Does Claude Code write the site content?

It drafts within a documented tone-of-voice specification and a per-site fact registry, and every page passes a gated review — including the AI-tell scan — before publish. I edit and sign off everything. The interesting shift is not who types the first draft; it is that the standards the draft must meet are written down and enforced mechanically.

What does this replace?

In agency terms: a producer, a developer, a content editor, an SEO analyst and a reporting function. What it does not replace is direction — the decisions about what to build and why come first, and they remain a full-time human job.

How much of this is specific to a small business?

The scale is small; the pattern is not. Context files as engineered continuity, methodology as versioned skills, scheduled jobs with heartbeats, and drift audits at the gates would transfer to any team that keeps its operation in version control.

Why publish this at all?

Because the shape of the system is the credential, and it cannot be copied from a description — the value is in the checklists, wordlists, modules and measurements built up over a year of production use, and those stay in-house. Describing the architecture costs nothing; operating it is the work.

Can Basic Unit set this up for someone else?

Work arrives by word of mouth. If you have something real to say, write: lynton@basicunit.com.