Writing ·

How a design process holds up when agents write the code

I'd never built an app before AI tools. Contrrrol took about three days with Claude Code, and I made it the same way I've designed things my whole career.

I have ten apps on the App Store, and I run all of them through App Store Connect, Apple's website for builds, store pages and releases. Apple also has an API for nearly everything in it. I wanted a native Mac app on top of that API, so I could see where every app stood and change things in one place.

I built it with Claude Code over about three days. It's called Contrrrol.

I started with code

The first version came together in one evening. It was read-only, with a sidebar of apps and versions, each version's screenshots and store text, and a preview of the product page. Customer reviews went in about 40 minutes later.

It worked, but it wasn't what I wanted. Every screen looked a little different from the one before it, and plenty of them looked obviously AI-generated. I was also designing without knowing what App Store Connect would let me do.

An early Contrrrol screen for squiiish showing 4.6 stars from 1,284 ratings, a bar for each star level, and a list of written reviews in English and Japanese.
A first-evening screen, customer reviews, with sample data.

On a normal project I'd figure that out before designing anything, so less than two hours in I stopped and had Claude go through Apple's API documentation to map what was possible. It came back as a table with one row per feature, each linked to Apple's docs. It also made read-only calls against my account to see what data I actually had.

Three things in that map changed the app:

The map also showed that most of my data lived in TestFlight, Apple's beta service, with over a hundred builds across my apps. We built those screens next, and then I stopped adding screens altogether.

Wireframes before code

Before the agents built anything else, we talked through what the app should be, and I had them draw wireframes. These are plain gray layouts with no color or polish.

I didn't want a wireframe for every screen. I wanted one for each kind of screen the app would keep repeating, like a list with details on the side. Get those right and every screen built from them works the same way, which was the problem with the first version.

I also had them use my actual apps instead of placeholder data. At the time sliiime was approved and waiting for me to release it, and Riiiff had been rejected, so the layouts had to handle both. Placeholder data always looks fine, and real data shows where a layout breaks.

By the end of the first night I had 13 wireframes. Each went through three rounds of review, and then I locked them in as the plan to build against.

The first night

The agents built the first set of screens overnight. In the morning there was a note saying the app hadn't been launched yet, and that I should try it before calling anything done. Fair enough. I used it, had one set of agents review it, and had a second set check their findings. Nothing had been fixed yet. The review laid out the problems and left the choices to me.

That same morning the agents drew a second, much bigger round of wireframes covering more of the app.

Two rules

That morning I also gave the agents two rules for the whole app.

The first was that if the API can do something, Contrrrol should too. What I actually typed was "we can upload, edit, change, preview all of everything we do," which isn't elegant but got the point across. Where the API can't do something, the screen says so and links out to App Store Connect.

The second was that edits never go straight to Apple. Changes to text, images and settings collect in a local draft on my Mac, and nothing goes out until I review them and press Publish. Screenshots upload in the background as soon as I add them, so Publish only has to put them in place. There's one exception, which I'll get to.

The Review and Publish sheet for squiiish. Promotional Text goes from empty to a new line about an underwater world and a new garden, a Secondary Category change is held until 1.0 is released, and the button reads Publish 1 Change, 1 Live Now.
Review and Publish shows each change before and after.

Checking the wireframes

Next, a group of agents critiqued the new wireframes, and another agent checked each critique. Most held up: of 71, all but one were at least partly right. That told me which ones to read carefully before acting on them.

I've written two skills for this kind of review. UX Critique checks a screen against a UX knowledge base and gives prioritized feedback on what to change. Tastemaker critiques a screen's craft and taste, and can tell you what to cut before anything is built.

Some wireframes had been drawn before the rules. They saved page by page, and nine buttons still sent changes straight to Apple, including Generate Codes, Start Test and Turn Off Offer Code.

I had to decide which of those could wait for Publish. The critique suggested a split I liked because it was easy to explain. Actions on Apple's side, like starting a test or generating codes, happen right away after a confirmation. Edits go into the draft. Turning off an offer code settled it for me: if a code leaks, I'm not waiting until the rest of my changes are ready to shut it off.

How the build ran

From there the plan got split into phases, twelve by the end, some running side by side. In each phase, a few agents built separate pieces in their own copies of the code, and the agent I was talking to merged them. Then came three checks. One agent read the code without seeing the builders' notes, another compared screenshots to the wireframes, and a third checked both reviews before anything got fixed.

My job was to use what got built and say what was wrong. If the problem was in the design, we redrew the wireframe before touching code. Everything else went into the next round of fixes.

Settings is a good example. It had been built as one long page with 19 rows, which nobody wants to scroll through. I sent it back, we redrew it as a wireframe first, and it became four short tabs: General, API Key, Analytics and Agents.

A wireframe comparing the old one-page Settings window with the four new tabs, plus a before and after table.
The Settings wireframe, with the old 19-row page on the left and the four tabs that replaced it on the right. Key IDs and app names are blanked out.

Letting my agents use the app

On the last day I made Contrrrol usable by my agents too, through an MCP server. That's how tools like Claude Code and Codex plug into other apps.

An agent can read what Contrrrol knows about an app, like the saved store text, the character limits and the languages it supports. It doesn't need its own way to save, because every edit already goes through the draft. If I ask it to write the release notes for an update, they land in the same draft as my own edits. It can't publish, so I still review the before and after and press Publish myself.

The sliiice version page. Promotional Text reads 'MCP live test: new squish modes and faster saving.' and is marked Edited, and a bar at the bottom shows one unpublished change.
Promotional text an agent wrote over MCP during a test, sitting in my draft next to my own edits.

When I started, I didn't know if I could build something like this at all. What surprised me was how little the AI changed the way I work. I still mapped what was possible before designing, drew wireframes before anything got built, and sent screens back when they were wrong. The agents did the building, but every decision was still mine, and that's why it held up.

Shipping to the App Store turned out to be more complicated than I expected, and a lot of it I didn't understand going in. Contrrrol is how I keep track of it now: where each app stands, what's waiting on me and how each one is doing. I think it could help other people who ship apps too, so that's what I'm working on next.

  • Default
  • Clear dark
  • Tinted dark
  • Tinted light
The Contrrrol icon in each of Apple's icon styles.