Designing for Humans in an Age of Instant AI

Earlier this week, I watched two demos back to back.

The first was a model generating text at 17,000 tokens per second. The chat scrolled so fast it felt like watching a stock ticker. Applause in the comments. “This is the path to ubiquitous AI.” Faster, cheaper, everywhere.

The second was quieter: a developer showing a native macOS client for Hacker News, built in SwiftUI. Thoughtful typography. Keyboard shortcuts that felt considered. Animations that respected system conventions. The kind of product that disappears into your day because it fits.

Between those two moments—raw speed and careful craft—was a tension I haven’t been able to shake.

We’re entering an era where generation is instant, but understanding is not. And as designers and product teams, the risk isn’t that we’ll move too slowly. It’s that we’ll let speed itself become the strategy.

The Seduction of Throughput

There’s something undeniably impressive about scale. Seventeen thousand tokens per second is a technical achievement. So is shipping a feature in days that would have taken months just a few years ago.

But I’ve noticed a subtle shift in how we talk about progress. We measure:

Tokens per second
Features per sprint
PRs merged per week
Experiments launched per quarter

Throughput has become the proxy for momentum.

To be clear: speed matters. According to McKinsey, companies that accelerate product development can see up to 30% higher total returns to shareholders. In competitive markets, being late isn’t neutral—it’s costly.

But in design, speed is only virtuous when it compounds learning. Otherwise, it compounds noise.

I’ve worked on teams where AI-assisted development dramatically reduced build time. We could scaffold components, generate test cases, even draft interface copy in minutes. The velocity spike felt exhilarating. But within a few sprints, something else crept in: decisions were happening faster than shared understanding.

We had more output. We did not have more clarity.

When generation becomes trivial, judgment becomes the scarce resource.

The bottleneck has moved. It’s no longer how fast we can make something. It’s how well we can decide what deserves to exist.

That’s a design problem as much as a technical one.

Building to Understand, Not Just to Ship

One of the more interesting threads this week was about an “untapped way to learn a codebase”: build a visualizer.

Not optimize it. Not refactor it. Visualize it.

I love this instinct.

In complex systems, representation changes comprehension. When you turn a sprawling codebase into a visual map—modules, dependencies, hotspots—you’re not just creating a tool. You’re externalizing mental models.

We’ve known this in design systems for years. A well-structured component library isn’t just reusable UI—it’s a shared language. It reduces cognitive load because it makes relationships visible.

There’s research to back this up. Studies in cognitive psychology suggest that visual representations can reduce cognitive load by up to 40% when navigating complex information structures. We don’t think in nested folders and abstract syntax trees. We think in shapes, patterns, and spatial relationships.

And yet, as AI makes code generation easier, we risk building systems no one fully sees.

I’ve reviewed pull requests clearly assisted by AI where the code “worked,” but the underlying architecture was opaque. No one had built a mental map—only a functioning artifact.

That’s the hidden cost of speed: you can ship something you don’t yet understand.

Design has always been about making complexity legible. In this new landscape, that responsibility expands:

Visualize the system, not just the interface.
Map dependencies before they become fragility.
Treat internal tools as first-class design artifacts.

When we build visualizers, dashboards, and system maps, we’re not slowing down innovation. We’re creating the conditions for sustainable speed.

Native by Choice, Not by Default

The SwiftUI Hacker News client struck a different chord.

In a world where we can spin up cross-platform interfaces quickly, someone chose to build natively—for macOS. That means respecting system typography, accessibility settings, keyboard conventions, window behaviors.

It’s easy to dismiss that as nostalgia for platform purity. But I see something deeper: a commitment to context.

According to Apple, over 80% of active macOS users are on the latest major OS version within a year of release. That creates a rare opportunity in software: a stable, evolving platform with strong conventions and predictable user expectations.

Designing natively in that environment isn’t just about performance. It’s about coherence. It’s about meeting users where their muscle memory already lives.

As AI tools make it easier to generate generic UI, we’ll see more “good enough” interfaces. Clean. Functional. Slightly uncanny.

But the difference between a generated interface and a crafted one often lives in details like:

