To Dos

/to-dos - Technical Implementation Task Generator

Generate detailed, actionable developer tasks using TodoWrite for implementation tracking.

Core Principles

Workflow

Phase 1: Parse Request

Extract from the implementation request:

• Core Functionality: What needs to be built
• Scope: Small/medium/large implementation
• Type: UI/backend/fullstack/data/tooling
• Technical Hints: Any mentioned files, patterns, technologies
• Constraints: Performance, compatibility, style requirements

Phase 2: Explore

Search the codebase semantically based on the request. Find similar features and their patterns. Identify files to modify or create. Map dependencies and integration points. Note conventions to follow.

Exploration Checklist:

• Searched for similar implementations
• Identified files to modify/create
• Found patterns to follow
• Mapped dependencies
• Noted project conventions

Environment Detection:

• Identify available MCP tools
• Detect project dev commands from package.json, pyproject.toml, etc.
• Note tech stack and frameworks
• Identify if UI/frontend files will be modified (tsx, jsx, vue, svelte, css, html)

Phase 3: Clarify

Present understanding and ask 1-5 clarifying questions. STOP. Wait for user response.

**Implementation: [short title]**

**tl;dr:** [1-2 sentence summary]

**Files to Modify:** [list from exploration]
**Files to Create:** [list from exploration]
**Patterns to Follow:** [reference files]

---

**Clarifying Questions:**

1. [Question about scope/boundaries]
2. [Question about edge cases]
...

Reply with answers, or "proceed" if no clarification needed.

Phase 4: Plan Tasks

Break down into logical, ordered tasks. Each task = a meaningful unit of work. Prioritise by implementation dependency. Add verification tasks at the end.

Phase 5: Generate TodoWrite

Create technically detailed task descriptions and call TodoWrite.

Task Format

Each task MUST include:

1. Bold Title - Clear action statement
2. Context - Why this change is needed
3. Implementation Guidance - Specific instructions, patterns, signatures
4. References - Specific files to modify/reference
5. MCP Tools (only if relevant) - context7, sequential-thinking, browser mcp, etc.

Example (single line):

**Add `validateToken()` method to `AuthService`** Implement token validation for OAuth flow. **Implementation:** Add signature `async validateToken(token: string): Promise<TokenPayload | null>` - Use `decodeJwt()` from `~/utils/jwt.ts` - Check expiry against `Date.now()` - Return payload if valid, null otherwise. **Pattern:** See `refreshToken()` in same file. **Files:** Modify: `app/services/auth-service.ts` | Reference: `app/utils/jwt.ts`. **MCP:** `context7` - JWT library docs

Verification Tasks

Always include at the end:

1. Dev Checks — run lint, typecheck, build
2. Unit Tests — run suite + write new tests for the implementation
3. Browser Tests (only if UI files modified) — use browser MCP to verify as a user

Constraints

Output Format

TodoWrite([
  { id: "impl-1", content: "**Task title** [single line with all details]", status: "pending" },
  { id: "verify-checks", content: "**Run dev checks** [single line]", status: "pending" },
  { id: "verify-tests", content: "**Unit tests** [single line]", status: "pending" }
])

4. Implementation Notes (optional) — warnings or considerations