The Box Design System: AI-Ready Figma Files for Enterprise Software
About the Authors:
Garik Avetisyan, Davit Gabrielyan, and Anastasia Saroka are co-founders of Flexy Global, a design and development partner for startups and global enterprises. Garik built and successfully exited a consumer app used by millions. Davit brings 15 years of experience leading complex projects and operations at international companies including Orange (France Telecom) and Coca-Cola Hellenic. Anastasia, Design Director at Flexy Global, brings experience designing products for large corporations and startups in the fitness industry. Together, they explore how better design systems and development practices can help teams build complex technology more clearly and efficiently.
On a recent enterprise software project, we were working with a Figma file that needed to support both traditional developer handoff and AI-assisted development. One section alone contained dozens of screens documenting a single part of the product.
Each screen made sense on its own. The difficulty was understanding how they belonged together.
For the designers and developers who had worked on the project for months, much of that context was already familiar. We knew which screens represented the starting point, what action caused each change, which states were alternatives, and which details were still under discussion.
A coding agent coming to the file had none of that background. An individual screen did not provide enough context to explain the complete behavior, while the full canvas introduced too much unrelated information. We needed a way to organize the relevant frames, states, and decisions around a single interaction so they could be understood and used more effectively in AI-assisted development. That need became the basis of our Box Design System.
What is the Box Design System?
The Box Design System is our method for organizing complex product behavior into bounded sections of the Figma canvas. Each box contains the screens, states, transitions, annotations, and implementation context needed to understand one part of the product. This makes the file easier for people to navigate while also preparing its structure for AI-assisted development.
In the enterprise platform we were designing, navigation alone included several connected behaviors. Users could interact with a floating bar, select assets, explore the map directly, or move through a hierarchy. All of these actions occurred within the same broader interface, but they did not belong to the same flows.
Placing every screen in one large sequence would have made the file look complete while leaving its logic ambiguous. Instead, we grouped related states into separate boxes such as “Floating Bar,” “Select Assets,” “Direct Map Exploration,” and “Hierarchy.” Each box represented one coherent part of the experience.
At first, this was a way to make a complicated canvas easier for people to navigate. As AI agents became part of the development workflow, the boxes gained another purpose: they created clearer units of context for implementation.
Here are four principles that shaped the system.
1. Organize boxes around behavior, not pages
A page is a visual container. It is not always a useful development boundary.
One page may contain several independent interactions. A single interaction may also extend across panels, overlays, menus, and several screen states.
In our project, selecting an asset and exploring the map took place within the same primary interface. Visually, the screens shared most of their structure. Functionally, however, they represented different behaviors.
Treating them as one group would require a developer or agent to determine which changes belonged to asset selection and which belonged to map exploration. That distinction was obvious to the team because we had discussed it repeatedly. It was not necessarily visible in the pixels.
We therefore organized the boxes as a hierarchy rather than treating every box as an equal unit. The system has three levels:
- Feature boxes represent a complete product capability, such as Navigation.
- Flow boxes sit inside the feature box and separate interactions such as “Select Assets” and “Direct Map Exploration.”
- Screen-state boxes sit inside each flow and name the specific action or state shown on every screen.
This structure allows someone to move from the broader feature to an individual flow and then to the exact screen behavior without losing the relationship between them. It also means that an implementation task can be scoped around the behavior the team needs to build, rather than every element visible on the page.
2. Make each box understandable on its own
A useful box should not require a guided tour from the designer who created it.
Someone opening the file should be able to understand what the interaction does, where it begins, and what changes as the user moves through it.
That does not mean duplicating every piece of product documentation inside Figma. It means including enough context to remove the most consequential ambiguity.
Depending on the feature, a box may contain:
- The default or entry state
- The action available to the user
- The resulting state
- Expanded and collapsed variations
- Selected, disabled, empty, loading, or error states
- Short notes explaining behavior that cannot be understood visually
- References to existing components or patterns
This self-contained structure matters for human teams, especially when people join a project late or return to a feature after several weeks. It matters even more for coding agents.
An agent does not have the memory of the workshop where the interaction was discussed. It does not know which Slack message changed the requirement or which visual difference was intentional. It can only work with the context it is given.
If critical information sits somewhere else on the canvas, remains buried in a comment thread, or exists only in the team’s memory, the agent must infer what is missing.
And inference is where avoidable mistakes begin.
3. Make interactions and transitions visible
Individual screens show different interface states, but they do not always explain how the user moves between them.
In our design files, we use simple arrows to connect an interaction with the screen or state it produces. If clicking a button opens a sidebar, we connect that action to the designed sidebar state. If an interaction takes the user to another screen, the arrow shows exactly where they will arrive.
Not every interaction needs this treatment. Adding arrows to simple or obvious actions can create unnecessary visual noise. They become particularly useful when one screen contains several possible interactions, each leading to a different state or part of the flow.
For someone who has worked on the product for months, these relationships may already feel obvious. Developers and AI agents do not necessarily have that context. Without a visible connection, an agent may recognize all the individual screens but still misunderstand which action produces which result.
Combined with the box hierarchy, these connections make both the structure and sequence of the experience easier to follow. The boxes show which screens belong to the same feature and flow, while the arrows explain how users move between them. It is a simple practice, but it reduces how much developers and agents need to infer from the designs.

