Inside Plotly Studio: London Edition

Our Plotly Studio workshop in London was a special night.

We brought together a room full of data practitioners to try something brand new. It’s an entirely AI-native product we’ve been quietly building behind the scenes. It’s called Plotly Studio, and it’s not publicly released yet. We're in an early access period, slowly rolling it out to select customers. The waitlist is a few thousand people long, but we’re also taking it on the road. As part of our worldwide tour, we’re stopping in different cities, running meetups, and giving folks early access to test it out and share feedback.

Why the world needs a specialized AI code generator for data apps

Our product thesis is: constrain the world a little bit more so that we can have high-level quality, high accuracy by default versus some of the other AI coding tools out there like the co-pilots of the world or Claude or Cursor where it's kind of open-ended and AI is sort of enabling you to do more but you really have to steer it in the right direction. We're taking this slightly different approach of "what if we constrain the world a little bit more and accuracy was just good and it kind of just did the right thing by default."

Building in best practices by default

What I've found in using the co-pilots of the world and especially seeing other folks use them is that I can be pretty effective at making a Dash app with it. But I wrote Dash. I know all the weird tips and tricks, all the best practices, how to structure the code, all of this stuff. A lot of that knowledge isn't immediately provided with the LLM unless you ask it to do it. You could tell the LLM "use this best practice," but you have to know that best practice in the first place. You could maybe ask the LLM "tell me 10 best practices and then use them".

This is just visualization, but the whole world of data analytics and data science is full of challenges; performance issues, how to schedule data to run in the background, how to scale from megabytes to gigabytes. It’s a deep well of complexity. So we’re constraining ourselves for now to a few hundred megabyte files and relatively standard apps with a set of filters and six different charts.

A big part of Plotly Studio is helping people do the right thing by default.

Industry parallels and collaboration

We originally started Plotly because the status quo visualization tools weren't sophisticated and advanced enough for us as scientists and engineers. We made these super sophisticated amazing interactive libraries and application frameworks. Now with AI, anyone can actually use this technology, which is kind of amazing and a dream come true for us.

There's interesting trends that we're seeing in other industries like the design industry. Designers traditionally use point-and-click tools like Figma or Sketch to do design work, but then ultimately that work needed to get put into code at the end of the day to get implemented into websites. A lot of data projects similarly include some stakeholders. A product manager or portfolio manager might be working in Excel or drawing things up and then a technical team that complements them to actually implement the work and bring it into production.

In the design world, there's a lot of designers that are starting to use AI coding-based tools to actually create the designs and code themselves. Companies like Figma released AI coding tools to complement their design software so that everybody is working with the same backend.  The designer can work through AI and generate code which they can hand off that code to somebody else, a developer, to take it the last mile.

There might be something similar in data as well where there's a lot of handoff between different folks today — the folks that are the domain experts in the data versus the technical people that can actually work with it. If those two people could be working in the same language itself, then there'd be a lot less friction in that type of handoff. That's where we might see this tool working as well.

With Plotly team members on hand to assist, more than 20 data folks downloaded the software together and built applications live. I started with a quick demo and walked through our guiding principles and the thinking behind the product. Then, we turned things over to the group to explore Studio and build some great apps of their own. Here’s a recap of the entire workshop in case you missed it.

How Plotly is approaching the AI opportunity

I asked our workshop attendees if anyone was familiar with Plotly or Dash libraries. It was great to see almost everybody raise their hands.

Plotly libraries and our application framework, Dash, primarily have a Python interface. We've been building technology at Plotly for over 10 years. We've built a combination of user interface tools as well as Python-based interfaces to our visualization libraries.

Now, one of the things that AI is actually remarkably good at is programming. We found it to be pretty good at Plotly and Dash because our community and customers have developed tens of thousands of sophisticated visualizations and data apps that all of the large language models are trained upon.

What's amazing about Plotly and doing data analysis in Python is that it's totally flexible and customizable. You can automate everything, but of course the challenge is the learning curve in learning how to write Python code. No matter how you cut it, writing 10,000 lines of code, even if you're a really fast typer, takes a long time.

