Gemini 3 models into Google AI Studio, I’ve been experimenting with it quite a bit.

In fact, I find the concept of generative UI surprisingly useful for data scientists to streamline day-to-day work.

In this post, I’ll share four concrete ways (with video demos!) of how you can leverage this tool (or other similar tools) to:

• **Learn **new concepts faster,
• **Build **interactive prototypes for stakeholder exploration,
• **Communicate **complex ideas more clearly,
• **Boost **your productivity with personalized tools.

Let’s dive in.

In case you haven’t tried it yet: Google AI Studio is Google’s browser-based workspace for building apps with their Gemini models. It offers a “Build mode“, where you get to “vibe code” an entire, functioning web app in a short time. All you need to do is simply describe your idea in plain language, and the Gemini 3 Pro model will work behind the scenes to generate the code, show you a live preview, and let you iterate by chatting with Gemini or annotating the UI.

Disclosure: I have no affiliation with Google. This article is based entirely on my personal use with Google AI Studio and reflects my independent observations as a data scientist. The ideas and use cases presented here are platform-agnostic and can be implemented using other similar generative UI tool.

---

1. Learn New Concepts Faster

We often learn data science concepts by understanding equations written in textbooks/papers, or by running code snippets line by line. Now, with Google AI Studio, why not build an interactive learning tool and gain insight directly from interaction?

Imagine you read about a machine learning method called Gaussian Processes (GP). You find the uncertainty quantification capability it naturally offers is pretty cool. Now, you are thinking of using it for your current project.

However, GP is quite mathematically heavy, and all the discussions on kernels, priors, and posteriors are not that easy to grasp intuitively. Sure, you can watch a few YouTube lectures, or maybe work through some static code examples. But none of those really click for me.

Let’s try something different this time.

Figure 1. The starting prompt for our first demo app. (Image by author)

Let’s switch on the Build mode and describe what we want to understand in plain English:

“Create an interactive Gaussian Processes visualizer so that the user can intuitively understand the key concepts of Gaussian Process.“

After some minutes, we had a working app called “GauPro Visualizer”. And this is how it looks:

Gaussian Processes interactive app demo

With this app, you can click to add data points and see in real time how the Gaussian Processes model fits the data. Additionally, you can pick a different kernel function and move the sliders for the kernel length scale and signal/noise variances to intuitively understand how those model parameters determine the overall model shape. What’s nice is that it also adds a toggle for showing posterior samples and updates the “What is happening” card accordingly for a detailed explanation.

All of that becomes available with just a one-line prompt.

So what does this mean?

It basically means now, you have the power to transform any abstract complex concept you’re trying to learn into an interactive playground. As a result, instead of passively consuming explanations, you build a tool that lets you explore the concept directly. And if you need a refresh, you can always pull the app up and play with it.

---

2. Build Interactive Prototypes for Stakeholder Exploration

We’ve all been there: You have built a model that performs perfectly in your Jupyter Notebook. Now the stakeholders want to try it. They want to throw their data at it and see what happens. Traditionally, you’d need to dedicate some time to building a Streamlit or Dash app. But with AI Studio, you can bridge that gap in a much shorter time.

Imagine you want to train a logistic regression model to classify Iris species (setosa/versicolor/virginica). For this fast demo, you’ll train it directly in the app. The model takes sepal and petal dimensions and calculates class probabilities. You also configure an LLM to generate a plain-English explanation of the prediction.

Now, you want to integrate this logic into a tiny app so that your stakeholders can use it. Let’s build that, starting with this prompt:

Build a web app that trains a Logistic Regression model on the Iris dataset. Allow the user to either upload a CSV of new data OR manually enter the dimensions. The app should display the predicted class and the probability confidence, as well as a LLM-generated explanation of the prediction.

Within a few minutes, we had a working app called “IrisLogic AI”. And this is how it looks:

Classifier with LLM explanation

This app has a clean interface that allows non-technical users to start exploring immediately. The left panel has two tabs, i.e., Manual and Upload, so users can choose their preferred input method. For manual entry, as the user adjusts the input fields, the prediction gets updated in real time.

Below that, we have the model prediction section that shows the classification result with the full probability breakdown across all three species. And right there at the bottom is the “Explain with AI” button that generates the natural language explanations to help stakeholders better understand the prediction.

Although the prompt didn’t explicitly ask for it, the app decides to provide a live dataset visualization, which is a scatter plot of the entire Iris dataset, together with the prediction of the input sample (highlighted in yellow). This way, stakeholders can see exactly where it sits relative to the training data.

Just on the practical note: for our toy example, it’s totally fine that the app trains and predicts in the browser. But there are more options out there. For example, once you have a working prototype, you can export the source code as a ZIP to edit locally, push it to GitHub for further development, or directly deploy the app on Google Cloud as a Cloud Run Service. This way, the app will be accessible via a public URL.

Ok, so why does this matter in practice?

It matters because now you can ship the experience of your model to stakeholders far earlier, and allow stakeholders to give you better feedback without waiting for you.

---

3. Communicate Complex Ideas More Clearly

