Building Frontier Products with AI at One-Person Scale

My writing · 2026 · 11 min read

Building with agents, designing products that agents can operate, and deciding what is ready for people to use. Lessons from native audio, an agentic archive and a browser instrument.

Give a family archivist a document and it proposes sourced changes to a family tree. Give a music tool a composition request and an agent can use the same score, editor and sound engine as a person. These are the kinds of products I am building: AI changes what the software can do, not just how quickly I can write it.

Coding agents let me work across native applications, streaming, emulation and spatial interfaces at one-person scale. The important part is choosing what they should build, shaping how it feels to use, and finding out whether it actually works. A convincing implementation is the start of that work, not its conclusion.

This is an account of that practice, centered on a concrete decision: how a guest's iPhone should play a room's music after its screen locks. The evidence changed both the architecture and what I could honestly promise.

Why these products exist

Each one started from a problem rather than from a wish to demonstrate range.

PartyParty removes the setup between a host playing music and guests listening on their own headphones: one Mac, a QR code, no guest account or app. Darabiha helps a family recover multilingual, scattered records without giving up authority over them. The archive's agent can read and reconcile evidence, but a connected assistant cannot quietly rewrite the family's history.

Chiptunes.app makes a song something a person or an agent can compose, edit and share in the browser. Its score can also compile into a Game Boy cartridge. The browser instrument and the cartridge are two implementations of the same music, with their audio compared in an emulator; physical hardware verification remains separate.

The Retro Porting Toolkit website makes a collaborative technical ecosystem navigable, connecting other people's recompilers, runtimes, ports and releases. ramine.net makes the publishing system itself inspectable, including the sources behind its claims. Its Spatial Gallery asks how that same work changes when it becomes a place you can walk through. These are publishing and interaction problems, not products with an AI chat feature attached. Agents help me build and maintain them.

One decision, from assumption to shipped behavior

The behavior that mattered

PartyParty turns one Mac into the sound system for a room. A host plays music as usual, guests scan a QR code, and they listen on their own iPhones and headphones with no app and no account.

The behavior that decides whether that works is narrow. A guest opens the page, puts the phone in a pocket, and the screen locks. Audio has to keep playing through that, and it has to never jump. An audible skip in a room where everyone is on the same track is not a glitch, it is the party stopping.

Real rooms taught that lesson before any measurement did. At a live set on 4 August 2026 the player's stale threshold was twelve seconds, so phones froze for twelve to twenty seconds while their latency ratcheted upward; it is four seconds now, because four seconds of zero progress is a starving player rather than a buffering one. A per-session cap on drift corrections shipped once and left a phone 16.7 seconds behind. A silence keepalive fired 120 ms after the last real capture frame, inside ordinary audio-hardware jitter, and spliced zeros into live audio.

The first architecture, and what failed

The ordinary choice is a player written in JavaScript, because it hands the application control of buffering and position. On iPhone, hls.js with ManagedMediaSource produced repeated audible seek skips. It is recorded in the repository's agent contract as not a production option there, and the same held for the WebKit shell browsers on iOS, where it synced noticeably worse in the field.

Playback on Apple devices is now the platform's own player, AVPlayer, reached by setting the source on the media element directly. hls.js survives as a 404 KB lazy-loaded fallback for browsers with no native HLS, and it stays off the Apple join path entirely.

The evidence that exposed the problem, including the evidence that did not count

The skipping needed no instrument. The question that followed did: once playback belongs to the platform, where does the platform actually sit relative to the delay the room declares?

Unit and contract tests cannot hear AVPlayer. On 5 August 2026, two builds that passed those tests failed on real phones within minutes. One rolled a live listener backward. The other parked a phone twenty-seven seconds behind.

So the gate became a soak: attach a muted, headless, real AVPlayer to a live stream for ten minutes, and pass only if it proves it attached, advanced, sat at the declared target, and never moved backward. The first version of that harness reported PASS for a run in which the player never connected. That is the same theater in a smaller box, and it is written into the script's own header so it stays known.

