Build your own apps

That's it. Build your own apps. For yourself. For a need. For fun. Just build your own apps. Install Claude Code and describe your idea, cover the functionality, the interactions, the look and feel, and if you have design assets or copy hand them over so they can shape the output. Even a quick sketch on a napkin can point the LLM in the right direction.

The apps can be just for you. Give your agent a cheap VPS and have it set up a sideloading platform so you can skip Testflight. Let it send you a link for each new signed build, or push straight to your phone when you're on the same network.

These are 3 I built this summer: Phosphene, Datamosh and Linescan.

Phosphene

A phosphene is the light you see with your eyes closed, an image with nothing behind it. Phosphene takes a photo, turns it into words, and paints the words back into a picture.

flowchart TD
    A[Shutter] -->|photo| B[GPT-6 Luna describes]
    B -->|description| C[GPT-6 Sol writes a poem]
    C -->|poem| D[GPT Image 2.5 Sunburst paints]
    D --> E[Roll]
    E -.->|I pick it| F[This site]

Only the first model ever sees the photo. The poet gets the description, and the painter gets only the poem. Anything that drops out along the way stays out.

Short ripples lift sharp flecks of light across the blue lake. Dark water shows between them.

The poem kept the ripples and the light, and dropped the far shore and its pines. The painter had only those three lines to go on, and it gave the lake a mountain range.

The first version in June ran entirely on the phone using local models. It worked, but the poems got purple fast (pines that refuse, clouds that forget, a road in "white panic"). The current version is plainer, and the final images are better for it.

Here's the same photo through the June engine:

The wind shatters the noon into a million flashing coins. At the rim, the dark pines refuse the bribe. High up, a single scrap of cloud forgets what it came to spill.

Datamosh

Datamoshing is the glitch you get when video compression breaks. A video codec saves space by sending only what changed between frames. The codec describes most of a frame as blocks of the last frame moving around, and sends only new content as fresh pixels. Drop that new content and the decoder keeps pushing old pixels along with the motion. Things smear, melt, and drag pieces of the last frame with them.

Datamosh fakes a broken decoder live in the viewfinder. You compose the mosh onscreen, and the shutter saves about 3 seconds of it, a second and a half on each side of the tap, as a Live Photo.

flowchart TD
    A[Camera] --> B[Find block motion]
    B --> C[Broken decoder]
    C --> D[Viewfinder]
    C --> E[Last few seconds]
    E -->|shutter| F[Live Photo]
    F --> G[Roll]
    G -.->|I pick it| H[This site]

There are 4 Looks, each based on a classic datamoshing trick. Mosh drops new content, so the old picture gets dragged along. Trails keeps broken blocks broken for a few frames, so they streak. Bloom repeats one frame's motion, and you can hold the viewfinder to bloom in any Look. Drift averages the motion over time, so the whole picture slides. You can re-run any Look on a shot afterward, so you're never stuck with the one you picked.

Linescan

Line-scan cameras are a fun bit of imaging history. They've been used for everything from horse racing to aerial reconnaissance. A normal camera grabs the whole frame at once, but a line-scan camera grabs one line at a time and builds the picture as it goes. Linescan does that with the iPhone camera at 60, 120 or 240 frames a second, and it has two modes, Sweep and Strip.

flowchart TD
    A[Camera] --> B{Mode}
    B -->|Sweep| C[Band behind the line]
    B -->|Strip| D[Center slit]
    C --> E[Picture]
    D --> E
    E --> F[Roll]
    F -.->|I pick it| G[This site]

In Sweep, a line crosses the frame over 2 to 16 seconds. Everything behind it freezes, and everything ahead stays live, so anything moving while the line passes bends or repeats.

In Strip, a thin slit in the center records 1 line per frame, like a photo-finish camera at a race. One direction of the picture is time. Things crossing the slit get drawn, and anything still smears into a streak. At 120 lines a second, a strip can run a little over 2 minutes before it hits the phone's size limit.

The frame rate is the resolution along time. At 240 frames a second, every second of motion gets 240 lines, four times as many as at 60, so the same movement comes out four times as wide. The catch is light. The camera can't expose a frame for longer than the frame lasts, so at 240 each line gets at most 1/240 of a second, and indoors the phone makes up for it with gain.

My pen plotter is a good test subject. It repeats the same moves, and it sits under indoor light. Here it is at 60, 120 and 240 frames a second.

At 60 the plotter is a compact block and the pen's stroke reads as one arc. At 240 the same moves stretch into a long ribbon with a fine zigzag running through it.

Outside in full sun, 1/240 of a second is plenty of light. This is my kids running past the slit at 240 frames a second. They come out sharp, the still background turns into stripes, and their shadows curve away behind them.

The shared libraries

All three apps use one Swift package with two parts, CameraKit and FarfieldKit. A fix in the package lands in every app at once. Datamosh's screens became the template for the other two, and Linescan's Review screen became the shared one.

flowchart TD
    A[Datamosh] --> K[CameraKit]
    B[Linescan] --> K
    C[Phosphene] --> K
    A --> F[FarfieldKit]
    B --> F
    C --> F
    F -->|JPEG and series| S[This site]

CameraKit has everything except the effect: the camera controls, the Roll, the Review screen for paging through shots, and Settings. Each app brings its own engine and its own accent color.

Orientation was the hardest part to get right, so it lives in CameraKit too. The viewfinder is locked like the Camera app's. Turning the phone only changes how the saved photo is tagged, so a landscape shot comes out landscape and the preview never spins.

FarfieldKit handles publishing. Each app has its own series on this site. When I publish a shot, FarfieldKit converts it to a JPEG, uploads it, and rebuilds the series from the app's own records. It deletes an upload only after no shot in the app uses it. Publishing is always manual. I pick what I like from the Roll, and it shows up here.