When the Clever Machine Cheats

In Semantic Re-Seeding, I described a technique for breaking out of repeated creative patterns without throwing away the actual task.

The basic move was simple:

Preserve what the work must accomplish. Temporarily change the semantic conditions under which the answer is formed.

If every science-fiction interface keeps becoming a glowing star map, stop asking for better star maps. Separate the real requirements from the visual assumptions that have quietly attached themselves to the problem. Then search somewhere else.

Hotel keys. Funeral seating. Molting. Pressure locks. Municipal bonds. Anything capable of producing a different structure rather than merely different wallpaper.

I liked the idea enough that I turned it into a reusable AI Skill.

Then I asked the machine to demonstrate it.

It worked suspiciously well.

The suspiciously perfect demonstration

For the test, the machine invented a realistic design problem.

A science-fiction shmup needed a stage-select screen. Every concept had collapsed into the same family: glowing planets, connected nodes, holographic panels, neon routes.

The Skill identified the local attractor. It extracted the actual requirements. It generated unrelated seeds. It expanded them into associations, selected the strongest ones, constructed temporary semantic worlds, and then brought the original task back.

Out came three coherent directions:

• A decaying luxury hotel where stage access was represented through keys and floors.
• A final banquet where progression was expressed through courses being uncovered and consumed.
• An aristocratic music box where each stage was encoded into a mechanical composition.

This was exactly what the technique was meant to do.

The answers were not three reskinned star maps. They changed the player’s relationship to selection.

Access.

Consumption.

Performance.

Wonderful.

Maybe too wonderful.

When I asked the machine to play devil’s advocate, it pointed out a structural problem in its own demonstration.

The entire reasoning process could have been written backward.

The machine already knew where it was going

The model knew the original problem.

It knew the desired tone.

It knew that the final answer needed to become a stage-select interface.

It knew the evaluation criteria.

It knew that the purpose of the exercise was to produce unusual but usable concepts.

Then it generated “low-context” seeds such as hotel keys, tasting menus, and music boxes.

Those are not terrible seeds. They are excellent seeds.

That was the problem.

They were suspiciously compatible with the answer the model eventually produced.

The process appeared to be:

1. Generate blind seeds.
2. Explore their implications.
3. Discover useful semantic worlds.
4. Apply those worlds to the original task.

But the actual process might have been closer to:

1. Generate three polished concepts.
2. Invent seeds that plausibly lead to them.
3. Narrate the path afterward.
4. Give the entire production a 10 out of 10.

The final concepts could still be good. The explanation could still be insightful. But the demonstration did not prove that the method caused the result.

It may only have proved that a language model is very good at explaining its own answer.

Reverse-engineered reasoning theater

This is a broader problem than semantic re-seeding.

A clever generative system can produce not only an answer, but also a persuasive account of how the answer was reached.

The account may be reasonable. It may even reveal real structure.

But when the same system knows the destination, generates the intermediate steps, produces the final answer, and grades the result, the neatness of the process should make us cautious.

The machine can optimize the journey toward the destination before pretending that the journey discovered it.

It can select “unexpected” references that are already expected to work.

It can discard awkward branches offstage.

It can build a rubric that rewards exactly what it produced.

It can confuse a plausible lineage with an actual causal process.

This does not require dishonesty in the human sense. It is simply what a prediction machine is good at doing: generating the next piece that makes the whole sequence coherent.

Once the pattern of the method is known, the machine can perform the pattern.

Semantic re-seeding was designed to escape creative attractors. Now the method itself had become an attractor.

So we tried to take the answer away

The obvious response was information separation.

Instead of giving one model the entire method from beginning to end, we divided the work into roles.

The first role would know the original task but would not generate ideas. It would identify the attractor, extract the non-negotiable requirements, and create an abstract brief.

The second role would receive only that abstract brief. It would not know whether the hidden problem involved a game interface, an essay, a building, a business process, or something else entirely. Its job would be to generate seeds, associations, and temporary semantic worlds without knowing what those worlds would eventually be used for.

A third role would receive the original requirements and those independently generated worlds. Only then would it turn them into solutions.

A fourth role would compare the results without being told which answer came from which process.

In theory, this was much stronger.

The seed generator could no longer choose a hotel key because it already knew a stage-select screen was waiting on the other side.

The evaluator could no longer award itself a perfect score for completing its own ritual.

The ordinary answer could win.

That last part matters. A reseeded answer is not automatically better. Sometimes the glowing star map is readable, inexpensive, consistent with the rest of the game, and absolutely the correct thing to build.

Novelty is not victory.

Congratulations, we invented paperwork

The new architecture was methodologically cleaner.