The convenient measurement was then rejected outright. A small proxy exists to serve a candidate playlist so it can be soaked without shipping it, and it is explicitly not valid evidence for where a player attaches: it reported roughly 3.1 seconds whether the start offset was pinned on the multivariant playlist, pinned on the media playlist, or absent altogether. The synchronous proxy makes the player fall behind, so what it reports is mostly itself. A number that does not move when the thing it measures moves is not a measurement.

The decision, and what it cost

Handing playback to AVPlayer is a permanent trade. The application no longer owns position. PartyParty never seeks a healthy native player, and the guest page treats a seeking event on an audible player as an external event worth logging, because it can only have come from Safari, Control Center, or the guest.

Losing per-listener control means the room's timing has to be declared once, in the playlist, for every phone on every path. It is EXT-X-START:TIME-OFFSET=-3.000,PRECISE=YES in the multivariant playlist, a 0.9 second PART-HOLD-BACK floor, 320 kbps stereo AAC-LC in 500 ms segments and 150 ms parts, and one constant in the Go server: Delay = 3.0. Never adaptive, never per phone, never tracking an individual listener's conditions.

Two forms of that declaration were tried and are recorded as never again. Stretching PART-HOLD-BACK to 2.9 pointed outside the parts region, and AVPlayer snapped a listener to the oldest edge of the window. Putting EXT-X-START in the media playlist without PRECISE measured 25.00 seconds from the edge, because the offset applied from the wrong end. The only correction still available is coarse: a visible phone that stays 0.75 seconds beyond the room target for three consecutive measurements gets a fresh attachment, with no per-session cap.

The repositories record what was tried and what replaced it. They do not record how long any of it took or what it cost in money, so I am not going to put a number on that.

What shipped, and what is still open

On 11 August 2026 a muted real AVPlayer measured the direct path at about 1.17 seconds and the relay path at about 3.33 seconds, against the declared three second target. That leaves the common direct path without the cushion it was designed to have, and puts a guest on venue Wi-Fi and a guest on the relay roughly 2.2 seconds apart in the same room. It is reproduced, and it is not fixed.

The release decision was to ship and to change the words. Public copy dropped "synchronized" and the exact three second promise in favor of low-latency beta language, and the TestFlight tester description discloses the direct and relay difference. The declared target stays at three seconds rather than being lowered to match the accidental direct measurement, because the cushion exists to absorb venue Wi-Fi stalls. Synchronized-playback claims do not return until a candidate passes the pre-upload soak and a supervised mixed-path field test with real phones.

PartyParty is in public beta by invitation. The repository records no usage figures, so there are none here.

The reusable part is two rules. Evidence has to be produced at the layer where the user experiences the product. And an instrument that changes the thing it measures is not a weak measurement, it is not evidence at all.

The same method on two other products

Chiptunes.app: choose the clock instead of rounding it. The Game Boy has one sample buffer, 32 nibbles of wave RAM on channel 3, so a sampled drum kit is played by rewriting that buffer while the channel runs. The obvious refill point is the video frame, because a music driver already runs there and it needs no interrupt handling at all. That route samples at 1911 Hz for 955 Hz of usable bandwidth, which is muffled thuds with no click and no sizzle. Refilling from the hardware timer interrupt instead makes the sample clock and the refill clock the same clock: channel 3 at period 1792 steps its nibbles at exactly 8192 samples a second, one buffer lasts exactly a 256th of a second, and the timer's 4096 Hz clock with a reload value of 240 fires exactly 256 times a second, so nothing drifts.

The cost was paid in the emulator rather than the driver. The CPU emulator had to learn interrupts, the timer, and six more opcodes, and it throws on any opcode the driver did not emit, so the additions stay exactly what is used. A kit hit steals the bass voice for its length, which is what the hardware does. The gate is strong because the two sides reach the sound by completely different routes: the browser walks a cycle counter, the cartridge takes a real interrupt on an emulated CPU. On the current build it plays every drum through both paths and reports 0.9918 spectrogram correlation at 1.34 dB per band, and asserts that the two clocks are exactly in step.

