Dynamic Interfaces is officially trilogy! Part Un focused on the overall concept of a Dynamic Interface, Part Duex covered end user implications, and in Part Trois we’ll look at implementation considerations to design for Dynamic Interfaces. Before we start, let's acknowledge I'm not going to cover decades of software interaction paradigms in great detail. It's important when looking at future innovations to see who has imagined this in the past. This isn't an academic paper where I am building a thesis. Instead, it's a conversation connecting dots in hopes some of these concepts resognate with you. Perhaps in the future I'll write research paper, but this is writing as conversation. Let's take a look at where software design is headed with Dynamic Interfaces.

Design tools will look more like dev tools

An integrated development environment (IDE) is a software application that provides comprehensive facilities for software development. An IDE normally consists of at least a source-code editor, build automation tools, and a debugger. In the near future, it's going to be the IDDE: Design and Development.

Drawing with code

Designers joke about how they just draw rectangles. I hate it. That’s the problem of how design is perceived. The days of software simply drawing vectors that manually get converted to UI is going away. In place of tools for pure vector drawing, drawing in real-time will affect functionality more like a visual development tool. However, this won't be just for front end but integrated with building, automation, and debugging. Without any inside knowledge, I expect Figma to have some ground-breaking announcements in this space. We'll see in a few weeks. Authoring UIs likely will focus more on what the component should do based on what context it is in. An example of this are CSS Container Queries vs. media queries.

We’ll see drawing software like Figma evolve to more sophistication or be infused in how software is constructed. This isn’t “designers should code”, but you should go deep in the technical systems in order to stay relevant.

Abstraction is a spectrum, not rigid

As someone whose worked on both no-code and code heavy authoring environments, the key is having the capability of navigating the spectrum of abstraction as opposed to being rigid about it. In the First Round Podcast with Melissa Tan, she mentions the "nu uh" moments we coined at a previous company. Introducing concepts too sophisticated when people aren't ready to comprehend it can be detrimental to the adoptiion of your software. On the flip side, if you abstract too much of the power away it caps the magic of your product.

Extensibility and interoperability

Software interoperability has been the dream since the days of Open Doc. However, most enterprise companies aren't incentivized to be interoperable. In fact, being a walled garden is part of the strategy. I see AI tools like Agents and Language Models forcing the walled gardens to either come down or have more access than we're accustomed to. It's like micro-services but for AI. IDEs and software authoring enviroments will need to be extensible to stay competitive.

Considerations on implementation

What would the authoring environment look like for Dynamic Interfaces? Let’s take a look.

Dynamic Interfaces should have control on what’s designable

What the human end user sets and can override is key. We can design what aspects of our software we want to be dynamicly designed. In Xcode and Mac/iOS Development, you can set certain properties to be designable in the GUI. It’s called IBDesignable (IB = Interface Builder). Let’s take this concept and apply it to Dynamic Interfaces. If you have a piece of UI in your app, there might be aspects of it you want to keep static and other areas dynamic. I could see a world when you set it as Dynamic, you can declare what the AI has agency to change on behalf of the human user and what the human user can set and override.

Imagine an app that lets you choose social algorithms. A human user might declare other criteria of what content they prefer to see (and not see) to set parameters for the AI.

Developer-defined abstractions

Before asking, “how do we use Agents?” one must first ask, “Do end users need to know what Agents are? Do they care?” It depends. Collaboration is now tablestakes in modern authoring environments, and with that inevitably comes variable levels of comprehension. There will be some who need to harness the raw code, models, and algorithms while others need templates authoring objects to get their work done. I see a world in the future where there are libraries of abstraction the end user can create for themselves and their teammates. Think of this similar to how a component library in Figma serves people, but for other aspects such as Logic, Data, and Integrations. Great software authoring tools templatize and build guardrails in the right places while allowing complexity for those who need it.

Structured and unstructured prompt criteria

It's time to put the binary argument to rest. If the Land Before Time can teach us that three horns can play with long necks, so can interfaces with chat and direct manipulation. So far, Adobe's Generative AI feature in Photoshop is probably the best example of how to balance direct manipulation with text prompts. I can imagine a world where you can type in a chat interface, "find me an accessibility linter to improve my front end code." it may not have to run the entire command based on your text and present refinement controls, but the generative prompt is what invoked the workflow.

That concludes the Dynamic Interface trilogy! My hope is to refactor this all to an essay and share more concrete samples over time. This is a new space yet built on the foundations of people over the decades of software authoring. What I write is nothing new and I’m not inventing anything. My hope is to connect the dots.

Weekly recap

• My goodness, it was WWDC week and I’m still getting caught up with all the content. I have thoughts on Vision Pro. First and foremost, congrats to all the folks who worked so hard on seeing their work releases to the world (who cares what people say)

• Apple is finally on Figma! Let’s all take a moment to thank Joey Banks for all his work on UI Kits in Figma. This resource helped people’s work so much.

Tweet of the week

Hype links

• Replit AI Manifesto

• We're hosting an event during the week of Config: Replit for Designers

• Incredible WWDC talk: Design with SwiftUI

• Chris Lattner: The Future of Programming and AI - Lex Fridman Episode #381