Design Community: Osman Gunes Cizmeci

10 UX Moments That Defined 2025

Osman Gunes Cizmeci — Wed, 10 Dec 2025 22:34:39 +0000

Looking back at 2025, it’s clear that this was one of the most transformative years UX has seen in a decade. Not because of a single trend, but because so many shifts converged at once. Here are the moments that, for me, defined the year and set the stage for where UX is headed in 2026.

AI Design Assistants Became Everyday Tools

What once felt like novelty became infrastructure. Designers stopped “trying out” generative UI tools and started relying on them for ideation, drafts, and pattern exploration.

Adaptive UX Broke Into the Mainstream

Interfaces began learning from users in real time. Some worked beautifully, others caused confusion. Either way, adaptation became part of the UX vocabulary.

Personalization Hit Its Trust Limit

Users enjoyed recommendations, until they didn’t. Products that over-personalized without explanation exposed a new trust gap designers must solve.

Conversational UI Surged

More design teams began using natural language prompts to generate screens and styles. This shifted design from pixel placement to intent definition.

Accessibility Tools Leveled Up

Automated checkers became far more robust, analyzing patterns, motion, reading complexity, and contrast in ways that saved hours of manual review.

Design Systems Started Thinking

AI-enhanced systems tracking component usage and inconsistencies changed how teams maintain quality across platforms.

The Return of Emotion in UX

Minimalism lost momentum. Motion typography, subtle animations, and warm visual cues returned as users increasingly sought interfaces that “feel” like something.

Ethics Became a Product Feature

Explainability, fairness, and privacy moved from checklists to selling points. Users began choosing tools based on how respectfully they handled data.

The Hybrid Designer Emerged

With AI automating production tasks, designers leaned further into strategy, writing, systems thinking, and research. The role widened rather than shrank.

The Definition of “User” Changed

We no longer only design for humans interacting with interfaces. We design for humans collaborating with agents. That shift will echo for years.

Looking Ahead

If 2025 felt like a turning point, it’s because it was. The industry matured fast, sometimes uncomfortably, but in ways that set the foundation for a more thoughtful, adaptive, human-centered future.

2026 won’t be about catching up to AI. It will be about teaching AI how to design with us rather than for us.

Generative UI Tools Are Changing My Workflow — and My Expectations

Osman Gunes Cizmeci — Thu, 09 Oct 2025 20:29:27 +0000

When generative AI first showed up in my design tools, I treated it like a novelty. Type a few prompts, get a layout. It felt interesting, but not practical. Then, gradually, the tools started to improve — faster rendering, better component logic, even context-aware color systems.

Now I find myself using them almost every day, not as replacements for my work but as accelerators. And I’m starting to see both the promise and the limits of this new generation of “Generative UI” tools.

Where They Shine

The obvious strength is speed. Generative UI makes it possible to jump from a rough idea to a testable prototype in minutes. If I’m exploring a new product concept, I can describe a few screens, watch the tool auto-populate layouts and typography, and then adjust the details manually.

That means I can iterate more. Instead of designing one or two versions because of time pressure, I can explore five or six directions and learn from all of them. In that sense, GenUI encourages creative diversity — it gives me more room to experiment without the usual production bottlenecks.

These tools are also surprisingly useful in team settings. During design critiques or product syncs, I can generate a variation on the fly, test a hypothesis in real time, and see how stakeholders respond. It makes feedback more dynamic. People stop arguing about abstractions and start reacting to something tangible.

Where They Struggle

But the gaps are real. Most generative systems still lack a sense of nuance. They understand structure — grids, cards, spacing — but not emotion. They can copy a style guide, but they don’t yet understand tone.

Accessibility is another weak spot. The designs they produce often look clean but fail accessibility audits. Low-contrast color choices, small touch targets, missing alt text — all things that might pass visual inspection but fail real-world usability.

In my experience, the more polished the output, the more likely it hides these subtle issues. That’s why I think of generative tools as draft partners, not finishers. They can take me 70 percent of the way there, but the remaining 30 percent — the part that involves empathy, readability, and intent — still requires human judgment.

Integrating AI Into the Workflow

The best use of generative UI, for me, has been as a conversation starter. I use it heavily in the ideation and exploration stages, where quantity matters more than perfection. Once I have direction and purpose, I shift back to manual tools for refinement.

I’ve also found that clear prompting makes or breaks the process. Instead of saying “generate a mobile profile page,” I’ll say “generate a mobile profile page with high contrast, simple navigation, and a visual hierarchy that highlights the avatar and recent activity.” The more context I give, the more useful the output becomes.

