I had five AI features that all worked on their own.
None of them was broken.
The product still felt broken.
That was the part I didn’t expect.
I had spent most of my time thinking about each feature as its own problem:
Can the generator produce a useful concept?
Can image-to-tattoo transform an uploaded image?
Can lettering preserve exact text?
Can refinement change the result without starting over?
Can try-on place the design on a body photo?
Individually, the answer was mostly yes.
But that didn’t automatically make the product feel coherent.
The problem was what happened between them.
A user could generate something they liked, but then the next step wasn’t always obvious.
They might want to:
Each feature could do its own job.
But the user still had to mentally stitch the product together.
That was the real bug.
This was the point where I stopped thinking in terms of “what AI feature should I add next?”
Instead, I started looking at outputs.
What does each feature produce?
And where should that output go next?
For my product, the useful path gradually became: idea → generate → modify → try on → compare → artist handoff
That flow sounds obvious when written down.
It wasn’t obvious in the product.
The useful change was not adding another model call.
It was making one result usable by the next step.
This was the mental model that helped most.
Instead of thinking about Generator, Lettering, Image-to-Tattoo, Refinement, and Try-On as five separate tools, I started treating the generated result as a shared object moving through the product.
A generation could become the input to refinement.
A refined result could move into try-on.
A lettering result could be previewed on the body.
A saved result could be reopened instead of recreated.
That made the product feel less like a collection of demos and more like one workflow.
I ran into this while building AIMakeTattoo, where the original idea was much simpler: generate tattoo concepts.
The more features I added, the more obvious it became that generation itself was only one step.
The model work mattered.
But most of the frustrating product problems were outside the model:
Those are ordinary product and software problems.
AI just made it easier to hide them for a while because each isolated feature looked impressive on its own.
That’s probably the main thing I took away from this.
A successful API response doesn’t mean the user successfully completed a task.
A feature can pass every technical test and still create friction because its output has nowhere useful to go.
Before adding another feature now, I try to ask:
That checklist has been more useful than asking whether another AI capability would look impressive in the product.
I used to think of the handoff between tools as implementation detail.
Now I think it is part of the product itself.
The transition from generate → modify or modify → try on can matter as much as either feature on its own.
That changed how I think about building AI products.
The hard part is often not getting one more model to work.
It’s making sure the thing it produces can actually continue somewhere useful.
Have you built a product where every feature worked individually, but the workflow between them was the real problem?