AI is this amazing technology for Plotly and for our customers because they gain faster analytics without having to sacrifice any of the customization and flexibility of our tools. Because all our libraries are Python-based, the resulting apps have infinite customization and flexibility. And now, we have this radically simpler way to generate that code through just natural language.

So can you AI-generate apps without prompting?

We're building out this new product that enables you to generate applications and visualizations with just your data. We're learning a lot in the process about how we can supplant our coding abilities with natural language — the types of high-level specificity that you have in programming, how you can actually express that type of stuff in natural language. We're figuring all of that out as is the rest of the world.

Right now, everything in AI is just a chatbot. We're not even sure if that's going to be the future of user interfaces in AI. We're exploring a lot of different ways of interacting and generating code through alternative interfaces, some of which you'll see across our demos of Plotly Studio.

What you can expect at a Plotly Studio demo

Plotly Studio is a desktop application. We've built it as a desktop instead of a web application so that it runs on your laptop, you can use the processing power available on your laptop, you don't need to pay for additional infrastructure in the cloud, and you can import data that's just locally on your machine.

At our Plotly meetup in London, I demoed how easy Studio is to pick up and run with.

Data upload and context

After uploading a file containing my data, I can provide some additional context and goals. Plotly Studio is going to look through the dataset that I've uploaded to get a sense of the data. This is where our multi-agent system takes over. The first task is to analyze the data to identify its shape, determine appropriate data types, calculate summary statistics, understand its sparsity and other characteristics. All of this is done by an autonomous data profiling agent. The data profiling agent runs in parallel with other specialized semantic, visualization and app component agents.

Application generation process

Via its multi-agent architecture, Plotly Studio builds an outline that describes the Dash application that it's going to generate. Here's that outline based on the dataset that I uploaded.

Code generation and chart customization

While the outline is being created, Studio sets off a bunch of different agents that will run in parallel in their own loops and generate Python code to generate the full Dash application in a really well-organized structure. In the theme file, it specifies all the styling that will end up getting used. In the layout component, we see the Dash application layout that will get generated. The data component loads the CSV file into a dataframe, infers the type of the data, and performs data prep and cleaning based on the column headings and a sample of the data itself.

For the dataset I demoed, Plotly Studio generated a scatter plot of average total payments versus average covered charges as a scatter plot with a dropdown to color classification and a slider to filter by total discharges. This is all powered by a Dash callback.

A new AI coding paradigm with spec-driven development

One of the really interesting things that we're experimenting with Plotly Studio is that we not only supply just the code itself, but we also write out this specification. The specification is a natural language description of all of the things that the code is doing. If you're not familiar with code, but you still want to know what it's doing, you can look through this natural language specification that describes in more detail all of the steps that it's doing in the code.

This new way of interacting moves us away from open-ended chat interfaces and prompts that are common in most AI products. Our approach is opinionated and AI-native. It’s something that could be described as specification-driven development, with domain guardrails yielding a much higher-quality result than generalized AI coding IDEs and coding copilots. 

Alternative UI approaches to chat

The workflow within Studio is one of the alternatives to a chat-based interface that we're exploring with AI. Normally when you're working with just chat, you would just say those things: "Okay, now make it blue. Now title this thing that." You're just continually chatting.

What we found with those types of interfaces is then you have this 2,000 prompt long chat history and you might want to share that with a colleague, but then your colleague doesn't want to scroll through your chat history. If you want to recreate that thing that the AI generated for you, it's actually pretty hard because you've got to go through and have that same chat conversation again and again.

With these different chart outlines, you're filling out more and more of the details about how it works, and then that becomes a little bit more reproducible. Reproducibility is one of the challenges today with AI-based tools. A code-first approach is amazing at reproducibility.

Iterative development process

The idea is we first generate the first draft of the application. Then if you actually have a really good idea of what you want to create, you would go in here and you'd either add new charts to this particular application or remove the ones that you don't like, or you'd go in and edit the prompts themselves.

Building product requirements through iteration

When you build out applications with specification docs, you fill out all the details and then you end up having basically a product requirements document at the very end that completely describes your application. Because it's just text, it's really easy for you to share and you can chat, you can email, you can put it in Confluence or whatever works best for your team’s work style.

If you like what you read and want to learn more, I demoed Plotly Studio with real-life datasets at a webinar — watch now.