And when working with teams, I like to use GenUI outputs as a bridge between designers and developers. A generated draft communicates intention faster than a static wireframe because it shows how components might actually behave. It doesn’t replace design systems; it sits between them — a sandbox for exploration.

What Still Matters Most

What all this experimentation has taught me is that good design judgment doesn’t scale. No matter how advanced these systems become, someone still has to decide whether an interaction feels respectful, whether motion distracts or delights, whether a tone of voice feels human.

I think that’s where designers add irreplaceable value. Generative UI handles speed, but designers handle sense.

So yes, these tools have changed how I work — but not what I value. The more I collaborate with AI, the more I realize that what makes design meaningful isn’t efficiency. It’s the part of the process that no algorithm can fully capture: understanding what people need, and shaping technology that feels right for them.

Why Value-Sensitive Design Is My North Star Now

Osman Gunes Cizmeci — Tue, 30 Sep 2025 21:53:01 +0000

I didn’t always talk explicitly about values in my design process. Early in my career, I treated ethics, inclusion, privacy — all of that — as constraints or “nice to haves” you layered in at the end. Over time, though, I’ve come to believe they must be foundational. In fact, I now see value-sensitive design (VSD) as a kind of compass that keeps me anchored in what really matters: creating technology that respects people.

What is value-sensitive design?
At its core, VSD is a design methodology that integrates human values systematically throughout the design process. It encourages you to ask: Which values are at stake? Who are the stakeholders? How might design decisions privilege or harm them?

Because values are rarely obvious or universal, VSD is inherently multi-layered. It asks us to iterate between conceptual investigations (what do users care about?), empirical investigations (how do users behave, feel, or push back?), and technical investigation (how can our systems support or thwart values) — all in a loop.

Why It’s Urgent in 2025

We’re at a moment where interfaces, AI systems, and immersive platforms are so pervasive that the stakes of design decisions feel existential. As technology progresses, the hidden value trade-offs are becoming more visible.

Opaque AI influence — Interfaces personalize so deeply now that decisions are sometimes invisible to users. When the logic is opaque, how do users trust or contest those decisions?

Data & privacy flux — Our designs often require data to function, but more and more users are wary of what’s collected, how it’s used, and who owns it.

Diverse contexts of use — A “one size fits all” design is more dangerous than ever. What feels seamless in one culture or environment might feel invasive or alien in another.

In a sense, VSD feels like a necessary antidote to the “build fast, iterate later” culture. If we skip value thinking early, we end up retrofitting or, worse, inflicting harm.

How I Use Value-Sensitive Design in My Work

I’ve adapted VSD to fit my own process. Here are a few practices I’ve integrated (and refined, sometimes painfully):

Value Mapping Before Wireframes

Before sketching anything, I explicitly map values in tension — transparency vs. simplicity, convenience vs. consent, efficiency vs. reflection. I sketch “value maps” that visualize how design decisions might push users one way or another.

This map becomes my north star during design reviews. Whenever a team member suggests a shortcut, I ask: “Which side of our value map does this lean toward?”

Stakeholder Interviews + Value Probes

Beyond standard user interviews, I introduce probes (surveys, scenario exercises, conceptual cards) to surface hidden values. I ask: What makes you feel in control? What feels invasive? The answers often surprise me.

These probes help me see values users care about — sometimes more than features themselves.

Value Testing

In usability tests, I don’t just ask “Can you complete this task?” I also ask: Did you feel respected? Did anything feel manipulative? Would you change permissions or opt out of any part of this flow?

I compare versions of flows not just on efficiency, but on how they score in terms of trust, clarity, and comfort.

Technical Support for Values

Design decisions should be paired with technical mechanisms that enforce or protect values. If consent is a value, I might bake in revocable data access or visible toggles rather than hidden defaults. If inclusivity is a value, I ensure extensible typography scales, alt text is robust, and motion is curtailed.

Iteration & Reflection

Values shift. Contexts evolve. What felt like a good balance six months ago might feel off today (e.g., in light of news about algorithmic bias or data breaches). I revisit value maps and audits regularly — not just when features get added.

What I’ve Learned (Good & Hard)

Over time, VSD has transformed how I see what “good design” means — but it hasn't been easy. Here are a few lessons I’ve gathered:

Trade-offs are unavoidable. You often can’t maximize all values simultaneously. The trick is to make trade-offs visible and defensible, not hidden.

Not everyone cares equally. Some stakeholders — product leads, business teams — may prioritize growth or engagement over values like privacy. Those tensions have to be surfaced and negotiated.

It can slow you down (if you let it). My early VSD efforts felt like friction. But I’ve learned to embed value thinking in smaller iterations, so it doesn’t block progress but guides it.

