Step 6 of 6
Revise
Change a room. Rebuild the game. See the difference.
Change the Underground Pool
The pool is too quiet. Let's make it dangerous:
Tell your agent
"Update the rooms/underground-pool page. The water is no longer still —
something moves beneath the surface. Add a new exit: down leads to a
Hidden Shrine. And add a notable feature: the player needs Ariadne's thread
to find their way back."
The agent uses str_replace_page or put_page to update
the pool. Then create the new room:
Tell your agent
"Create a room called Hidden Shrine — an ancient altar to Poseidon,
crumbling columns, a trident embedded in the stone floor. The only exit
leads back up to the Underground Pool."
Rebuild the game
Tell your agent
"Read all txtscape pages with snapshot. The pool has changed and there's a new
room. Rebuild index.html to include the Hidden Shrine, the danger in the pool,
and the thread requirement."
Open index.html. The game has changed:
- The pool description mentions something moving in the water
- A new "Hidden Shrine" exit appears
- The thread from Ariadne's Chamber now matters for navigation
Commit your progress
git add .txtscape index.html
git commit -m "add Hidden Shrine, deepen Underground Pool, rebuild game"
The loop
You edited knowledge, not code. The game adapted.
This is how txtscape works in any project — not just games:
- You edit knowledge, not code. The source of truth lives
in txtscape pages. The code is derived from them.
- The agent stays consistent. It reads the current state
every time. No stale context, no drift between sessions.
- Changes propagate. Update a page, regenerate, everything
aligns.
Beyond the labyrinth
txtscape is not a game engine. It's persistent project memory for AI
agents. The pattern is always the same:
- Architecture decisions — why you chose Postgres,
how auth works, what you tried and rejected
- Runbooks — how to deploy, what to do when the
queue backs up, incident response
- Learning logs — bugs you hit, patterns that worked,
things that surprised you
Define concerns with templates. Store knowledge in pages. Let the agent read
them. It doesn't start from scratch — it starts from everything you've
recorded.
What's next
- Try
search_pages to find pages that mention "thread" or
"Minotaur" across the whole project
- Try
page_history to see git history for the underground pool
— works because you've been committing each step
- Try
related_pages to discover which pages reference each other
- Add txtscape to a real project and record your first decision
- Browse the tool reference to see all 11 MCP tools
The labyrinth ends here. The real adventure is what you build next.
🔬
Take it to a real project.
Create a .txtscape/config.json in your work project. Define one
concern — maybe decisions/ with a Context / Decision /
Consequences template. Record your next architecture decision there.
Tomorrow, start a new chat and ask the agent what decisions have been made.