AIMakeTattoo 的 5 個 AI 功能各自正常運作，產品整體仍令人覺得失靈

I Had 5 AI Features That Worked Individually. The Product Still Felt Broken.

I had five AI features that all worked on their own.

• tattoo generation
• image-to-tattoo
• lettering
• refinement
• try-on

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 wasn’t the features

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:

• change one part of the design
• try a different placement
• compare the same idea at another scale
• move from lettering into a more complete composition
• reopen something they made earlier
• put the result on a body photo

Each feature could do its own job.

But the user still had to mentally stitch the product together.

That was the real bug.

I had built features, not transitions

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.

The output became the shared object

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 call was rarely the hardest part

The model work mattered.

But most of the frustrating product problems were outside the model:

• preserving state between tools
• deciding what should carry over
• handling exact text separately from visual instructions
• keeping the same result available for the next action
• making the next step obvious
• avoiding forcing users to start over

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.

A feature can work and the workflow can still fail

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:

1. What does this feature output?
2. What is the most likely next action?
3. Can the user reuse the output directly?
4. Are we making them re-enter information?
5. Does the new feature connect to the existing workflow, or just add another branch?

That checklist has been more useful than asking whether another AI capability would look impressive in the product.

I’m starting to think transitions are part of the feature

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?