Skip to content
Developer Toolkit

The Core Methodology: PRD to Plan to Todo

The single most effective and reliable workflow for building features with an AI assistant is the PRD → Plan → Todo methodology. This structured approach transforms a high-level requirement into a detailed engineering plan, ensuring that both you and your AI partner are perfectly aligned before writing a single line of code.

This guide breaks down each step of this core workflow, providing a repeatable process for tackling any development task.

The Three Phases of the Core Methodology

Section titled “The Three Phases of the Core Methodology”

The workflow moves from high-level business needs to granular, executable tasks.

1. PRD: The Source of Truth

Everything starts with a clear requirement. This can be a formal Product Requirements Document (PRD), a user story, a ticket, or even a detailed bug report. This document serves as the “source of truth” that defines the what and the why of the task.

2. Plan: The Architectural Blueprint

In this phase, you collaborate with the AI to translate the PRD into a technical implementation plan. You act as the senior architect, guiding the AI as it explores the codebase, suggests architectural approaches, and outlines the major components to be built or modified.

3. Todo: The Actionable Checklist

Finally, you and the AI convert the high-level plan into a granular, step-by-step todo list. Each item on this list is a small, concrete task that can be implemented and verified independently. This checklist becomes the script that the AI will follow during the execution phase.

Step-by-Step Implementation

Section titled “Step-by-Step Implementation”

Here’s how to apply the PRD → Plan → Todo workflow in practice.

Phase 1: Ingesting the PRD

Section titled “Phase 1: Ingesting the PRD”

  1. Make the PRD Accessible. Place your PRD or user story inside your project repository, typically in a /docs directory (e.g., docs/feature-x-prd.md). This makes it easy to reference.

  2. Provide the PRD as Context. Start your conversation with the AI by giving it the PRD as the primary context.

    I'm starting work on a new feature. Please read the requirements in @/docs/feature-x-prd.md.

Phase 2: Collaborative Planning

Section titled “Phase 2: Collaborative Planning”

  1. Request a High-Level Plan. Ask the AI to generate an initial plan. It’s crucial at this stage to instruct it not to write any implementation code yet. Use a “read-only” or “ask” mode for this. For Claude Code, use the /think command to encourage deeper reasoning.

    Based on the PRD and your analysis of the existing codebase, create a high-level implementation plan.
    Do not write any code yet. Outline the necessary changes to the database, backend, and frontend.

  2. Review and Refine. The AI will produce a plan, perhaps suggesting new database tables, API endpoints, and UI components. This is the most critical part of your role as the architect. Review the plan and ask clarifying questions.

    The plan looks good, but what are the security implications of the proposed public-facing endpoint? How will we handle authentication?

  3. Iterate Until Solid. Continue this back-and-forth until you have a technical plan that you are confident in. You have successfully front-loaded the architectural thinking, significantly reducing the risk of going down the wrong path during implementation.

Phase 3: Generating the Todo List

Section titled “Phase 3: Generating the Todo List”

  1. Request the Checklist. Once the plan is solid, ask the AI to convert it into a detailed checklist.

    Excellent. Now, convert this plan into a detailed todo list in Markdown format. Each task should be a specific, actionable item.

  2. Receive the Action Plan. The AI will generate a granular checklist. Both Cursor and Claude Code have built-in features to manage and track these todo lists. An example might look like:

    - [ ] **Database:** Add `is_active` boolean column to `widgets` table.
    - [ ] **Backend:** Create a new `GET /api/widgets/:id` endpoint.
    - [ ] **Backend:** Modify `POST /api/widgets` to set `is_active` to `true`.
    - [ ] **Frontend:** Create a new `<WidgetStatus>` React component.
    - [ ] **Frontend:** Add the `<WidgetStatus>` component to the `WidgetDetailsPage`.

With this detailed todo list, you are now ready to move into the Execute and Verify phases of development. You’ve transformed a vague requirement into a precise and actionable engineering plan, setting your AI partner up for a smooth and successful implementation.