For years, Jupyter Notebook has been the default tool for data analysis in Python.

But it assumes one thing:

👉 you start with code.

What if you didn’t?

I’ve been experimenting with a different workflow.

Instead of writing Python, you describe what you want in plain English — and the system generates and runs the code for you.

The flow becomes:

prompt → LLM-generated code → auto-execution → results

Code is still there.
But it’s no longer the starting point.

Why this might matter

The idea came from a simple observation.

Someone told me:

“I don’t care about the code. I care about the results.”

And honestly, that stuck with me.

As engineers, we often treat code as the main interface.
But for many people, it’s just a tool to get answers.

Old problems... less important?

There has been a lot of criticism of notebooks over the years:

• hidden state
• mixing code and outputs
• hard to review in git

These problems are real.

But I’m starting to wonder if AI changes which of them actually matter.

If:

• code is generated
• execution is automated
• results become the main interface

then some of these issues feel... less central.

New problems appear

Of course, we are not removing complexity — we are shifting it.

New challenges show up:

• trusting LLM-generated code
• debugging when something goes wrong
• less visibility into what is actually happening

In some cases, these might be even harder than the original problems.

A small but important detail

One thing I care about a lot:

👉 everything is still saved as a standard .ipynb file

So you can always:

• open it in a classic notebook
• inspect the code
• edit anything manually

Nothing is locked in.

So what’s really changing?

Maybe the biggest shift is this:

We are moving from:

code → results

to:

intent → results

Code becomes an implementation detail, not the main interface.

Open question

Are we solving notebook problems — or just hiding them behind AI?

I wrote a longer version with screenshots and implementation details here:
👉 https://mljar.com/blog/reimagine-python-notebook-in-ai-era/

I’d love to hear your perspective:

• Would you use a prompt-first notebook?
• Does this make notebooks better — or just different?