The method behind this entire site

This is T00.

Not a product. The assistant, the flow, the way of communicating — refined through months of daily, hands-on iteration with Claude Code. Every other product on this site was built through it.

1
Say what you want, in plain language.
→
2
It finds the right files on its own and reads them.
→
3
Unsure about something? It asks — it doesn't guess.
→
4
You review the result and confirm before anything ships.

What it actually is

T00 is a personal AI-collaboration framework built the way most real engineering practices get built: not designed upfront on a whiteboard, but refined through repeated, hands-on friction — a communication protocol here, a memory convention there, a rule added the day it would have prevented a mistake.

It makes Claude Code work more effectively, and it makes me work more efficiently. That's the whole point: not "the AI does everything," but a working relationship between a person and an AI assistant that gets better the more it's used.

Every product on this site — the app generator, the email agent, the shop, the games, all of it — was created through T00. T00 isn't one of the products. It's the method that made the others possible.

Two questions people actually ask me

My Japanese teacher asked me this

Can AI actually finish a task without you opening files one by one? Yes. This exact page is the proof — I asked for "a more compelling T00 introduction, with a diagram," and Claude Code found the right files, read them, rewrote them, and checked its own work. I didn't open a single file by hand.

"Is this limited to the T00 folder?"

No. T00 is the name of the workspace where the rules and the conversation history live — not a wall around what the AI can touch. Give it a path anywhere on the computer, and it can read or edit it. It just always asks before anything risky or hard to undo — nothing runs silently in the background.

T00 at a glance

Without it
  • Open file 1. Read it.
  • Open file 2. Read it too.
  • Try to hold all of it in your head at once.
  • Make the edit yourself, and hope nothing else broke.
→
With T00
  • Say what you want, in plain language.
  • The agent finds the right files, reads them, makes the change.
  • It asks you when it isn't sure, instead of guessing.
  • You review the result and confirm — nothing ships unchecked.

What it means, from two angles

If you're not technical
  • Tells you what needs doing today, and what's coming up.
  • Flags what actually matters, instead of drowning it in noise.
  • Reads files for you and tells you what's actually in them.
  • Understands what you meant — the result doesn't drift from what you asked.
  • Asks you before guessing, whenever it's unsure.
If you build software
  • Token/context bloat — hierarchical rule files, only the relevant layer gets loaded, not everything every time.
  • Answers drifting off-task over a long session — a persistent req/reply log stands in for scrollback memory.
  • Detail problems that don't surface until later — trust-level tags plus a dedicated review pass before anything ships.
  • The real one: the first 80% of a build goes fast — the last 20% is where quality quietly erodes or you need far more people. Sub-agent delegation for the hard, isolated pieces, plus a hard rule against ever reporting "done" without actually checking, is what T00 built specifically to hold that line.

Curious what it's actually produced?

From slash commands to how-to guides — see the concrete output T00 has built.

What T00 has built →