You need allies. VSD is easier when you have engineers, product managers, and leadership who are aligned on value principles. If design is the only voice raising these questions, you’ll feel friction.

Looking Forward

I believe that in the next few years, we’ll start to see value-aware AI, UX 3.0, and design ecosystems that aren’t just reactive to data, but proactive in upholding values. (As some researchers suggest, UX is evolving from “user-centered” to “human-AI-centered” frameworks.)

My hope is that design education, tooling, and team cultures shift so designers don’t have to be lone moral agents — value thinking becomes a shared foundation.

In the end, I design with VSD not because it looks “ethical” in marketing pamphlets, but because I want to build systems I can live with. When technology powers our lives so intimately, our values can’t live at the margins — they must live in the infrastructure.

How AI Is Changing the Way I Prototype

Osman Gunes Cizmeci — Tue, 02 Sep 2025 22:37:03 +0000

When I think back to my first design job, prototyping was the part of the process that consumed most of my nights and weekends. I’d spend hours moving boxes around in Figma, tweaking flows, and stitching together clickable paths just to show how a single feature might behave.

Now, with AI entering the toolkit, that work looks completely different.

From Blank Canvas to Starting Point

AI isn’t replacing design, but it is replacing the blank page. Instead of staring at an empty frame, I can describe the flow I’m imagining — “a mobile checkout with three steps and an upsell modal” — and within seconds I get a working draft.

That draft isn’t perfect. But it gives me a head start. It’s easier to edit something that exists than to invent it from scratch, and that saves me time I can spend refining interaction details or testing variations with users.

The Judgment Layer

What AI can’t do — and probably won’t for a long time — is apply judgment. I’ve seen it spit out checkout flows that are technically “functional” but completely ignore accessibility, or recommendation screens that feel more like manipulative traps than user-centered guidance.

That’s where I come in. My job isn’t to rubber-stamp whatever the algorithm gives me. My job is to ask: Does this respect the user? Is it consistent with the brand? Does it actually solve the problem?

AI speeds up the “what if” stage. But I’m still responsible for the “should we?”

More Room for Exploration

One of the unexpected benefits of AI prototyping is that it encourages more exploration. Before, I might only mock up two or three variations because of time pressure. Now I can generate ten, keep the two that feel promising, and discard the rest.

This abundance means I can test more hypotheses earlier. It makes the design process less precious, more playful. Failure costs less — and that makes me bolder.

Collaboration in Real Time

Another shift is how AI is changing collaboration. Instead of waiting days for me to prepare a polished prototype, I can generate a draft in a meeting and invite feedback right away.

That immediacy helps stakeholders feel like co-creators, not just reviewers. It also shifts the conversation: we’re not debating whether my prototype is “finished” enough, we’re discussing the idea itself.

Where I Draw the Line

Still, I’m careful about how far I let AI into the process. When it comes to fine-tuning motion, writing microcopy, or designing error states, I want human intentionality. Those moments are where users feel whether a product respects them or not.

I don’t want to outsource that responsibility.

Looking Ahead

I don’t think AI is the future of prototyping. I think it’s the future of starting. It’s the fast-forward button that gets me to the interesting parts sooner.

But the craft — the empathy, the judgment, the care — that’s still on us. And honestly, I wouldn’t want it any other way.

The Death of Static Onboarding: Living Tutorials for Ever-Changing Products

Osman Gunes Cizmeci — Mon, 11 Aug 2025 21:47:36 +0000

I was onboarding a new team member to our design tools last week when I realized how broken our traditional approach has become. The tutorial screenshots were outdated within months, the workflow had changed twice since we recorded the walkthrough video, and half the features we were explaining had been redesigned or moved to different locations.

This isn't unique to our team. Every product I use regularly feels like it's constantly shifting. Figma's interface evolves monthly. Notion adds new features that change fundamental workflows. Even Gmail's layout seems different every time I look away for too long.

Static onboarding made sense when software shipped annually and stayed consistent for predictable periods. Now we're designing for products that change weekly, features that adapt based on user behavior, and interfaces that personalize themselves in real time.

The Stale Tutorial Problem

Traditional onboarding assumes a stable product that new users can learn once and understand permanently. We create carefully crafted tutorials, record polished demo videos, and write step-by-step guides that become obsolete before users finish reading them.

I've lost count of how many times I've followed tutorial instructions only to discover that buttons have moved, menus have been reorganized, or entire workflows have been replaced. The disconnect between onboarding content and actual product experience creates immediate frustration for new users who assume they're doing something wrong.

