As designers, we’ve long dreamed of tools that could transform our visions directly into working products. With the rise of AI, that dream is becoming a reality—but not quite in the way we expected.

The Challenge: Making AI Accessible

Large language models (LLMs) are everywhere these days, and for creatives, they open up so many possibilities. But most AI tools seem tailored for engineers, not designers. When I discovered Ollama, a tool for running LLM models locally, I saw an opportunity. Here was powerful technology that offered privacy and speed, but like many AI tools, it lacked an intuitive interface.

Looking through the available front-ends listed on Ollama’s GitHub page, I found them either too basic or requiring technical expertise to set up.

Wouldn’t it be great to have a simple, well-designed front end? Something intuitive, something that works out of the box?

With that in mind I started to imagine what an Ollama client UI could look like. I opened Figma and quickly sketched some basic UI.

But there was one major problem— I could only design, but didn’t know how to code.

The Experiment: Using AI to Build an AI Client

Armed with design skills but limited coding knowledge, I embarked on an unconventional journey: using AI to help build an AI application. My tool of choice was Cursor, an AI-powered coding assistant.

Learning to Dance with AI

The initial results were — awkwardly speaking — both inspiring and disappointing.

Watching code automatically generate and update with just a few prompts was mind-blowing. But in the meantime, dropping a well-designed UI screenshot into Cursor and expecting perfect code was like asking a stranger to read your mind. There were incorrect UI implementations, buttons that didn’t respond, layouts that collapsed unexpectedly, broken functions, and endless errors when trying to build the app.

That’s when the process had to change. Instead of approaching it from a developer’s perspective, why not lean into a designer’s way of thinking—visual, iterative, and exploratory?

A Designer’s Approach to AI Collaboration

I started over by giving Cursor a clear brief of the overall concept, encouraged it to ask clarifying questions about the product requirements. As we refined the details, we documented our conclusions in a README file to track our goals and progress. The initial prompt looks like this:

I want to write an Ollama Mac app, named OllaMind. It should be able to detect whether Ollama is running, list out the models installed, have a chat interface similar with ChatGPT. with a collapsable conversation history sidebar, user can rename and export each conversation as JSON format. I have attached the UI mockup, let’s plan how to code this app, please ask me questions to clarify requirement, and document them into a readme file once we are clear. Don’t start anything yet before we confirm the requirement

and this is how the readme looks like after a few rounds of Q&A.

It became clear that AI wasn’t just a tool that magically spits out solutions—it needed to be guided. The way questions were asked changed everything.

• Start with clear product requirements and encourage AI to ask clarifying questions
• Document conclusions and progress in a structured way (the README file became our shared understanding)
• Frame questions to invite analysis rather than demanding solutions
• Instead of “Fix this” it helped to ask, “What’s going wrong here, how can I help you to debug?”
• Instead of “Write this UI for me,” better results came from asking, “Here’s my UI—what’s missing in my implementation?”

Debugging became a conversation rather than a command. Logs were added based on AI suggestions, and insights were gained along the way. The magic started to happen when I switched mind to ask AI to “help me to help you.”

Breaking Away from Linear Design

The traditional design-then-develop workflow evolved into something more fluid:

• Quick mockups in Figma to establish direction
• Rapid prototyping with AI-assisted coding
• Screenshot problematic areas for redesign
• Iterate between design and implementation

This non-linear process led to faster iterations and better results. The key was maintaining a dialogue with AI—helping it understand not just what we wanted to build, but also why.

While AI can dramatically accelerate development, some technical foundation is still valuable. Understanding basic UI styling (in my case, SwiftUI) helped streamline the process significantly. Sometimes it’s simply more efficient to manually adjust a few lines of code rather than trying to get AI to understand all your intentions.

Thoughts for Future

This was more than just building an app—the experience reshaped how digital products could be designed and implemented. A few years ago, I thought the next thing to replace Figma would be something that converts designs directly to code. But through this experience, I realized that spending too much time in design tools like Figma isn’t necessarily the best way to design an app. While I did start with a quick mockup, the product interface evolved through several iterations as we added more features—some directly suggested by AI. We didn’t always follow the traditional design-then-code approach; sometimes we’d start by coding, take screenshots, return to Figma (or even MS Paint) to tweak elements, then have AI update the code. For behaviors and interactions, the key was maintaining a dialogue with AI to help it to help you achieve what you really want.

So if you ask me what will replace Figma, I’d say probably not another design tool. It’s more likely to be a new coding product design tool like Cursor, and I believe we’ll see many more alternatives emerging in the market very soon.

Up next

This journey is just beginning. With OllaMind successfully running, I’m already planning my next challenge: creating a user-friendly Stable Diffusion application. The goal remains the same—making powerful technology accessible to everyone, regardless of their technical background.