How focus states behave with keyboard navigation
Whether animations respect reduced motion settings
How text reflows at extreme accessibility sizes
Whether system-level gestures feel natural or bolted on

These aren’t flashy features. They’re signals of care.

And care is a form of strategy.

When everything can be built quickly, choosing to align deeply with a platform—or a user’s specific context—is a differentiator. Not because it’s trendy, but because it reduces friction in ways users may never consciously articulate.

As a design lead, I’ve started asking a different question in reviews: Where does this product feel native to someone’s life?

Not just native to a device. Native to a workflow. A habit. A cognitive rhythm.

The Fragility of Trust in High-Velocity Systems

Then there was the PayPal data breach. Six months of exposed user information.

Data breaches aren’t new. In 2023 alone, over 2,800 publicly reported data compromises affected more than 350 million individuals in the U.S., according to the Identity Theft Resource Center.

But each one reinforces a simple truth: trust scales more slowly than features—and collapses much faster.

As products grow more complex and more AI-driven, the surface area for risk expands:

More integrations
More third-party services
More automated processes
More generated code

Every layer adds potential fragility.

I’ve sat in post-incident reviews. The pattern is rarely dramatic villainy. It’s usually incremental oversight. A configuration left exposed. A permission mis-scoped. A dependency not fully understood.

Again, speed isn’t the villain. But velocity without visibility is.

Design often enters the security conversation late—focused on messaging, notifications, damage control. But I believe we have a more foundational role to play.

We design:

Permission flows that clarify scope
Privacy settings that are comprehensible
Feedback loops that make unusual activity visible
Systems that default to restraint rather than exposure

Security is not just an engineering concern. It’s an experience.

When we prioritize seamlessness above all else, we risk designing away the very friction that helps users understand what’s happening with their data.

In an age of instant generation, we need to be just as intentional about intentional friction.

Orchestrating Outcomes in a Specialized World

Another theme surfacing lately is the idea of the product manager as an “orchestrator” in increasingly specialized ecosystems.

I think that framing is useful—but incomplete.

Yes, modern product work involves coordinating:

Machine learning engineers
Platform teams
Security specialists
Designers across multiple surfaces
Data scientists and analysts

But orchestration implies harmony. And harmony requires a shared tempo.

Right now, the tempo is set by what’s technically possible. AI makes it possible to prototype in hours. To generate content at scale. To spin up experiments without deep investment.

The risk is that each specialty optimizes locally:

Engineering for performance
Data for signal
Design for polish
Product for roadmap velocity

Without someone holding the larger question: Are we building understanding along with output?

In my experience, the most effective teams in this moment do three things deliberately:

They slow down at the right moments. Not everywhere. But at key architectural and experience decisions, they insist on shared clarity.
They make systems visible. Through diagrams, design docs, prototypes, and internal tools that externalize complexity.
They define quality beyond shipping. Not just “Did it launch?” but “Do we understand how this works, for us and for users?”

This is less glamorous than chasing the next throughput milestone. It doesn’t produce headlines like “17k tokens per second.”

But it produces products that endure.

Designing for the Pace of Humans

What I keep coming back to is this: human comprehension has not accelerated at the same rate as our tools.

We can generate faster. We can ship faster. We can integrate faster.

But people still:

Need time to form mental models
Build trust gradually
Learn new workflows incrementally
Recover from mistakes emotionally, not just functionally

As designers, our job is to design for the pace of humans, not the pace of machines.

That might mean:

Introducing progressive disclosure rather than exposing every AI capability at once
Providing system maps and explanations alongside powerful automation
Building native-feeling experiences that anchor users in familiar patterns
Designing security and privacy as comprehensible experiences, not buried settings

The question isn’t whether AI will become ubiquitous. It likely will.

The real question is whether ubiquity will feel coherent—or overwhelming.

I’m excited about the tools we have. I use them every day. They’ve made me faster, more exploratory, more ambitious in what I can prototype.

But the craft of design hasn’t become obsolete. If anything, it’s more essential.

Because when everything is instant, the most valuable thing we can offer is not speed. It’s sense.

And sense takes care, context, and the humility to pause—even when the tokens are flying by.