Nothing Ships Until One File Says So

Here's how design usually gets handed to engineers. A designer finishes a screen in Figma, writes some notes, gives it to an engineer. Then they spend the next two weeks answering small questions: how much space here, what happens if this is slow to load, what does this look like when it's empty. Most of that time isn't real thinking, it's just two people turning the same idea into two different formats and hoping they match.

I decided we should stop doing that part by hand.

"Code made from a design should be something engineers can just use, not a picture they have to guess at and rebuild."

The system I built takes one screen from Figma and makes three things automatically: a working demo you can click through the same day, real code using our actual design pieces, and a checklist of everything an engineer needs. The engineer doesn't start from a picture anymore. They start from working code, already written the way they build things.

• 01Wrote clear, saved instructions for the AI to follow, not a one-time request. One folder, one owner.
• 02Tested it on real screens, starting with Askk's onboarding, about twelve times, until it worked every time.
• 03Got it right about 85% of the time on the first try. It keeps getting better with each new screen we run through it.

Keeping one version matters as much as the output does. Nobody on the team changes the instructions themselves. If someone finds a tricky case it doesn't handle, they tell me, I fix the master copy, and everyone gets the update at once. Small rule, but it's the difference between one shared standard and seventeen people quietly using seventeen slightly different versions without knowing it.

I rolled this out to the whole design team with a real, step by step guide, not just an announcement. Install this tool. Turn on this setting in Figma. Use a strong AI model, not the cheapest one, because a weaker model skips the rules. Download the current instructions, put them in the right folder, read the short guide, try it on one screen first. A little setup, in exchange for skipping what used to be a whole back and forth conversation between design and engineering.

"Don't change the instructions yourself. Bring me the tricky case. I'll fix it once, for everyone, and share the update."

This isn't finished. Getting it right 85% of the time on the first try means 15% of every screen still needs a person to fix it, and that's just an average, some screens are harder than others. It also depends on the AI model staying good, which isn't something I control. What I do control is the part that holds it all together: one set of instructions, one person in charge of them, one version everyone uses instead of seventeen people quietly drifting apart.

That's the real leadership work here, not the AI part. Anyone with Figma and a bit of setup can turn a screen into code. What's harder is making sure the whole team follows the same rules, that those rules get better over time instead of splitting into different versions, and that someone is responsible when it goes wrong. That's a people and process problem before it's a tools problem, and it's the part you don't notice if you only look at the output.