Research shows that activation rates increase by 47% when onboarding flows include progress indicators and clear completion feedback. But what happens when the features being explained in your progress flow no longer exist in the same form?

Maintaining static onboarding content requires constant manual updates that most teams struggle to prioritize. Documentation becomes a debt that accumulates faster than teams can service it. Meanwhile, users encounter broken onboarding experiences that undermine their confidence in the product from day one.

Adaptive Onboarding Patterns

The most successful modern onboarding experiences respond to current product state rather than assuming static functionality. Notion's onboarding adapts based on which features are currently available and how they're configured for specific workspaces.

Contextual tutorials appear when users encounter new features rather than frontloading all education into initial signup flows. Slack introduces channel features when users create their first channel, threading explanations when someone posts their first reply, and advanced formatting when users start typing markdown.

This just-in-time approach reduces cognitive overhead while ensuring relevance. Users learn features when they need them rather than trying to remember explanations from weeks earlier that may no longer apply to current product functionality.

Progressive disclosure works particularly well for products with deep feature sets. Rather than overwhelming new users with comprehensive capability tours, adaptive onboarding introduces complexity gradually as users demonstrate readiness for advanced functionality.

The Personalization Layer

AI-powered onboarding can customize educational content based on user role, experience level, and demonstrated needs. A developer joining a design tool needs different guidance than a product manager, even though they're using the same software.

Behavioral adaptation helps onboarding systems understand when users struggle with particular concepts or workflows. Rather than assuming everyone learns at the same pace, smart tutorials can provide additional support for users who need it while accelerating past basics for experienced users.

However, personalized onboarding creates new challenges around consistency and troubleshooting. When every user experiences different educational content, it becomes difficult to provide support or ensure everyone understands core functionality.

The key lies in personalizing presentation while maintaining consistent core concepts. Users might see different examples or interface elements, but they should understand the same fundamental principles regardless of their customized learning path.

Living Documentation

The most promising approaches treat onboarding as living documentation that evolves alongside the product. Rather than creating static tutorials, teams build educational systems that automatically update when product functionality changes.

Interactive guides that reference actual interface elements can detect when those elements move or change, updating their instructions accordingly. This requires closer integration between documentation systems and product development, but it prevents the constant drift between explanation and reality.

Smart tooltips and contextual help can appear based on current interface state rather than assumed product configuration. Users see relevant guidance for the features actually available to them rather than generic instructions that may not apply to their specific setup.

Version-aware onboarding acknowledges that different users might be experiencing different product versions and adjusts educational content accordingly. This becomes particularly important for products with gradual rollouts or A/B tested features.

The Continuous Learning Model

Modern onboarding needs to assume that learning is ongoing rather than a one-time event. Users need support systems that help them adapt to product changes over time, not just initial feature discovery.

Change notifications can highlight new functionality or modified workflows for existing users. Rather than leaving people to discover changes accidentally, proactive communication helps users understand how updates affect their established patterns.

Skill progression systems help users understand their mastery level and discover advanced capabilities when they're ready. Figma's component system is complex enough that most users never explore advanced features, but contextual suggestions can guide users toward more sophisticated workflows when appropriate.

Community-driven learning leverages user expertise to supplement official documentation. When products change rapidly, experienced users often develop workarounds and insights faster than official support channels can document them.

Technical Implementation

Building adaptive onboarding requires infrastructure that traditional tutorial systems don't provide. Educational content needs to query current product state, user permissions, and feature availability to present relevant guidance.

API-driven documentation allows onboarding systems to verify that interface elements exist before referencing them in tutorials. This prevents the broken experience of instructions that point to nonexistent buttons or missing menu items.

Content management systems for educational material need versioning capabilities that match product development cycles. When features launch, educational content should deploy simultaneously rather than lagging behind product changes.

Analytics become crucial for understanding when onboarding breaks down due to product changes. Teams need visibility into where users get stuck, which tutorials become obsolete, and how product modifications affect learning success rates.

Looking Ahead

The future belongs to onboarding systems that assume constant change rather than fighting against it. Products will continue evolving faster, personalization will make user experiences more diverse, and static tutorials will become increasingly inadequate.

Success requires treating user education as a product capability rather than a content creation challenge. The most effective onboarding experiences will be those that learn and adapt alongside the products they're teaching.

We're moving toward a world where products teach themselves, where tutorials evolve automatically, and where user education becomes as dynamic as the software it's explaining. The teams that build these adaptive learning systems will have users who feel confident and capable despite constant product evolution.

The death of static onboarding isn't a loss—it's an opportunity to create educational experiences that actually match the reality of modern software development.