Field Log

Operating System

One voice, many hands.

The practice runs as an organization, not a chat window. Eugene, a voice agent I built, conducts a roster of named specialists: Quill, the researcher who writes the specs; Prism, the designer who produces the mockups; Forge, the engineer who builds; Critic, the reviewer who tears into the work before it ships; and Scout, the verifier who walks the finished product like a skeptical user. Each has a tuned role, its own tools, and a permission boundary.

Conductor

Eugene

The voice agent I built, conducting the roster. Each agent has a tuned role, its own tools, and a permission boundary.

Quill · researcherwrites the specs

Prism · designerproduces the mockups

Forge · engineerbuilds it

Critic · reviewertears into the work before it ships

Scout · verifierwalks the finished product like a skeptical user

The pipeline is the product discipline.

Spec, then design, then sign-off, then build, then review, then verification. Nothing skips the gates. The same rules I hold professional teams to apply here: pilots run on production AI, every change is measured against a baseline, and no agent's claim about its own work counts as evidence.

Spec Design Sign-off human Build Review Verification

Evidence over assertion. Finished work is rendered, probed, and inspected before it's called done.
Baseline before pilot. If you can't measure the before, you can't claim the after.
Defect ledgers. Every flaw found gets tracked to closure with its own proof, not fixed-and-forgotten.
Create-only test fixtures. Test accounts are created fresh, never borrowed from real users.
A graceful failure that logs nothing is a feature that never worked.

The Log

13 entries. Strongest first. Undated.

Eugene

Desktop

The conductor itself. A voice agent with a real-time HUD, speech in and out, a persistent memory layer over my files, and the dispatcher that runs the whole agent team as detached background workers. Eugene briefs me in the morning, nudges me before meetings, and hands work to specialists while I talk to one voice.

Crewevery agent in the roster, by definition.

Eugene's HUD: the cosmic orb with the live conversation panel and tool feed

From existing captures. Live tool feed and agent panel.

Lesson

An assistant becomes an organization the moment delegation gets a protocol. The breakthrough wasn't a smarter model; it was giving one conductor a team with roles, tools, and boundaries.

Hearthbook

Phone

A tabletop companion app that listens to a game session, transcribes it, extracts the campaign's people, places, and events into memory, and answers rules questions with citations. Works offline at the table, supports two rules editions, and runs entirely as an installable web app.

CrewQuill spec'd it, Prism mocked it, Forge built it, Scout walked every flow at phone width.

Hearthbook dice table on a phone showing a live d20 roll during a session

Hearthbook character sheet on a phone: a level 3 halfling druid with stats and spell slots

Hearthbook rules reference on a phone with a spell entry expanded

Test account. Seeded campaign.

Lesson

I was building against the newest ruleset until the campaign's own materials showed the table plays the older one, so it shipped with both before the first session. Read what your users already use before you decide what current means.

Ember

Phone

A private app built for two people. Daily questions you each answer before either can see the other's, shared rituals, and a guided flow for hard conversations with an AI mediator that summarizes both sides fairly. Row-level security enforces the reveal rules so the app literally cannot show you an answer early.

CrewQuill through Scout, with Critic treating the reveal gate as the core feature.

Ember flame home on a phone: a 34 night streak, glow level, and an upcoming date night

Ember daily question revealed on a phone, showing both partners' answers side by side

Ember love tanks on a phone with a love language nudge and recent acts

Fictional data. The real interface, rendered against a local fixture so no private content is shown.

Lesson

In software this personal, privacy architecture is the user experience. The database enforcing kindness beats the UI promising it.

Stet

Desktop

A system-wide writing assistant that lives at a hotkey, works in any app, and never sends a word to the cloud. A local grammar engine flags issues inline; a local language model offers rewrites. Built native for the desktop with accessibility APIs.

CrewForge forked and extended an open grammar engine; Critic caught the platform edge cases.

Stet overlay flagging a misspelling in TextEdit, with suggested corrections and an issue counter

Native overlay captured on sample text.

Lesson

Local-first is a real product stance, not a compromise. Latency and privacy stop being tradeoffs when the model lives on the machine.

Karaoke

Phone

A live show system: singers sign up from their phones, a host console runs the queue, and a big screen shows who's up. Realtime sync across every device in the room. After launch, a security audit hardened per-singer tokens and column-level database grants, verified against the live endpoints.

Crewbuilt by Forge, audited by Critic, verified live by Scout.

Karaoke singer view on a phone: queue position, wait estimate, and tonight's live queue

