The More AI I Added, the Less Predictable the Product Became

I used to think the obvious way to improve an AI product was to add more AI.

If one part of the workflow could call a model, why not let the model handle the next decision too?

That worked for a while.

Then the product started becoming harder to reason about.

Not because the models were bad.

Because I was using probabilistic behavior in places where users were actually asking for certainty.

That distinction became much clearer while building AIMakeTattoo, a tattoo design and planning product.

The product eventually included generation, image editing, lettering, Roman numeral conversion, cost planning, placement controls, history, and try-on.

Some of those features benefited from variation.

Others became worse when I treated variation as a feature.

The first version of the product made AI the default

The earliest mental model was simple:

user input → model → useful output

That works well for something like tattoo concept generation.

A user might describe:

a blackwork raven with a broken compass and storm clouds

There is no single correct image.

Variation is useful.

One generation may emphasize the raven.

Another may make the compass more prominent.

A third may produce a composition the user had not considered.

That uncertainty is part of the value.

The same is true for visual refinement.

If a user asks:

make the composition darker and simplify the background

there are many reasonable interpretations.

Again, variation is useful.

The mistake was assuming this logic applied to the rest of the workflow.

It did not.

Exact text exposed the problem first

Tattoo lettering looks like a generative problem.

There is text, style, composition, ornaments, and visual output.

So it is tempting to give everything to the model.

But consider a user entering:

MCMXCIV

The user may want the model to explore:

• Blackletter

• Chicano lettering

• serif layouts

• ornamental frames

• different spacing

• different visual treatments

What they do not want is creative interpretation of the text itself.

MCMXCIV must remain MCMXCIV.

A visually beautiful output with one character changed is simply wrong.

That forced me to separate two kinds of information that initially lived too close together.

Things the model may interpret

• style

• visual hierarchy

• ornament

• composition

• shading

Things the system should preserve exactly

• names

• dates

• initials

• Roman numerals

• quoted text

The UI and data model became better once that boundary was explicit.

Roman numerals made the distinction impossible to ignore

Roman numeral conversion is another good example.

It looks adjacent to AI because the result may later become part of an AI-generated tattoo.

But the conversion itself is deterministic.

If someone wants to convert a date, I do not want a model to produce a plausible answer.

I want the correct answer every time.

The same input should produce the same conversion tomorrow, next week, or on a different device.

There is no benefit to creativity here.

So the workflow became:

deterministic conversion → visual exploration

instead of:

ask a model to understand and render everything at once

That seems obvious in retrospect.

It was less obvious while I was still thinking of the product primarily as an AI generator.

Pricing had the same issue

Tattoo cost estimation also sits inside the same product, but it has completely different requirements.

A cost planning tool can use inputs such as:

• approximate size

• placement

• style

• detail level

• color

• hourly rate

The useful output is a planning range.

If the same inputs produce dramatically different estimates because a model happened to interpret them differently, trust disappears quickly.

Here consistency matters more than novelty.

A calculator is allowed to be boring.

In fact, boring is often the point.

Saved state should be even more boring

The same lesson applies to product infrastructure.

Generation history should not “approximately” remember what happened.

Credits should not be interpreted.

A selected placement should not change because the system inferred something else.

User state, quotas, saved inputs, IDs, and billing rules all benefit from predictability.

The more I built, the more I noticed that many of the most important parts of an AI product should contain very little AI.

That sounds obvious when written down.

It was not obvious when every new model capability made another part of the workflow look automatable.

I ended up using one question as a filter

I now ask:

Would I be happy if this gave a slightly different answer every time?

If the answer is yes, generative AI may be a good fit.

For example:

• concept generation

• style exploration

• image transformation

• visual refinement

• alternative compositions

A different result may reveal something useful.

If the answer is no, I become much more skeptical about putting a model in the critical path.

For example:

• exact text

• date conversion

• pricing rules

• credit balances

• saved state

• placement coordinates

• permission checks

• IDs

In those cases, predictable software usually wins.

The architecture became clearer after that

The product stopped looking like one large AI pipeline.

It started looking more like a combination of layers.

Generative layer

Used where exploration is valuable.

Examples:

• generate a tattoo concept

• transform a reference image into a tattoo direction

• modify selected visual details

• explore lettering styles

Deterministic layer

Used where correctness or consistency matters.

Examples:

• validate exact text

• convert Roman numerals

• calculate planning ranges

• enforce quotas

• store generation records

• preserve user selections

Interaction layer

Used to help users evaluate the output rather than generate more of it.

Examples:

• compare versions

• modify one part

• try the design on a body photo

• move and resize placement

• revisit generation history

That third layer became especially important.

I originally thought generation was the product.

Over time, generation became one step inside a much larger decision workflow.

More intelligence can create more product uncertainty

There is a subtle failure mode here.

A model can make a system technically more capable while making the product less understandable.

Suppose a deterministic control does exactly one thing.

The user quickly learns what will happen when they use it.

Now replace it with a model that can interpret five different intentions.

The feature may become more powerful.

But it may also become harder to predict.

Users now have to wonder:

• What will the model infer?

• What will it preserve?

• What might it change?

• Will the same instruction behave differently next time?

Sometimes that flexibility is worth it.

Sometimes it is exactly what makes the feature worse.

AI should not erase product boundaries

Another thing I learned is that the existence of a capable model does not mean every boundary should disappear.

It can be tempting to build one giant input box:

Tell us anything you want changed.

Then let the model infer whether the user means the text, style, subject, placement, or composition.

That is elegant from a demo perspective.

It is not always elegant from a product perspective.

Explicit controls can still be valuable because they tell the user what the product is capable of and what will remain stable.

The model can operate inside those boundaries instead of replacing them.

That is the architecture I now prefer:

deterministic structure around probabilistic capabilities

rather than:

probabilistic behavior everywhere because the model can technically handle it

The most useful AI product may contain surprisingly little AI

I still use generative models heavily.

They are the reason several important workflows are possible at all.

But I no longer measure product sophistication by how many decisions are handed to a model.

Sometimes the better product decision is another model call.

Sometimes it is:

if input_is_valid: return deterministic_result

Sometimes it is a slider.

Sometimes it is a history table.

Sometimes it is a simple drag-and-resize interface.

The hard part is not deciding whether AI can do something.

Modern models can do an increasingly large number of things.

The harder question is:

Should this part of the product be allowed to behave creatively?

That question has been much more useful to me.

AI is strongest where multiple good answers are possible.

Software is strongest where the user expects the same answer every time.

The product became easier to reason about once I stopped treating those two cases as the same problem.