An iOS drawing app where the AI coaches instead of critiques.

It remembers what it told you last time and judges whether you acted on it, so the thing being measured is your progress rather than one drawing.

Context
self-initiated
Stack
  • Swift
  • Metal
  • Cloudflare Workers
  • Supabase
Links
  • What it is — an iOS drawing app whose AI coaches instead of critiques, and remembers what it told you last time.
  • My role — everything: design, iOS, backend, infrastructure. One person, six months.
  • Built with — Swift, Metal, Cloudflare Workers, Supabase.
  • Outcome — shipped to TestFlight and approved for external testing, running with a beta group of working artists.

The premise

Most AI feedback on creative work is stateless. You show it a drawing, it tells you what's wrong, and next time you show it a drawing it has no idea it's ever met you. Every session starts over with a very confident stranger.

DrawEvolve remembers. A second critique on the same piece references the first one and evaluates whether you acted on it. What gets measured is your progress across drawings.

The app has an Artist Bill of Rights, and nothing in it generates art on your behalf. It coaches. You draw.

  1. DrawEvolve on an iPad: a finished color portrait of a bearded man in glasses on the canvas, with the AI Feedback panel open over it giving a Quick Take on the head construction, a What's Working list, and a Focus Area on solid head construction and feature alignment

    The critique itself. A Quick Take, then what is working, then one focus area, in that order, because an artist told what is wrong first stops reading.

  2. Eve, DrawEvolve's conversational layer, opened over the critique: the question 'How would I improve this based on the feedback?' answered with a construction pass to run on a new layer, ball plus jaw wedge plus neck cylinder, and a 'Show Eve my canvas' button

    Eve picks the critique up in conversation. Asked how to act on it, she answers with a pass to run on a new layer rather than restating the note in different words.

  3. The same Eve conversation further on, with the canvas attached to the turn and the question 'What is the one part that I should really focus on in here?' answered with a single priority, the eye line wrapping around the head

    The canvas travels with the question. Asked for the one thing worth fixing, the answer is one thing. A critique that returns five priorities has returned none.

  4. DrawEvolve's Composition panel: a top attention region at 59% confidence from an on-device vision model, an intended focal point marked at 55% across and 32% down, and a prompt to ask Eve why the eye goes there

    Composition, as a measurement. An on-device vision model estimates where attention actually lands, and the artist marks where they meant it to.

  5. The attention overlay drawn on the canvas: four numbered dashed regions over the finished portrait showing where the model estimates the eye lands, with the artist's own marked focal point on the near eye

    The estimate drawn back onto the drawing. The distance between where the eye goes and where it was sent is the whole critique, drawn instead of written.

The constraint

I was the entire team. Design, iOS, backend, infrastructure, and every decision in between. That shapes everything downstream: I couldn't afford architecture that required a team to maintain, and I couldn't afford a cost structure that could bankrupt me while I slept.

I also started this not knowing Swift. I learned it in about two weeks and started building.

What I built

A drawing engine, from scratch. Metal tile-based rendering, a wet-ink stroke system, brush suite, layers, selection tools, symmetry, full Apple Pencil support, and portrait/landscape handling.

The renderer went through a multi-phase architectural migration to tiles.

An iterative critique system. Four distinct AI voice presets, and "Eve," a conversational coaching layer that maintains rolling summaries of your conversation history so context survives across sessions without unbounded token growth. Critiques reference prior critiques. A My Evolution dashboard turns critique history into a visible progress record.

Infrastructure that assumes the worst. Every model call routes through a Cloudflare Worker proxy that verifies JWTs, enforces App Attest, applies tiered rate limits, and hard-caps daily spend. Supabase with row-level security behind it. Sign in with Apple and Google via authorization code flow with PKCE.

None of that is glamorous and it is why the product exists. A solo developer shipping an LLM-backed app without a spend ceiling is one abusive script away from a five-figure bill. The ceiling went in before the app went out.

The tradeoff I made

I shipped the tile-based renderer before retrofitting wet-ink onto it. The stroke system is running on architecture it was not written for until I go back and finish that work. I chose the visible progress over the clean sequence, because a renderer nobody can use is a renderer nobody has tested.

It is a real debt. It is named here and it is scheduled.

How I worked

I ran parallel Claude Code agents across git worktrees for most of the build. That was the only way one person covers that much surface area in six months. Each agent held a bounded scope on its own branch, and I did integration and review.

Decomposing work so the agents don't collide is a real skill. It is most of why six months was enough.

Outcome

Shipped to TestFlight. Three builds; the third passed Beta App Review and was approved for external testing.

Running with a beta group of working artists, including a tattoo artist who's been the heaviest user of the critique system.