Stop your AI from yolo'ing your codebase.

Claude forgets. td remembers. Tasks, decisions, and learnings that persist - in markdown files your AI reads every time.

npm install -g @teedee/td
→ then run td init · Free beta

Meet td.

A CLI for you. An MCP server for your AI. Same memory, two doorways. What you log today, your AI remembers tomorrow.

Files that survive
everything.

Markdown doesn't compress. Doesn't forget. Survives session restarts, machine changes, team handoffs. Every task, decision, and learning - in files your AI always finds.

  • Your memory travels with your code. Clone and you're caught up.
  • Version controlled like everything else. Diff decisions, review in PRs.
  • Works with any AI that reads files. No lock-in.
  • No database. No sync service. Just markdown.
.tasks/TSK-042.md 
---
ref: TSK-042
title: Add user authentication
status: in-progress
priority: high
epic: auth
iteration: sprint-3
points: 5
---

## Acceptance Criteria

**Given** a user on the login page
**When** they enter valid credentials
**Then** they're redirected to dashboard

Right context,
right time.

Context windows are precious. Every token on project management is a token not available for code. td loads what's needed, when it's needed - never a context dump.

Manifest
Project snapshot. Task counts, active iteration, what's blocked. Loaded every session.
Task Context
Full task details, epic summary, blockers, dependents. When working on specific tasks.
Full Reference
Complete methodology guide. Only when asked.

Progressive disclosure - right context at the right time. Hat tip to Anthropic for the concept.

Memory that learns.

Sessions end. Context compacts. But your decisions, discoveries, and project direction persist - in files your AI reads at the start of every conversation.

Project vision

What you're building and why. The north star for trade-offs.

Architecture decisions

ADRs. Why Postgres over Mongo. The "why" alongside the "what."

Hard-won learnings

Knowledge earned the hard way. Gotchas that shouldn't repeat.

During work

Log findings as you go. Brief notes, discoveries, gotchas.

Iteration end

Retrospective prompts reflection. What worked, what didn't.

Next session

Learnings surface automatically. No re-learning the same lessons.

Small tasks,
clean context.

LLMs get worse as context fills. Big tasks mean poor output. td enforces the discipline that keeps AI effective - small, focused work with clear boundaries.

Epics

Group related work. Auth, API, Dashboard - the big picture, broken into small pieces.

Story Points

Fibonacci sizing. XS to XL - know the weight before you lift.

Dependencies

Tasks block tasks. Work in order, not chaos.

Iterations

Timeboxed focus. Plan what fits, ship what matters.

BDD Criteria

Given/When/Then. Requirements clear enough for AI to verify done.

Retrospectives

Iteration ends, learning begins. Discoveries saved for next session.

Git-native.
No new tools to learn.

td doesn't fight your workflow - it lives inside it. Everything in your repo. Branch, review, merge. The way you already ship.

Auto-referenced commits

td commit adds task refs automatically: [TSK-042] Add user auth

One task, one PR

Small, focused work. Fast reviews. Clean git history. No batching chaos.

Team sync

Pull to get everyone's task updates. Merge conflicts? Git handles them.

Full traceability

Trace any line of code back to its task, conversation, and requirements.

From rant to roadmap.
Then autopilot.

Don't just use AI to execute - use it to plan. Start with a messy idea, end with well-scoped tasks. Then let the agent work through them systematically.

Discovery first

Give AI your rant. It asks the right questions, captures vision, breaks work into epics and tasks.

Epic breakdown

Epics become tasks with acceptance criteria. Better definition = better execution.

Catchup protocol

td catchup - your AI knows the state in seconds. Active work, blockers, what's next.

Focus mode

td focus TSK-042 - exactly what's needed for one task. Description, blockers, what it unblocks. No noise.

Autonomous loop (Ralph Loop)

Agent picks task, works, logs findings, completes, moves to next. The task list becomes the PRD. Learnings accumulate.

Three commands.
Full memory.

1 npm install -g @teedee/td
2 cd your-project
3 td init
# Your AI remembers everything.
npm install -g @teedee/td