Play

Every designer who has handed off a prototype knows it. It looks right, it clicks through, engineering builds it, and the thing that ships feels different. The screens were correct. What was missing was never in the picture.

The two sheets below end at the exact same pixels. Press play on the left and try to grab it while it moves. Then do whatever you like to the right one.

Happy paths are easy to animate. Interaction starts when the user changes their mind: halfway through a gesture, halfway through a settle, before the last one has finished. Nothing should ask them to wait.

Try to break it. Drag the sheet. Release it. Grab it before it settles. Reverse it. Flick it from halfway. The surface answers immediately because running state is still manipulable state.

A timeline knows two things: where it starts and where it ends. A finger brings position, velocity, direction, resistance and the option to stop. Native interfaces are built out of those, and a designer working in screens had no way to touch any of them.

Four surfaces, one variable each. Each one is something Play let a designer decide instead of inherit.

Physics says how something moves. It does not say when, what started it, which state we are in, what happens if a condition is not met, or what comes next. That is the point where Play stopped being a motion problem and became a product-design problem.

An interaction in Play is a trigger, an action, and the state the object ends in. The finger fires the trigger; the action decides the state; the spring decides the route. Drag the sheet and the sentence lights up in the order it happens.

A bottom drawer that feels right is a trigger with two phases, a threshold, a release rule, two states and a spring. A designer who wants a bottom drawer wants a bottom drawer. The engine has to hold all of it; the interface does not have to show all of it.

Good tools do not remove power. They decide when you need to see it. Show the logic and the card opens into its own structure; the choices you made physically travel into their places in the system.

A canvas on a Mac shows layout, hierarchy, type and colour at a comfortable size, under a cursor that is one pixel wide. It cannot show what a thumb can reach, what a finger covers, how fast a flick really is, or how a spring feels when the whole device is in your hand. Play ran the prototype on the phone, with the platform’s own gestures, springs, scroll and haptics.

That is why everything here is something you can touch, not something you watch. On a phone, your device is the device.

Play existed before this cycle and kept going after it. The question for these four months was never how much six people could build. It was which part of the interaction system had to be true first. A design tool could grow in almost any direction, and most of those directions already existed, and existed well, in tools designers were not going to leave.

I worked across product design, interaction design and implementation within Play's six-person product team, focusing on how native mobile behavior could become something designers could author directly.

So the cycle did not widen the product. It deepened one loop in it. Cut the universe down and see what is left.

The audience was professional designers. They clock an easing curve from across the room and have an opinion about scroll inertia. The editor could be beautiful and the product would still fail if the output felt wrong, because the output was the only thing their own users would ever touch.

So craft meant precision, not ornament: the invisible decisions that are only noticed when they are wrong. This is what they would have caught, and what the tool had to get right by default.

The four-month cycle's scope held: import a design, give it behaviour, preview it natively, share it. Wider authoring came after the loop had survived daily use.

After my time the product kept moving in the direction the model implied: prefabs that packaged whole behaviours as one drag, variables and conditions for logic, App Clips so a prototype could be handed to anyone with an iPhone, and export straight into Xcode.

I went in thinking prototyping was about communicating an intended outcome: here is the screen, here is the next screen, here is how it should get there.

I came out thinking about the space between intention and response. While the finger is still down. When the direction changes. When the velocity changes. When someone interrupts the thing they started, or changes their mind halfway through. That is where an interface feels right or wrong, and it is the part a picture cannot hold.

We did not need to make every part of the design process better. We needed to make one missing part meaningfully better, and put it in someone's hand.

Screens were not enough. Timelines were not enough. Behaviour depended on input, state, physics and context, and Play made that something a designer could author, test, and hand to someone else.