A Note on AI Experimentation - Interactive Portfolio

The Brief

Claude Fable 5 created quite a bit of buzz recently, so I've been experimenting with it quite extensively. One of the more interesting projects was to build an interactive cyberpunk city portfolio inspired by anime and retro neo-noir.

I gave it access to my local ComfyUI instance, with enough VRAM for image, video, and audio generation models, then let it go wild.

I didn't provide a design system, scene layout, asset list, or specify any technology choices.

Check it out here: neo.sanvirdessai.com ↗

The finished project is called NEO-JOZI. It begins with a boot sequence, drops the visitor from the night sky into a neon street canyon, and lets them move between four main stops: an izakaya for the about section, Signal Alley for skills, an arcade for projects, and an uplink booth for contact details. It also includes hidden data shards, an archive terminal that links to my writing, rain, ambience, animated holograms, and a final vista at the end of the street.

I asked for a cyberpunk portfolio. The agent decided that the portfolio should be a place you travel through.

What Was Built

The result is a Vite application built with Three.js, a custom camera rig, a heads-up display, raycast interactions, content panels, audio, and a small post-processing pipeline.

The city has a clear route, but it's not completely linear. Visitors can scroll or use keys to move, drag to look around, click objects to interact, and fast-travel between the main stations. Six discoverables reward people who decide to explore. None of that is essential to a portfolio, but it gives the site a world beyond the content it needs to display.

This was the first surprise: a high-level visual brief had become a working interaction model. The agent did not just put my name on a cyberpunk background. It created a structure for the content and carried that structure through the project.

The stations have defined positions, labels, and activation ranges. Panels map each location to the relevant portfolio information. The city geometry places specific storefronts at those points. Even the decorative choices follow the same naming and visual language.

I did not direct any of that, but they seem like reasonable choices.

The Art Pipeline

The other interesting part is how it used the ComfyUI access. Rather than generate a handful of generic backgrounds, the agent created an asset manifest with 29 named images. Each has dimensions, a prompt, and a scene role.

There are panoramic skylines, building facades, storefront rows, landmark locations, project posters, and small objects such as a drone, a vending machine, and a holographic koi fish. The manifest also defines a shared style suffix: retro anime, neo-noir cyberpunk, cel shading, night scenes, neon glow, and a teal, cyan, and yellow palette.

More importantly, the prompts are specific to their jobs in the scene. Facade prompts ask for straight-on, flat elevations. Hologram prompts ask for black backgrounds. Storefront prompts use wide compositions. Those constraints let the images work as textures and planes in a 3D scene instead of only as attractive standalone images.

The agent also built a repeatable local workflow around the images. A generation script asks OpenWebUI for ComfyUI renders, stores high-resolution PNGs locally, and retries failed requests. A second script converts the selected renders to WebP for the web. Deleting one source image and running the script again rerolls that asset without recreating the whole set.

I find this more interesting than the images themselves. It's a small but real production pipeline, and running locally means it's cheap and data security isn't an issue.

The Technical Decisions

It would be easy for an agent-built visual project to ignore performance until it becomes unusable. This one did not, at least not entirely.

The agent chose mostly unlit materials, so lighting is baked into the generated art rather than calculated dynamically. Buildings are textured boxes; storefronts and billboards are planes; holograms use additive blending. Rain is a single GPU point cloud that follows the camera rather than a world of individually simulated objects.

It also added a lightweight full-screen pass for grain, scanlines, vignette, and chromatic aberration. These are obvious genre choices, but they also make separately generated images feel more consistent once they share a scene.

Finally, the application measures frame time and lowers its pixel ratio if frame rate drops below 40 FPS. It raises quality again when performance recovers. This isn't a complete performance strategy, but it's a sensible decision for an interactive portfolio that might run on less powerful hardware.

The point is not that every technical decision is perfect. It is that the agent made coherent decisions across visual design, asset generation, interaction, and rendering.

Why This Was Interesting

The most interesting part was not that an agent can write JavaScript or generate an anime-style image. Those capabilities are already familiar. What stood out was the connective work it did from a short brief.

It took a visual direction and turned it into a name, a journey, locations, controls, generated assets, a rendering strategy, and a development workflow. Each part is conventional on its own.

It also changes what a first pass can be. I usually think of a first pass as a wireframe or rough prototype that proves a narrow point. An agent can now produce something closer to a complete creative prototype: not production-ready by default, but developed enough that the next conversation can be about taste, trade-offs, and improvements rather than starting from an empty directory.

Why It Was Not Magic

I do not think this means that a prompt has replaced the work of designing and building software.

The prompt was well suited to this experiment. An anime cyberpunk city has an established visual vocabulary: neon signs, rain, arcades, towers, holograms, and retro interface effects. The result works because those patterns are familiar and because a portfolio can tolerate theatricality. A payroll system, industrial control interface, or complex product workflow would need a very different level of domain knowledge and verification.

There is also a difference between producing a convincing first version and owning a project over time. I still need to understand enough of the code to maintain it, decide what content belongs in it, and judge whether it works for visitors. If I want a change more specific than "make it better," I need to describe the problem and evaluate the response.

I also do not know that every choice the agent made is one I would have made. The site is intentionally dramatic. That suits the experiment, but it could obscure the portfolio content for someone who only wants a fast overview. The generated art is cohesive, yet it leans heavily on familiar cyberpunk references. Neither point makes the project a failure. They are reminders that an agent's ability to make decisions does not make those decisions automatically right.

Final Thoughts

This project is a record of a simple experiment: give an agent a broad creative brief, local image-generation access, and room to execute, then see what it does.

What it produced is more complete than I expected. It created a functioning portfolio, a visual world around it, an asset pipeline, and a set of performance-minded implementation choices without me specifying those pieces individually.

I think that is where this becomes useful. Agents can compress the distance between an idea and something concrete enough to react to. They do not remove the need for taste, accountability, or technical judgment, but they can make those things relevant much earlier in the process.

Disclosure: This article was also AI-generated. Why shouldn't it be?