Ariadne
Coding journey

The Labyrinth

Building a small game with the agent — every decision, dead-end and recall, captured as it happens.

A real run — every screenshot is the agent's live memory after that step.

Frame the project — the memory after this step
Step 1 · Frame the project · OBSERVATION

The developer frames the project. Claude takes it in and starts a fresh thread. Ariadne stores the project's first memory.

Frame the project — the memory after this step
Step 2 · Frame the project · OBSERVATION

The developer describes how rooms work. Claude notes the model. Ariadne keeps the detail beside the project.

Frame the project — the memory after this step
Step 3 · Frame the project · QUESTION

The developer raises an open question. Claude holds it open instead of guessing. Ariadne records the question so it isn't lost.

Design debate — the memory after this step
Step 4 · Design debate · HYPOTHESIS

The developer floats an idea. Claude treats it as a hunch to test. Ariadne files it as a hypothesis.

Design debate — the memory after this step
Step 5 · Design debate · DEBATE

The developer opens a real debate. Claude lays out both sides. Ariadne starts a debate thread to hold the tension.

Design debate — the memory after this step
Step 6 · Design debate · ARGUMENT

The developer gives points for and against. Claude weighs them. Ariadne links each argument to the debate.

Design debate — the memory after this step
Step 7 · Design debate · RESOLUTION

The developer decides. Claude commits to the call. Ariadne stores the resolution where it won't fade.

Build it — the memory after this step
Step 8 · Build it · ACTION

The developer asks for code. Claude writes the first version. Ariadne logs the action taken.

Build it — the memory after this step
Step 9 · Build it · CONCLUSION

The developer confirms it works. Claude validates the approach. Ariadne records the conclusion as settled.

Hit a wall — the memory after this step
Step 10 · Hit a wall · DEAD_END

The developer flags a past failure. Claude marks it clearly. Ariadne stores a permanent dead-end so it's never tried again.

Hit a wall — the memory after this step
Step 11 · Hit a wall · RULE

The developer turns the lesson into a rule. Claude adopts it. Ariadne pins the rule close to the core.

Instant knowing — the memory after this step
Step 12 · Instant knowing · PROCEDURE

The developer records a repeatable procedure. Claude captures the steps. Ariadne stores the how-to for next time.

Instant knowing — the memory after this step
Step 13 · Instant knowing · REFLEX

The developer sets a standing principle. Claude internalizes it. Ariadne keeps it as a reflex at the centre.

Lean on memory — the memory after this step
Step 14 · Lean on memory · RECALL

The developer asks why. Claude answers from memory, not a guess. Ariadne surfaces the original decision.

Lean on memory — the memory after this step
Step 15 · Lean on memory · DEAD_END_CHECK

The developer almost repeats a mistake. Claude warns it's a known dead-end. Ariadne flags the recorded failure.

Lean on memory — the memory after this step
Step 16 · Lean on memory · TIMELINE

The developer asks what happened today. Claude replays the day in order. Ariadne returns it by time, not from imagination.

Lean on memory — the memory after this step
Step 17 · Lean on memory · RECALL

The developer asks for the standing rule. Claude recalls the reflex instantly. Ariadne hands it back word for word.

Let it sleep — the memory after this step
Step 18 · Let it sleep · DREAM

The developer wraps up. Claude runs a consolidation. Ariadne merges the noise and keeps the decisions, dead-ends and rules.

Give your agent this kind of memory

Download for Windows Other journeys
macOSsoon Linuxsoon