I recently ran into a very simple problem while working with ChatGPT Images.
I had a finished image containing several distinct elements — an elevator, a cable, planets, lighting effects and a title. I wanted to make one very small change: move only the title slightly to the right.
In a conventional design application, that would be a trivial operation. The title would be an independent object, so its position could simply be changed without affecting anything else.
With generative image editing, however, even a very small requested change can cause other parts of the composition to be reinterpreted or regenerated.
That made me think that the underlying problem may not be image quality at all.
It may be the way the image is represented.
The image is treated primarily as a visual composition, rather than as a structured project containing independently editable elements.
The idea
What if an AI-generated image could retain an underlying editable representation of its visual structure?
For example:
PROJECT
├── Background
├── Planets
├── Elevator
├── Cable
├── Character
├── Lighting
├── Effects
└── Text
Each element could retain properties such as position, scale, rotation, opacity, z-order and masks. Text could remain actual editable text, with its own font, size, spacing and position.
This would create two fundamentally different kinds of editing.
Generative editing
“Make the elevator more futuristic.”
This requires AI.
Deterministic editing
“Move the title 20 px to the right.”
This does not require AI regeneration.
The second operation could simply modify the relevant object’s coordinates and render the existing scene again, leaving everything else unchanged.
In other words:
**AI should handle changes that require intelligence.
The editor should handle changes that only require precision.**
The user should retain control after generation
This is perhaps the most important part of the idea.
The generated result should no longer be something the user can only modify by going back to the AI.
The user could retain control of the composition after generation, independently from the generative process.
They could open the resulting project later and move, resize, hide, rearrange or otherwise adjust individual elements without having to ask the AI to regenerate the image and without needing a separate professional design application just to perform basic compositional changes.
ChatGPT would no longer be just a generator that hands the user a JPG. It could deliver a project that the user can continue to control and edit independently of the AI.
The AI creates the visual concept and structure, but the user remains in control of the composition afterwards.
The AI can step back.
Why this could matter
This could improve consistency across long creative sessions, preserve exact compositions between iterations, make typography genuinely editable and give users direct control over their creations.
There is also a potential energy-efficiency and compute-efficiency benefit.
Regenerating an entire image because a title needs to move a few pixels is fundamentally different from changing the position of an existing object and rerendering the composition. The former requires another generative inference; the latter is essentially a deterministic graphics operation.
A system that understands which requested changes actually require generative AI — and which can be handled by the underlying document structure — could therefore avoid using expensive generative computation for operations that do not need it.
In practical terms:
Creative change → AI inference
Positional / structural change → deterministic rendering
This could reduce unnecessary compute, improve responsiveness and potentially make image-generation workflows more energy efficient at scale.
So the system would not only become more precise. It could also become more computationally efficient by reserving generative inference for tasks that actually require it.
From image to project
This changes the nature of the output.
Instead of:
AI-generated image
the result becomes:
AI-generated, persistent, editable visual project.
The project could preserve its structure across sessions and be reopened days or months later without the user having to reconstruct the context in which it was created.
The workflow becomes:
Prompt → Generate → Structure → Edit → Refine → Export
rather than:
Prompt → Generate → Regenerate → Regenerate → Regenerate
for every subsequent change.
There is an interesting irony here
The industry is already moving in this direction.
Canva’s Magic Layers takes flat and AI-generated images and reconstructs them into editable, multi-layered designs, specifically so users can separate and edit individual elements rather than starting over.
Canva has also moved toward generating editable, layered designs directly.
So there is an interesting product paradox here:
AI systems are generating increasingly sophisticated visual content, while other tools are building systems to take those flat AI outputs and reconstruct them into layers precisely so users can regain control over what the AI created.
There is therefore little reason to think of structured output as a threat to generative AI.
The opportunity is to make that structure native to the image-generation workflow itself.
Instead of generating a flat image and leaving another application to reverse-engineer it afterwards, the system that creates the image could preserve its own structure from the beginning.
The larger product idea
This is not really about “adding layers” in the Photoshop sense.
It is about introducing a distinction between:
Generative state
and
Editable state.
A generated visual could retain both.
The AI could understand the whole project as a structured scene, while the user could independently manipulate its components.
That would allow ChatGPT to combine something traditional creative software has always done well — precise user control — with what generative AI does well — understanding intent and creating complex visual content.