The Screen Is a Viewport onto a Physical Object
i swear, it is
Every music app on your phone is a filing cabinet. Drawers inside drawers, tabs behind tabs, settings three screens deep. Ableton Note, Koala Sampler, the various MPC apps — they're powerful the way a cockpit is powerful. You can do almost anything if you can find it. The problem is that finding it takes you out of playing music.
Hardware doesn't have this problem. A loop pedal has a footswitch and a knob. An SP-404 has pads and a few buttons. You learn the instrument in twenty minutes and then you never think about the interface again because there is no interface. There's just the thing. The constraint is the point — what you can't do is exactly what keeps the instrument from getting in the way of the music.
Audio Object is an attempt to bring that constraint to a phone.
A Cube You Can Hold
The entire UI is six faces of a cube. One face per instrument surface: four record/play pads, a loop editor, a click track with time signatures, a project browser, I/O routing, master volume. That's it. No menus. No tabs. No settings screen tucked behind a gear icon.
Navigation is one gesture. You grab the wood grain at the edge of the screen and pull. The body rotates. Both faces — the one you're leaving and the one you're arriving at — are visible during the transition, like turning a real object in your hands. Where your finger started determines which adjacent face comes into view.
This means the information architecture is the topology. The perform pads share an edge with the loop editor because you need the loop editor right after recording. The click track shares an edge with the perform pads because you set your tempo before you play. Workflow adjacency is physical adjacency. If two faces are next to each other on the cube, their functions are next to each other in your workflow.
What Happens When Six Faces Run Out
Six faces is enough for a looper. It's not enough once you add a sampler, a sample editor, and eventually a keyboard.
The obvious solution — more screens — would break the object. The whole premise is that you're holding one thing with a fixed number of sides. So instead of opening screens the way a normal app would, Audio Object reveals them. Pull down from the top edge of the sampler face and the sample editor slides into view from above, the sampler visible underneath it. Pinch and it seals shut. The screen you opened didn't replace anything. It's still attached to the face, like a drawer that slides out of one side of the cube.
Three navigation verbs, total. Rotate to move between faces. Split to pull open a panel. Seal to close it. Every interaction in the app is one of those three things.
The Click Is a Drum Machine
Most looper apps give you a metronome — a sine wave or a wooden tick on every beat. Audio Object synthesizes a three-voice drum kit instead. Kick, snare, hi-hat, generated in Swift with no sample files. The default pattern on a fresh project is a four-on-the-floor kick with a downbeat hi-hat.
This matters because it means pressing play on an empty project gives you a beat, not a click track. You're playing along with a drummer, not a metronome. The step sequencer resolution follows your subdivision setting, so switching from eighth notes to sixteenths doubles your sequencer grid. Time signatures beyond 4/4 work — the kick adapts, the pattern wraps, the downbeat hi-hat stays on one.
The click LED on the perform face presses into the surface when you tap it. A haptic bump fires on touchdown. The pad LEDs blink in time with the beat, and the timing comes from the audio clock, not a display timer, because display timers drift. These are small things. They're the difference between an app that shows you music and an instrument that feels like it's making music.
AI Wrote Most of the Code
This is the part that will either interest you or make you stop reading.
Audio Object was built with AI generating the majority of the code, from sprint plans down to individual functions. That sentence sounds like a gimmick or a shortcut. It was neither. Making it work required building a system on top of the AI — a system that, once it existed, turned out to be the more interesting thing.
The technique is that the code was designed to report on itself.
Every important operation in Audio Object emits a labeled line to the system log — a stable tag with a small typed payload. The tags aren't afterthoughts added during debugging. They're designed before the feature is written, as part of the spec. When something breaks, you don't describe the symptom in prose. You run the app, do the thing that's broken, capture the log, and hand the AI the actual sequence of events with real timestamps and real values.
Here's why this matters: the step where AI hallucinates most aggressively — the natural-language description of the problem — is gone. The AI doesn't read "the MIDI clock seems to drift sometimes." It reads a log showing the scheduler firing at timestamps X, Y, Z, messages departing the phone, and nothing arriving at the Mac. The bug is in the gap between departure and arrival, which means it's in the transport layer, which means the next question is specific: does a CoreMIDI virtual source cross the USB boundary? It doesn't. You need an output port with destinations enumerated. That's a fifteen-minute fix once you know where to look. The log made it a fifteen-minute fix instead of an afternoon of guessing.
The second technique is that tests run against real audio, not synthetic fixtures.
When AI writes both the tests and the code, both can be wrong in the same direction. They share assumptions. The auto-chop detector is a good example: it passed every synthetic test we generated and found one slice out of twenty-two on a real drum break. One out of twenty-two. We fixed it by testing against twenty real breaks with human-annotated slice points — ground truth that neither the code nor the tests had ever seen. Same principle for everything: the test runs the actual production code against inputs the code's author didn't generate.
What Shipped
Four perform pads, each with a waveform that scrolls during playback. Loop editing with trim, snap-to-current-length, and cut-to-next-free-pad. A drum-machine click with a step sequencer whose resolution follows the subdivision, supporting time signatures beyond 4/4. A project browser with tape-label naming and export to WAV stems plus a tempo map. Audio output to any Mac DAW over USB via IDAM. MIDI clock export that locks a DAW's transport to Audio Object's tempo. Stereo input from a USB audio interface. Concurrent multi-pad recording that doesn't stall. A first-launch tour that walks through every face by driving the real UI — not screenshots, the actual running interface. Eight sample pads with grid, auto, and tap chopping, two switchable banks, and a three-band filter.
All of that on one phone, in one app, behind one gesture.
What's Next
A three-mode synthesizer: bass, chord, lead. Subtractive synthesis, six voices for chords, three factory patches per mode. It gets the same face-plus-slide-down-panel treatment as the sampler — the keyboard rises from the bottom edge, the face underneath stays visible.
After that, the body cracks open along a hinge to reveal a second set of pads. Chorus and verse become swappable physical surfaces you flip between while performing. The structure of the song becomes the structure of the object.
That's the bet Audio Object is making: that the right constraint isn't fewer features. It's a physical shape that only has so many sides.
Audio Object on the App Store · greenrosesystems.com/audio-object