ramine.net: one missing file unmounted an entire scene. On 1 September 2026 the Spatial Gallery pane on its own project page rendered black in production. The cause was not the pane. A newly published article had no generated card texture, drei's useTexture threw through Suspense on the 404, and the uncaught error unmounted the whole WebGL canvas. One missing image took down the room.

The fix was three things in increasing order of durability: generate the missing art, wrap each tile in its own error boundary so a future texture failure costs one flat-colored tile instead of the scene, and add a content test that requires card art or a preview clip for every talk and article so the class of failure cannot recur silently. The handoff also records what was not proven that day: the in-app preview browser cannot composite the scene, so the fix was not called visually confirmed until a real browser looked at the deployed build.

Different products, different boundaries

The operating system around the agents

The leverage comes from making the work legible enough that agents can contribute without being allowed to redefine the product accidentally.

The product contract comes first. Each repository records its user problem, system boundaries, platform constraints, ownership, and release conditions. Agents receive bounded work against that contract instead of an open invitation to generate an application.

Architecture is expressed as enforceable structure. Typed records, validation, fixtures, tests, content eligibility, explicit site selection, and agent-readable instructions turn decisions into constraints the next task must respect. A handoff records facts about the live system and its remaining risks so a different agent can resume without inventing a new baseline.

Implementation and review are separate jobs. Agents can research unfamiliar APIs, implement across languages, generate tests, inspect failures, and review one another's work. The output is still judged against the product behavior and the underlying platform, not against whether the code looks plausible.

Verification follows the risk. A type check is useful evidence for a schema change. It is not evidence that Safari drew the correct native cursor, an iPhone continued playing after its screen locked, a cartridge sounds like the browser renderer, or a spatial interaction remains comfortable in a headset. Those boundaries are tested on the real system.

Operation is part of the product. Deployment, media processing, metadata, source attribution, privacy, monitoring, and continued iteration are not cleanup after the demo. They are part of the work agents are expected to support and the human owner is expected to verify.

Where the method fails if used carelessly

Agents are persuasive before they are correct, and every failure below happened here rather than in the abstract.

They preserve a claim after the evidence for it has narrowed. PartyParty's product site presented automatic Shazam track recognition as an unqualified shipping feature when the only proven result was recognition in a development-signed build; the page now labels it as part of the beta and states the exact proven boundary.

They accept a green result as proof of the thing it was meant to prove. The playback soak harness reported PASS for a run in which the player never connected, and two builds that passed unit and contract tests broke on real phones within minutes.

They accept computed browser state as proof of visible native behavior. This site's own rule now says that inspector output, synthetic events, and headless WebKit prove engine state and never prove what Safari drew or what a trackpad did.

They make a collaborative ecosystem sound like one person's technical work. The Retro Porting Toolkit page documents tools, runtimes, and ports that other people build and maintain. I built the website and the publishing system.

All four produce polished and false stories. The countermeasure is not to remove AI from the process. It is to bind every claim to the live system, separate contribution from attribution, keep irreversible decisions human, and require evidence at the layer where the user experiences the product.

Where one person stops being enough

One-person scale is an advantage for as long as the work is decisions, structure, and code. It stops being one at the boundary where evidence needs other people or other hardware.

PartyParty's remaining verification is a supervised mixed direct and relay field test with real phones on a real venue network. One person cannot be several guests on several phones in a room, and a headless soak does not become that by running for longer. Nor can the builder be the operator at the same moment: compiling on the host Mac during a set has caused capture strain and audible cutoffs, so the rule is not to build while it is broadcasting. The Spatial Gallery's frame budget needs a headset on a head. Chiptunes verifies cartridge execution in an emulator, not on physical hardware.

Those are the places where the model needs help, and naming them is part of owning it.

One-person scale is a demonstration of leverage, not an argument against teams. At Halfbrick, I built a product organization around frequent releases and reviews of real player behavior¹². The useful habits transfer: make the intent clear, give people room to contribute, inspect what reaches users, and learn without defending the first idea.

I want to bring this practice into product and R&D leadership: building hands-on, helping a team explore what is newly possible, and turning the strongest ideas into products people choose to use.

Sources

1. Game Developer, November 2014
2. Game Developer (Gamasutra)

Links

• See the current products
• Contact Ramine