Enjoying this issue?
Get tomorrow's AI & engineering digest in your inbox — hand-picked, summarized, and always spam-free.
TLDR
Connecting Claude Opus 5.5 to Higgsfield lets you go from a single text prompt to a generated product image, a responsive website, and even a short film in one conversation, with plain-language iteration between steps. The practical workflow is more useful than flashy demos: small changes keep the design anchored, cost estimates help you plan, and inspecting the actual output beats trusting the preview. The real takeaway is that the iterative, inspect-each-step approach matters more than any single tool feature.
Key points
Claude Opus 5.5 integrates with Higgsfield via a connector address and account connection.
A single keyboard image was iterated through follow-up requests to change key caps.
The same conversation produced a responsive website with generated product renders.
Cost estimates for media generation changed during the project; the speaker advises monitoring the current quote.
A macaw animation revealed that ASCII-to-video outputs can lose detail when animated.
Tools mentioned
Techniques
- Iterative prompting with plain-language follow-ups
- Splitting generation into plan–estimate–execute stages
- Keeping camera steady in animations to isolate changes
Stop scrolling. Start reading smarter.
Receive the day's most important AI & engineering updates in one concise email. No spam.
Transcript (captions)
This keyboard started with a prompt in Claude. Then I wanted a website around it and eventually a short film. I thought you guys might find the process useful because the interesting part is
how you get from one request to the next. Higsfield is sponsoring this video. I'm using Claude Opus 5.5 with Higsfield connected. We'll go through what I actually sent, the results, and
the things I changed. Then I'll show you a few of Higsfield's bigger creative examples. First, the connection. I opened the Higsfield integrations page, selected Claude, and used the connector
address and Claude setup. That brings up the account connection. This is what gives the conversation access to the Higsfield tools. So, we can request images and video from here. I allowed
access and the connection appeared in Claude. Claude handles the instructions and the website code. Higsfield handles the media generation through those tools. So, when I ask for a product
image, there is an actual generation step behind the answer. Here's my first request going in. I asked for an original compact keyboard, brushed aluminium, ivory key caps, and one muted
amber key. I also specified the camera angle and left some empty space for a website headline. Then I sent it. The the image came back in the conversation. Look at the lighting, the dark
background, and that empty area beside the keyboard. Those choices already give us something we can build a page around. I wasn't asking it to design the entire project at once. Then I changed my mind
about one detail. My original prompt asked for blank key caps, but now I wanted letters and numbers. You can see me enter that follow-up and send it. It's a small request and it keeps the
rest of the design anchored to the image we already have. Here's the updated version. Tiny generated lettering needs a close look, though. Claude mentions that, too. If this were a real product
page, I'd check those details against the actual keyboard before using the image. Now, I asked it to turn that image into a responsive website for a fictional keyboard called Shift01.
strong typography, generous spacing, two finishes, and matching assets from Higsfield. Here's the prompt being sent in the same conversation with the original image still part of the
project. It starts working through the assets and the page. There's also a useful cost correction in this recording. The loop estimate changes and Claude calls that out. That's worth
watching when several generations are involved. Keep an eye on the current quote instead of assuming the first estimate covers everything. Then I open the preview. We have the big product
headline, the finished comparison, and a plan view further down the page. It feels like one concept. The finished comparison lets you see both versions together. Further down, the plan view
gives you a different angle on the same object. Those sections are using the assets we asked it to make. These are the actual files behind it. The raw aluminium finish, the black finish, the
top down view, and the close-up of the accent key. You can keep those separately and reuse them. For a developer, that makes this a more useful starting point than a single flattened
website screenshot. With the website there, I asked for a launch image. I'm sending that request here. I also asked it not to invent testimonials or user numbers because this is a concept and
there's no reason to make those up. In this run, the screenshot didn't come through and Claude said so. It used the pallet and layout from the site we'd already built, plus the product renders.
Here's the graphic it returned. The overall direction carries across, but the tiny key labels still deserve a manual check. Next, I wanted to put the keyboard into a little story. A
developer at a desk hands typing, a close-up of a key press, and a final product shot. I asked Higsfield for the visuals with narration and subtle sound. You can see the full request going into
the chat. Claude worked through the shots and assembled them into a short film. Here are the generated pieces and the finished download. Having separate shots also gives you something specific
to revise if one part doesn't fit. This is the result with its own sound. So, I'll let it play before we move on. >> An unfinished idea, a quiet desk, and one more try. For a developer, this is
where so much of the work happens. Thinking, typing, testing, starting again. I wanted this keyboard to feel like it belonged.
for a quick concept that gives us something to react to. I can look at the framing, the rhythm, and whether the product stays consistent between shots. But now we're discussing an actual film
using the same keyboard idea we started with. Then I tried something completely different, a scarlet macaw. I asked for a still followed by a short clip of the bird opening its wings with a steady
camera. I also asked it to check the available models and estimate the credits before submitting the jobs. The reply breaks the job into two parts. Generate the image, then animate that
image. In my recording, the estimate was 13.25 credits for that pair. That's the quote from this run. The useful habit is asking for the plan and the estimate. While you can still change the request,
here's the still, and here's the short animation made from it. Keeping the camera steady makes the change easy to judge. I can watch the wings and the outline of the bird rather than having a
big camera move distract me. Start with a simple movement and check what actually changes. After that, I asked for an ask key version of the same bird. The idea was to form the picture from
colored text characters on a dark background. This first request was already submitted when the recording starts. Here's the generated still where you can see the bird's shape carried by
the character grid. Then I asked it to animate that version, keeping the camera locked and preserving the characters. Here's that follow-up being entered and sent. It's the same kind of iteration as
the keyboard. Take an existing result. say what should change and be specific about what should stay. And this is where the result gets mixed. It starts with a character pattern, but some of
the feather detail becomes more photographic as it moves. So, I'd use the still more confidently than this animation. That's what I wanted to show you with our tests. The request, the
tool doing the work, and something we can actually inspect. The plain language updates help me follow the job. The downloaded image, page, or clip is still what tells me whether the idea worked.
Now, Higsfield also supplied some examples that take this further. These are their demonstrations. I'll focus on what you can actually see in them because they're useful ideas for where
you might take your own project next. This one starts from a vehicle reference, moves through an exploded view of the parts, and arrives at a much more stylized vehicle. For a developer,
the interesting idea is carrying one reference through several representations. You could use that approach to explain how a product fits together or build a visual concept
around it. I'm looking at this as a creative demonstration. The mechanical labels in a promo aren't engineering validation. These visual effects examples are closer to the question I
had with the Macau. There's a source image or clip, then a visible treatment, characters, particles, or trails. The comparison makes it easy to ask whether the subject is still recognizable. Look
at the horse's movement, and then the eye built out of characters. For your own experiment, choose a source with a strong silhouette and compare the same moment before and after. you'll spot
lost detail much faster. There's also motion design, bold shapes, color, and short animated sequences. What makes this useful as a reference is the timing between elements. When one movement
ends, another gives your eye somewhere to go. If I were adapting that idea for this channel, I'd start with one developer concept and a few clear visual steps, then refine the timing before
adding more decoration. The three-dimensional examples take it into creative software. In Blender, you can see the structure collapse. In the flower example, the visual sits beside a
node-based setup. Those are different ways of building something you can adjust. They also involve the software and its own connections. Connecting the standard Higsfield media tools doesn't
automatically give every chat control of all those applications. And here's a game style project with an editing timeline followed by a visual simulation with agents, paths, and different views
of the scene. There's a lot you could explore here for a coding channel. I'd keep the first version small enough to understand, one interaction, one visible rule, and a result you can test. Then
expand it once that part works. For me, the useful starting point was one keyboard image and one follow-up request. You can try the Higsfield connection through the link in the
description. Pick something small, send the prompt, and inspect what comes back. That's how you find the part worth building