Imagine with Claude: A Guide With Practical Examples

Using the advanced agentic features of Sonnet 4.5, Imagine with Claude combines reasoning, tool use, and multi-step planning to create functional codebases, user interfaces, and even presentations within hours.

How to Access Imagine with Claude?

To use Imagine with Claude, you can navigate straight to the Imagine with Claude page or click the "Want to build from your imagination?" button at the bottom right corner of the usual Claude chat interface.

As of September 30, this feature is only available to Max subscribers for the next five days. So, if you want to try it out, hurry up or wait for its release. However, there's no confirmation from Anthropic that this will become a permanent feature of Claude yet. So far, it is more of an experimental feature to showcase the capabilities of the new Claude Sonnet 4.5 model.

How Does Imagine with Claude Work?

The interface of Claude Imagine is rather simple. We have a prompt input where we can describe what we want to build. It also comes with a few suggestions that we can use if we just want to try it out and are out of ideas.

The rest of the interface consists of just decorative, fun elements; they don't provide any functionality to Imagine with Claude.

Example 1: Building a Good News Feed

To get started, I wanted to try one of the suggestions, so I clicked the first one: "Build a news feed for good news."

Here's an edited video of the build process:

In this example, we see that it builds a feed with good news. The news isn't clickable; we can only see the headline, summary, and a few tags. Apart from that, the only functionality is a button to refresh the feed, which fetches and displays a new batch of good news.

As you may have noticed in the video, the context window is quite small for this research preview.

Note that the app lives only inside the interface and can't be published. We can't see the code either, and if we refresh the page, it's lost forever. So, at this stage, Claude Image is really just a feature to explore the idea of using LLMs to create code that builds itself.

Example 2: Building a Simple Game

For the second example, I wanted to experiment with something a little more interactive, so I asked it to "create a simple dungeon explorer game."

I tried this example three times from scratch, and each time, it ran into the same problem. As soon as I moved the player, it stopped being visible.

Here's a video of the last attempt:

We can see from the video that after I move down for the first time, the player disappears. Afterwards, I tried moving right twice to see if the coin would be collected, and it was. However, all the other coins were also collected at the same time.

After collecting the coins, I prompted it, saying that the player isn't visible and that it should be fixed. However, it didn't work. Everything remained the same. I experienced the same in my other two attempts.

Overall, this example was quite disappointing.

Example 3: Building a CV Manager App

In this third example, I tried building a CV manager app. I used this prompt:

"Create a website to manage my CV. I want to be able to add all my work experience, skills, languages, publications, and any other information relevant to a CV. Then, depending on the job I’m applying for, I want to select a subset of this information to generate a tailored CV."

This example worked well overall, in my opinion. Before going into the details about the creation process, here's a video of the creation process.

The application does the job that was asked for. We can input several different types of information into it and then select which ones we want to include.

I ran into a few bugs, though. First, there was no save button when I added a second skill.

However, a good thing that came out of this example was that I wanted to select a category that didn't exist, and was able to add it dynamically by prompting Claude Imagine.

The second bug was that PDF exporting wasn't working.

Despite these errors, I found this example to work much better than the other. Somehow, at this stage of the process, we have only used 46% of the tokens, which is surprising when we think that the news example used all of the tokens so quickly.

We don't know how Claude Imagine works in the background, but it seems from this example that what we view is generated on the fly from the current context. This is both good and bad, in my opinion. The good part is that it makes it capable of imagining a new view or functionality from scratch, the first time we click a button.

However, it seems that once something is imagined, it's not stored and is imagined again each time. Even the information we entered seems to be generated from the context, which could lead to cases where it hallucinates information we never provided to it.

Lack of imagination?

Another thing I've noticed is that each time I use the same prompt, I get very similar results. For example, I tried the CV manager prompt again, and this is what I got:

This second version has new options on the left; for example, it includes a "Certifications" section. However, the rest is the same, including the information in each section.

Because each session with Clause Imagine is just temporary, it seems more suited to prototyping and experimenting with ideas. However, the fact that it comes up with almost the same idea each time is quite limiting.

Example 4: Building a Personal Website

In the previous examples, I felt the UI was always quite simple, and I wanted to try an example where presentation is more important. For that, I asked it to create a personal website where I can showcase my personal projects.

In this example, Imagine with Claude was more capable and implemented the changes I requested via prompting. In particular, I was able to:

1. Make it possible to select a profile picture.
2. Redesign the UI.

There were also some bugs, for example, when clicking the "View Projects" button, nothing happened despite Claude Imagine acknowledging the button press.

This example ended up being interesting in ways that I hadn't anticipated at first. Because the page is to showcase my apps, there were a few dummy app examples in the content. These had a "View Demo" button, so when clicking it, Claude Imagine had to actually imagine those dummy apps and show them.

For each of them, it came up with a realistic example. This gave me some sort of inception feeling of an app within an app, within an app, all generated on the fly. I found it quite fun to play around with.

This example also confirmed that the code is generated each time. When playing around with the TaskMaster Pro demo, the UI of the tasks changed after clicking the "AI Sort" button, then changed again when I closed and opened the window.

The Limitations of Imagine with Claude

I think the main limitations in the current Imagine with Claude preview are:

1. Lack of imagination. I approached this article thinking that Claude Imagine could be a great tool to brainstorm ideas for a new app. We could generate a few versions and then take the best ideas from each of them. However, I found that similar prompts lead to very similar results.
2. No persistence or way to publish the app. Once we refresh the page, everything is gone.
3. Still quite buggy. It often failed to implement the functionality of a button and implement changes based on a prompt.

The Groundbreaking Idea of Imagine with Claude

What is truly new in Imagine with Claude is the idea of generating code on the fly by determining what a button should do by itself. It could be revolutionary if integrated with a software editor.

The way software is being developed with AI is that LLMs are integrated with the code editor and have the context of the code. Then the developer specifies what they want the AI to change via a text prompt. With Imagine with Claude, we could skip the prompting step. It could be integrated with the editor, and the developer would simply add a button. Then, by clicking it while running the app locally, Imagine with Claude could implement its functionality.

This isn't far off from what the Imagine with Claude demo is showing. The only missing steps are:

1. Having it integrated with an existing code base.
2. Making the changes persistent. Right now, it seems that the functionality is imagined each time, but what we need is for it to be imagined only if it's not yet implemented.

Another way Imagine with Claude could be extremely useful would be to couple with design tools like Figma. In that way, a designer could design the UI by placing the components where they are needed, and then Claude Imagine would run it and implement the functionality behind the UI components.

Conclusion

Imagine with Claude introduces a fascinating new paradigm for AI-assisted software development, one where functionality is implemented dynamically based on the application's context.

This shift away from explicit prompting could represent the future of coding, saving developers an immense amount of time. The current version is more of a playful tech demo than a practical development tool, and it's certainly not a compelling reason to subscribe to the Max plan on its own, especially given its temporary and experimental status.

Despite these shortcomings, I believe in the core concept. This research preview feels like a first step to test the waters of what's possible, and I am genuinely excited to see how Anthropic refines this groundbreaking idea in its next iteration.