How We Built an E-commerce App in 18 Hours Using AI Without a Single Wireframe

In most product design workflows, everything begins with wireframes. Designers usually open Figma, sketch layouts, define user flows, and slowly refine the structure of the product before a single line of code is written. Weeks can go into polishing interactions, visual hierarchy, and micro details before development even starts. That process exists for a reason. It helps teams think through the user journey and avoid costly mistakes later in development.

But for our latest internal project, Zenith, an enterprise-grade admin console, we wanted to try something different. Zenith is an internal admin console designed to help administrators manage e-commerce operations such as orders, payments, and workflows from a single interface. Instead of following the usual design-to-development pipeline, we explored whether we could move directly from product vision to a working interface using AI-assisted software development and structured prompting. This was driven by a member of our UX team who led the entire process end to end. With a strong understanding of both product and technical fundamentals, the work moved forward quickly without relying on traditional handoffs.

The goal was not just speed. We wanted to understand what happens when design thinking, technical understanding, and modern AI tools come together in a tightly integrated workflow. This approach reflects a shift toward more intelligent software development workflows powered by generative AI.

Could we skip parts of the traditional process and still end up with a solid, usable product? Zenith became our way of finding out.

How AI orchestration helped structure the workflow

One of the biggest challenges when working with AI in development is maintaining consistency. AI tools are powerful, but they can also be unpredictable when instructions are not structured clearly. If you simply prompt an AI builder repeatedly, small changes in one area can accidentally break something else. A button might get fixed on one screen while the navigation quietly breaks somewhere else.

To avoid this problem, we adopted a two-tier prompting system. Instead of treating AI as a single assistant doing everything, we separated the workflow into two distinct roles. One focused on maintaining the architecture of the product, while the other focused on executing the instructions needed to build the application.

Role of the architect in AI powered software development

Gemini acted as the architectural brain of the project.

Rather than using it only as a casual assistant, we used it as the place where the core logic and structure of the application lived. Gemini held the overall source of truth for the system. It understood the grid layout, the design language, the product goals, and the expected user behavior across the application.

By centralizing these elements inside Gemini, we created a stable reference point for the entire project. Every instruction generated later in the process could refer back to this foundation. This helped ensure that the product evolved in a consistent direction rather than drifting into disconnected pieces.

Role of the builder in AI assisted software development

AI Studio handled the execution part of the workflow. Instead of writing prompts for code ourselves, we asked Gemini to generate the prompts that AI Studio would run. This added a layer of structure to the process. The instructions given to the builder were not random or written on the spot. They were created with the system architecture and design rules already in mind.

In simple terms, Gemini acted like the architect while AI Studio did the building. Gemini understood the overall structure of the application, and AI Studio focused on implementing the specific parts. This separation helped avoid many common problems in AI-driven development. It reduced the chances of changes breaking other parts of the app and made the process more stable overall.

How generative AI helped build the application faster

Even with the structured prompting system in place, we wanted to push the experiment further. In our usual workflow, we create written product requirements along with visual wireframes. These wireframes act as a blueprint that developers follow while building the interface. For Zenith, we intentionally skipped that step.

Instead of designing screens in Figma, we focused on clearly describing the product. We discussed how administrators would use the tool, what tasks they needed to complete, and what information they should see on each screen. These discussions became the starting point for our conversations with Gemini.

Step by step, we defined the structure of the application through this dialogue. As the discussions continued, Gemini turned those ideas into structured prompts that AI Studio could use to build the app. The process felt different from traditional design work. Instead of designing screens first and thinking about functionality later, we started with the purpose of the product and how users would interact with it. Over time, the interface took shape from those conversations. In the end, the process felt less like designing screens and more like building a system.

Human oversight in AI software engineering workflow

Even with a strong prompting system and a clear product vision, AI-generated workflows are not always perfect. AI tends to rely on default patterns. Those patterns may work technically, but they do not always reflect the most efficient or intuitive experience for real users. This is where human oversight played an important role.

Throughout the process, we constantly evaluated the flows that were being generated. Whenever something felt unnecessarily complex or unintuitive, we stepped in and adjusted the logic guiding the system.

Improving the payment flow

One example was the payment workflow. In its early form, the process involved too many steps. While each step made sense individually, the overall experience felt cumbersome. For an administrator who might need to complete several transactions in a day, those extra clicks would quickly become frustrating.

We reviewed the logic and worked with Gemini to restructure the process. The goal was to remove unnecessary steps while still preserving the accuracy and control required in an enterprise environment. After several iterations, the workflow became far more streamlined and intuitive.

Defining the most efficient user journey

Another important challenge involved designing the core user journey. Enterprise applications often involve more complexity than consumer apps. Creating a B2B order, for example, is not as simple as placing an item in a cart and checking out. There are validations, approvals, and multiple data inputs that need to be handled correctly. Because of this, the goal was not simply to make the interface minimal. It was to make sure users could complete their tasks with the least possible friction.

We reviewed the AI-generated flows carefully and refined them to create what we considered the most efficient path through the application. Every step had to serve a purpose.

Debugging in AI assisted software development

No development process is perfectly smooth, and this project was no different. There were times when screens did not load properly or parts of the interface behaved unexpectedly. Instead of seeing these issues as major setbacks, we treated them as part of the process and worked through them step by step.

One helpful method we used was visual debugging. Whenever something broke in the interface, we took a screenshot of the problem and shared it with Gemini. Since Gemini already understood the structure of the application, it could often identify the issue and suggest a fix. Sometimes we also opened the browser’s Inspect Element console and copied the error messages we found there. Even when the technical details were not fully clear to us, sharing those errors with Gemini helped it understand the issue and suggest the right solution.

Over time, Gemini started acting like a bridge between design ideas and technical fixes. It helped us understand what was going wrong and how to correct it.

Outcome

The most surprising outcome of the project was the speed at which everything came together. What would normally involve weeks or months of back and forth between designers and developers was completed in roughly 18 hours. Since this was driven by a single UX team member as an experiment, the timeline also reflects a learning curve. With a more engineering-heavy setup, this process could be even faster. Most of those hours were not even consecutive. They were spread out between other responsibilities during the week.

Despite the unconventional process, the final result was a fully functional and responsive web application built from scratch. More importantly, the experience gave us a glimpse into how product development may evolve in the coming years. Designers are no longer limited to producing static layouts that are later handed off to developers. With the right tools and workflows, they can take a much more active role in shaping how software is actually built.

At Expeed Software, experiments like Zenith show how AI-assisted software development can reshape the way products are designed and built. By combining structured thinking, strong product design, and modern AI tools, we are constantly looking for better ways to turn ideas into working software faster and more efficiently. Zenith showed us that the real skill is not just designing screens. It is understanding systems, defining clear product logic, and guiding intelligent tools in the right direction. When those elements come together, the gap between idea and implementation becomes much smaller. And sometimes, work that once took months can begin to take shape in hours.