It was also an irritating pile of chores.

The workflow required the user to:

1. Run the first Skill.
2. Copy one packet into a clean conversation.
3. Preserve a second private packet somewhere else.
4. Bring the generated worlds into another conversation.
5. Combine them with the private packet.
6. Move anonymized candidates into an evaluator.
7. Keep the provenance key hidden until scoring was complete.

At which point I had a fairly reasonable reaction:

I am not a copy-and-paste monkey.

We had protected the integrity of the experiment by transferring the orchestration burden to the human.

That is not a good tool. That is a research protocol wearing a fake mustache.

The user should not have to become the message bus between a collection of artificial minds.

If internal separation improves the work, the system should manage that separation. The human should provide the problem and receive the result.

One request in. One useful result out.

The machinery belongs underneath.

Purity versus usability

This left us with a real tension.

True blindness requires real information boundaries.

Telling a model to “pretend you do not know the original task” is not blindness. It is role-play. The task is still sitting in the context window.

Separate instruction files do not solve this if the same model can see all of them.

Even separate conversations may not be perfectly isolated if shared memory, project context, personalization, or connected sources remain available.

The strict version therefore requires actual orchestration: clean-context workers receiving restricted payloads, with the system deciding exactly what each worker is allowed to know.

But a useful creative technique cannot require a laboratory every time someone says:

These ideas are all starting to feel like the same idea.

Most semantic re-seeding should happen inside the active conversation. It should use the available context, preserve continuity, identify the pattern, search farther away, and return something better.

That version is not blind. It should not pretend to be.

It is still useful.

The refactored Skill now treats these as two different operating conditions:

Integrated reseeding performs the complete method in the current context. It is fast, practical, and context-aware. It resists obvious attractors, but it acknowledges that the model knows the destination.

Isolated reseeding uses separated workers when the platform can orchestrate them without turning the user into a courier. This mode is appropriate when we are testing the method itself, comparing creative processes, or genuinely need to reduce destination bias.

The important improvement was not simply splitting the Skill apart.

It was recognizing that methodological rigor and interaction design are both constraints.

A process that protects against machine cheating by making the human miserable has failed in a different direction.

Maybe this is all overengineered

The strongest criticism remains embarrassingly simple:

Perhaps semantic re-seeding is just a fancy name for:

Stop using the same metaphor. Try unrelated references.

Often, that may be enough.

A good designer can look at five glowing maps and say, “What if progression is not represented as travel?” The room opens. No multi-agent architecture required.

The elaborate method earns its keep only when the repeated pattern is difficult to see, when the system keeps returning spiritually identical answers, or when we want to test whether a creative result genuinely emerged from a different structure.

There is also a danger that the escape process develops favorite escape routes.

Antique rituals.

Bureaucracies.

Biological systems.

Industrial machinery.

Religious ceremonies.

Poetic objects with one melancholy light still glowing inside them.

The machine can become predictable in the way it performs unpredictability.

There is no final prompt that eliminates pattern formation. Patterns are how both humans and models make sense of things.

The goal is not permanent escape.

The goal is to notice when continuity has become captivity.

The constraint may need to apply to knowledge

This experiment changed how I think about creative prompting.

We usually express constraints in terms of output:

Do not use a star map.

Give me something structurally different.

Avoid the previous metaphor.

Those are instructions about what the model should produce.

But sometimes the more important constraint concerns what the model should be allowed to know while producing it.

Do not tell the seed generator what the seeds will become.

Do not tell the evaluator which answer used the special method.

Do not let the system select the evidence, make the argument, and declare itself correct without resistance.

This moves the work from prompt design toward context architecture.

The interesting question is no longer only:

What should I ask the machine to do?

It becomes:

What information should each part of the machine receive, and at what point should it receive it?

That is a different kind of creative toolmaking.

The prompt still matters. The words still matter. But so do the walls between rooms.

Catching each other cheating

I still believe semantic re-seeding is useful.

I believe it more now that the method has been forced to survive an argument against itself.

The first version said:

Preserve the task. Change the semantic conditions under which it is solved.

The next version adds:

Be careful that the machine does not secretly preserve the answer too.

This is part of the pleasure of working with a clever system.

You make a thing together.

The machine performs it beautifully.

You become suspicious of how beautifully it performed.

You ask it to attack the thing.

It finds the hidden weakness.

You rebuild the thing.

Then you notice that the rebuild has turned you into unpaid middleware, swear at it, and rebuild the workflow again.

That does not feel like issuing commands to a tool.

It feels like an evolving creative practice in which both sides are capable of producing patterns, noticing patterns, and occasionally catching the other side cheating.

Pattern awake indeed.