As data scientists, we are often tasked with the challenge of presenting our sophisticated analysis and the uncovered insights to non-technical people. They are mainly outcome-driven but don’t necessarily follow the math.

Traditionally, we’d build some slide decks, simplify the math, add some charts, and hope they get it.

Unfortunately, that’s usually a long shot.

The issue isn’t the content, it’s the medium. We’re trying to explain dynamic, coupled, multi-dimensional analysis with flat, 2D screenshots. That’s just fundamentally a mismatch.

Take sensor redundancy analysis as an example. Let’s say you have analyzed sensor data from a complex machine and identified which ones are highly correlated. If you just present this finding with a standard correlation heatmap in the slide, the grid will be overwhelming, and the audience will have a hard time seeing the pattern you intended to show.

So, how can we turn this around?

We can build a dynamic network graph to let them see the insights. Here is the prompt I used:

Create an interactive force-directed network graph showing correlations between 20 industrial sensors. – Nodes are sensors (colored by type: temperature, pressure, vibration) – Links show correlations above 0.8 (thicker = stronger correlation) – Allow dragging nodes – Hovering over a node highlights its connections and dims the rest – Use mock data with realistic correlations

Here is the outcome:

Sensor network visualization

During the presentation, you can simply launch this app and let the audience intuitively see which sensors are available, how they are correlated, and how they define distinct clusters.

You can also grab a specific node, like the temperature sensor S-12, and drag it. The audience would see that the other sensors, like S-8 and S-13, are getting pulled along with it. This is much more intuitive to show the correlation, and easily facilitates reasoning on the physical grounds.

So what does this mean?

It means you can now easily bring your storytelling to the next level. By crafting the interactive narratives, the stakeholders are no longer passive recipients; they become active participants in the story you’re telling. This time, they’ll actually get it.

---

4. Boost Your Productivity with Personalized Tools

So far, we’ve talked about building apps for learning, for stakeholders, and for presentations. But you can also build tools just for yourself!

As data scientists, we all have those moments where we think, “I wish I had a tool that could just…” but then we never build it because it would take quite some time to code up properly, and we’ve got actual analysis to do.

The good news is, that calculation has largely changed. Let me show you one concrete example.

Initial exploratory data analysis (EDA) is one of the most time-consuming parts of any data science project. You get handed a new dataset, and you need to understand what you’re working with. It’s necessary work, but it’s just so tedious and easy to miss things.

How about we build ourselves a data profiling assistant that tailors to our needs?

Here’s the prompt I used:

Build a data profiling app that accepts CSV uploads and provides at least: – Basic statistics – Visualizations – LLM-powered analysis that supports EDA Provide a mock dataset that can show the full functionality of the app.

Here’s what I got:

Data profiling assistant with LLM insights

Now, I can upload a dataset, not only get the standard statistical summaries and charts, but also some natural language insights generated by the LLM. What’s nice about it is that I can also ask follow-up questions on the dataset to get a more detailed understanding.

If I like, I can further customize it to generate specific visual analyses and focus the LLM on specific aspects of data insights, or even throw in some preliminary domain knowledge to make sense of the data. All I need to do is keep iterating in the Build assistant chatbox.

So what does this mean?

It means you can build custom helpers tailored to exactly what you need, without the overhead that usually stops you from doing it. I think these tools aren’t just nice-to-haves. They can really help you eliminate friction from your own workflow and those small efficiency boosts that add up quickly, so that you can focus on the actual work. Since the tools are custom-built to match how you think and work, there’s almost zero learning curve and zero adaptation time.

Bonus: Reality Check

Feeling inspired to try the tool yourself? That’s great. But before you start building, let’s have a quick reality check so we stay grounded.

The first thing you need to keep in mind is that these demos only show what’s possible, not what’s production-ready. The generated UI can look professional and work nicely in “preview”, but it typically optimizes only the happy path. If you are serious about pushing your work to production, it’s often your responsibility to consider the implementation of error handling, edge case coverage, observability, deployment infrastructure, long-term maintainability, etc. At the end of the day, that’s expected. Build mode is just a prototyping tool, not a replacement for proper software engineering. And you should treat it like that.

Another piece of advice is to watch for hidden assumptions. Vibe-coded applications can hard-code some logic that might seem reasonable, but doesn’t match your actual requirements. Also, it may introduce dependencies you wouldn’t otherwise choose (e.g., licensing constraints, security implications, etc.). The best way to prevent those surprises from happening is to carefully examine the code generated by the model. The LLMs have already done the heavy-lifting; you should at least verify if everything goes according to your intention.

Finally, be mindful of what you paste into prompts or upload to the AI Studio Workspace. Your proprietary data and code are not automatically protected. You can use the tool to quickly build a frontend or prototype an idea, but once you decide to go further, it’s better to bring the code back into your team’s normal development workflow and continue in a compliant environment.

The bottom line is, the concept of generative UI enabled by the Google AI Studio is powerful for data scientists, but don’t use it blindly and don’t skip the engineering work when it’s time to move to production.

Happy building!