How Layers closed the gap between design and engineering with Slate

The challenge

Layers spends its days helping other companies stay consistent. Internally, that was the one thing the team struggled to do.

Design worked in its own tools. Engineering worked in another. Product kept its plans somewhere else again. Each team was excellent on its own, but the space between them was where things quietly went wrong.

A component would be marked ready in design, then sit untouched for a week because engineering never saw the handoff. Specs drifted out of date the moment they were written. By the time a build shipped, it had often wandered a few degrees away from what was originally designed.

Our whole product is about keeping teams consistent, and yet internally our design and engineering work lived in completely different places.

Devin Asher - Head of Design Engineering, Layers

None of it was dramatic. It was just steady, low-level drift, the kind that adds up across a quarter and leaves everyone slightly out of sync without quite knowing why.

Why Slate

Layers moved to Slate to put design, engineering, and product into a single workspace, and to close the gaps the team kept falling into.

Slate was the first workspace that felt designed, not assembled. It matched the standard we hold ourselves to.

That mattered more than it might sound. A team this particular about craft was never going to adopt a tool that felt clumsy to use. Slate earned its way in by being calm, considered, and quietly powerful, which is exactly how Layers thinks about its own product.

The migration was quick. The team brought existing work in through the Slate API, connected their repositories, and had design specs sitting next to the engineering issues that depended on them by the end of the first week.

How they use it

Every initiative at Layers now lives in one place, with design and engineering finally working from the same surface.

Design specs are written directly in Slate, attached to the issues that will turn them into code. When something in a spec changes, the engineers building it see the change in context rather than discovering it three steps too late.

Atlas does a lot of the quiet work of keeping people aligned. Each morning it surfaces what moved overnight, what is waiting on a decision, and which handoffs are ready to pick up.

Atlas tells us what moved overnight before we even open a project, so design and engineering start the day on the same page.

Reviews happen inside the workspace too. Instead of scattering feedback across comments in five different tools, the team runs design and code reviews in one ordered place, with the full history of a decision attached to the work it shaped.

What changed

The first thing the team noticed was that the gap simply closed.

The gap between a design being ready and engineering picking it up basically vanished.

Work stopped stalling in the space between teams, because there was no longer a space for it to stall in. A finished design flowed straight into engineering with its context intact, and nothing waited around for someone to notice it.

Specs stayed current, since they lived next to the work instead of in a document that slowly went stale. And the small inconsistencies that used to creep in between design and shipped code became rare, because everyone was building from the same source.

The result

A year on, Layers runs on Slate, and the company feels noticeably more like the product it sells.

Releases go out faster because design and engineering move as one motion rather than two. Reviews that once dragged across days now resolve in hours. And the team spends far less energy chasing alignment, which means more of its attention goes where it should, into the craft of the work itself.

Slate made our own company feel as consistent as the systems we help other teams build.

For a company whose entire purpose is keeping teams in sync, running on Slate was less a change of tools than a way of finally living up to its own idea.