4. Give the AI agent a bounded unit of context
AI coding tools can now access much more than a screenshot. When connected through tools such as the Figma MCP server, an agent can retrieve structured design information, visual references, variables, components, and layout data from a selected part of a file. However, in AI-assisted development, access to more information does not automatically lead to a better understanding of what needs to be built.
An isolated frame may leave out the surrounding states required to understand a behavior. At the other extreme, a large page or full canvas may introduce unrelated screens, unresolved concepts, and several versions of the same feature. The Box Design System creates a practical middle layer between these two extremes.
Instead of asking an agent to “build this page,” a developer can direct it toward a bounded interaction containing the relevant states, transitions, and supporting context. This gives the agent enough information to understand the intended behavior without requiring it to interpret the entire product.
The boundary of a box does not need to match a single code component. Some boxes may translate into one component, while others may involve several components and application states. The box is there to define the product behavior being implemented, not to dictate the final code architecture.
The quality of the generated code still depends on the codebase, prompts, design-system implementation, and the agent’s access to existing components. Figma also recommends semantic naming, variables, Auto Layout, reusable components, annotations, and Code Connect to improve consistency. The boxes complement this infrastructure by organizing those elements into a coherent piece of product behavior that the agent can understand and act on.

What boxes cannot solve
A clean Figma canvas cannot compensate for an undefined product.
If the team has not decided how an interaction should behave, placing its screens inside a box will not resolve the underlying uncertainty. It may simply make that uncertainty easier to see.
That is still valuable.
When related states are placed together, inconsistencies become more visible. The team may discover two competing versions of the same behavior, an exception with no recovery path, or a state that was discussed but never designed.
Boxes also do not replace the platform’s design system. While the main design file uses boxes to organize screens, flows, and product behavior, the design system lives in a separate Figma file containing the shared components, variants, and variables used across those designs.
The design system does not need to follow a box-design hierarchy, but it should be structured and detailed enough for agents to understand exactly what they need and where to find it in the file. Clear naming, logical grouping, and consistent component structures help both developers and AI agents find and reuse the correct elements. Without that structure and the corresponding code, an agent may understand the intended behavior while still selecting the wrong component or creating unnecessary one-off elements.
The box defines the scope and behavior. The design system defines how the interface should be constructed. The codebase defines how it must function in production.
Why Figma file structure now matters for AI-assisted development
For years, design-file organization was often treated as an internal concern. A tidy file was easier to navigate, easier to hand off, and kinder to the next designer who had to work in it.
That is no longer the full story.
As design files become direct inputs to AI-assisted development, their structure begins to influence what an agent understands, what it overlooks, and how much it must infer.
The canvas is no longer only a place where the team presents the final interface. It is becoming part of the system through which software gets built.
Our box-based approach began with a practical need: make a complicated enterprise product easier to understand. Its value grew when the same structure helped divide that product into clearer units for implementation and review.
The boxes themselves are not the innovation. The clarity they create is.

Components define what the interface is made from. Frames capture individual moments. Boxes explain how those moments belong together and what the team is trying to build.
In a development process increasingly shared with AI agents, that context is no longer optional documentation.
It is part of the product.





























































































