Magic Leap
Crafting Developer Tools
Role
I was brought in during a critical early phase to help unify Magic Leap’s fragmented developer tools into a coherent system. I focused on understanding how developers moved between Unity, CLI, the Magic Leap headset, and documentation—and how we could reduce that friction through tooling architecture, interaction patterns, and interface strategy.
But more than designing screens, I worked to surface and structure an invisible system. That meant:
→ Mapping the end-to-end lifecycle of a Magic Leap project from first commit to real-world deployment
→ Aligning terminology and expectations across Unity, CLI, and Lumin OS
Identifying leverage points for simplifying complexity through design patterns
→ Proposing modular workflows that respected divergent developer paths while nudging toward best practices
→Representing developer needs in design system governance conversations
The Problem
Before designing anything, I immersed myself in the workflows of real Magic Leap developers. That meant observing how Unity projects were structured, what pain points surfaced during build/debug cycles, and where context-switching disrupted flow.
I created diagrams, mapped tool usage over time, and surfaced insights to the broader team. Key questions we explored included:
- Where do developers get stuck most often?
- What information needs to be surfaced at what moment?
- What gets in the way of experimentation?
The answers shaped our interface architecture and interaction models. We prioritized responsiveness, clarity, and giving developers confidence about what the system was doing and why.
Our principle was simple:
Minimize the number of things a developer needs to hold in their head at once.
Systems Thinking in Practice
This wasn’t a simple UI refresh. Every decision required thinking across time, tools, and intent.
To design a single “Deploy” interaction, I had to consider:
- What environment the user was currently in (local simulation? paired headset?)
- The connection health and trust state of the device
- The version compatibility of runtime, SDK, and project settings
- What logs, confirmations, or fallbacks would reduce uncertainty
Each moment in the tool needed to reflect both state and possibility.
So we built layered flows that scaled with user expertise.
Novices got guardrails.
Experts got shortcuts.
Everyone got clarity.
A look at the configuration layer where developers fine-tune object settings—critical to our goal of minimizing cognitive load
Interface Design & Modular Thinking
I designed around a modular architecture—allowing different parts of the system to evolve independently without breaking core workflows. Rather than build one monolithic interface, we focused on reusable layouts and semantic patterns that made the environment feel consistent, even when functionality varied.
Inspector panels, console outputs, file trees, build queues—each was treated as a component with behavioral logic tied to developer expectations.
We worked to reduce cognitive overhead by collapsing or staging complexity until it was necessary. Where Unity conventions existed, we matched them; where they didn’t, we invented deliberately.
At this level, design isn’t about delight, it’s about removing drag from an ecosystem.
Visual Artifacts
The screenshots below reflect the fully evolved product but are closely tied to patterns and flows I helped shape early in the project. Where applicable, I've noted the areas I contributed to.
Note: Visuals reflect later-stage development of The Lab and are used here to contextualize my foundational design contributions.
CLI Integration & Logs
Helped refine the package manager UI to make installation status and device setup more intuitive.
Device Bridge + Status System
Contributed to early IA models and design patterns for persistent device state, pairing flows, and recovery tools.
Launch Activities
Helped define the hierarchy and logic behind task surfacing and contextual tool access.
Multitask Navigation & Layout
Collaborated on interaction models for switching between panels and layered tools without losing orientation.
Outcomes
Our work brought new clarity to one of Magic Leap’s most opaque workflows. By visualizing complexity, aligning expectations, and reducing redundant effort, we helped make the act of building spatial computing applications more fluid and less brittle.