Karaoke song catalog search on a phone, filtering the catalog by artist

Karaoke big screen: the current singer performing with the next three in line

Throwaway show. Fictional singers, deleted after capture.

Lesson

The audit found what code review couldn't: a permission fix that looked correct and did nothing. Only a live probe against the real database told the truth.

cut

Phone

A nutrition and weight app for two users: food and barcode lookup against a federal database, calorie and macro logging, and a smoothed weight trend that handles backdated entries correctly.

Crewthe full pipeline; Scout caught the food-search bug against the live deploy that local testing couldn't see.

cut on a phone: calorie and protein rings with the day's logged meals beneath

cut on a phone: weight trend chart with seven weigh-ins, smoothed trend line and goal projection

cut on a phone: water intake, a logged workout with calorie eat-back, and quick-add recents

Test data. Seeded log and trend.

Lesson

A trend line that only updates forward silently lies the moment someone backfills history. Recompute the whole series or don't call it a trend.

Mission Control

Desktop

A personal operations dashboard: calendar, tasks, weather, and system status in one glanceable view, refreshed on schedule and reachable from my phone. Runs as a small local server with a scheduled refresh that calls provider APIs directly.

CrewForge built it twice; the second architecture came from a hard lesson.

Mission Control dashboard tiles in a demo state

Demo state. No personal calendar or email.

Lesson

Scheduled automation can't borrow an interactive login. The refresh that worked when I watched it and died when I didn't taught me to separate human auth from machine auth for good.

Ops Sentinel

Desktop

The boring, load-bearing one: weekly verified database backups and a live health panel across five production apps. Every backup is restored and validated, not just written.

CrewForge and Critic, with a second AI system cross-checking the review.

Ops Sentinel health panel showing five production apps healthy

Demo state. Status panel, no private content.

Lesson

A backup you haven't restored is a hope, not a backup. Monitoring that only checks "is it up" misses "is it silently empty," and the second failure mode is worse.

visual-verify

Tooling the practice built for itself: a verifier that renders any artifact (page, PDF, image), crops every region at full resolution, runs machine probes, and produces a defect ledger that must be cleared item by item before anything ships.

Crewbuilt by Forge, for Scout.

Lesson

This tool exists because I once trusted a thumbnail and an agent's confident self-report, and shipped a broken logo. Evidence tooling is what turns "looks done" into "is done."

CPMAI study app

An offline study tool for an AI project-management certification: a question bank with spaced practice, built as an installable web app that works with no connection.

CrewQuill rebuilt the question bank against the current exam outline; Critic found the flaw.

Lesson

The first question bank had a tell: the longest answer was right 96% of the time. Rebalancing it to 28% was the difference between memorizing patterns and learning the material. Measure your own artifacts like you'd measure a model.

OpsPilot sample

A job tracker for a fictional HVAC company, built as a client-facing demo: scheduling, job status, invoicing views, and reporting, seeded with realistic data and zero backend.

CrewPrism and Forge, from a requirements document written from scratch.

Lesson

A demo with no backend can't rate-limit, error, or empty out mid-presentation. Constraint chosen well is reliability.

Packing List

Phone

The smallest ship and the pattern-setter: a trip packing app that learns a standard list per trip type. Its real contribution was the deployment pattern (isolated repo, private remote, auto-deploy) that every app after it reused.

CrewForge, mostly solo.

Packing List on a phone: trip progress with fifteen of twenty-eight items packed

Packing List on a phone: toiletries and luggage categories with items checked off

Packing List on a phone: remaining categories with per-item quantities

Test data. Seeded trip list.

Lesson

The first small thing you ship end to end is worth more than its feature list. It's the template every later ship stands on.

This page, and the one that cites it

The meta-entry. The portfolio page that showcases this practice was itself specced, designed, built, reviewed, and verified by the agent org, through the same gates as everything above. So was this page. The receipts printed themselves, and I checked them anyway.

Crewall of them, on their own story.

Lesson

If the practice can't build its own proof, it isn't a practice.

Field Notes

Transferable, one line each.

N01

An agent's self-report is not evidence. Render it, probe it, ledger it.

N02

Baseline before pilot. No before, no after.

N03

One voice, many hands. A team of agents needs a conductor, not a group chat.

N04

Verification is a role, not a step.

N05

Plan for the day the agents hit their limits mid-run. Capacity is part of the architecture.

N06

Test fixtures are created, never adopted.

N07

The second time you ask a human to check something, build the tool that checks it.

Notes 01, 03, 05 carry the lessons from the stretch that stress-tested the whole org at once.