Developer console

Yoco, the South African payments company, needed a Developer Console where external developers could create integrations, generate API credentials and control access. In credential management, the interface has to make the system itself clear.

I defined that structure first in a conceptual model, instead of discovering it through rounds of mockups. Claude made it cheap to prototype and revise. Seven working days later, I delivered the Figma design, working prototype, build instructions and a corrected model — work I would previously have quoted at four weeks.

Credential management punishes a wrong mental model. Misunderstand how a key is replaced and you can break your own integration.

So I started with Johnson & Henderson’s conceptual model framework: the objects developers believe exist, what they can do, how they relate, and the language around them. Applications, keys, permissions, environments — the structure before the screens.

Objects Structure States Language

That moved the back-and-forth out of mockups and into words, where changing your mind costs a sentence. The model designed what to design; the prototype tested it.

One prompt, 70% there

The first test was deliberately blunt. I gave Claude the conceptual model and asked for two screens: the applications list and an application detail. Nothing else. I wanted to see how much the document could carry on its own.

About 70% came back as I wanted it. The rest was detail.

That says more about the framework than the tool. The model already described the objects, attributes, actions, relationships and states the interface needed. There was little left to infer.

Four weeks was my estimate, not a measured baseline. What changed was where the back-and-forth happened.

The prototype changed about twenty-five times, mostly through small edits I could review one by one. Many came from engineers commenting directly in Notion while the work was still moving.

That was part of the speed. When feedback could become a change the same day, it stayed cheap to listen. The prototype wasn’t something to defend; it was something to keep correcting.

Cards to table

The first prototype used cards for the application list. Reasonable default, wrong audience.

Developers weren’t browsing; they were scanning for one integration and one fact. So I changed it to a table. It took under a minute. That’s the useful bit about AI prototypes.

The point isn’t that tables are better. It’s that when changing direction costs almost nothing, sunk cost stops making the decision for you.

Cards Table

Claude built an error for the one-key rule: if a key already existed, it explained why you couldn’t create another. But the model already ruled out a second key — narrating the rule was the wrong fix. We removed the action instead.

Narrated Enforced

Then an engineer reviewing the prototype in Notion caught something worse: a complete “all keys expired” state that couldn’t happen.

Claude had built a coherent interface around a false assumption, then defended it using its own prototype as evidence. We corrected the model and mapped which states were actually reachable. The prototype wasn’t just implementing the model; it was testing it.

Production got cheap. Deciding what to produce didn’t.

A dark theme is the clearest example. Once the decisions were made, a second version of every screen cost about as much as asking for it.

Light Dark

Claude could turn decisions into screens, list states and translate the prototype into specs. But scope, priority and constraints still came from me and the engineers.

Instead of spending most of the time designing screens, I could spend it designing what to design. Johnson & Henderson’s title suddenly felt very literal: Conceptual Models — Core to the Design of Interactive Applications.

Once the model was clear, the screens were the easy part.

The console launched in December 2025; these numbers are from August 2026. We still haven’t promoted it — no campaign, no push. Everyone who arrived came looking for it.

Many aren’t developers by trade. They’re merchants building their own tools — a stock system, a kitchen display, something that only has to work in one shop. They come with a business problem, not an API. The model described what a developer has; it didn’t describe what a merchant is trying to build.

The method worked well enough that I later turned it into Conceptual Kit with Filipe Baeta, a long-time friend and tech virtuoso at Lab Secreto.

The framework still frames the thinking, but AI makes the model much faster to create, review and update — and turns those concepts into working prototypes just as quickly.

If you want to try the method, you can use my Claude skill.

Next project