Cursor rules for creating task lists

task-lists.mdc

---
description: This rule explains how to create and manage task lists to track project progress.
globs: *
alwaysApply: false
---

# Task List Management

Guidelines for creating and managing task lists in Markdown files to track project progress

## Task List Creation

1. Create task lists in a markdown file (in the project root):
   - Use `TASKS.md` or a descriptive name relevant to the feature (e.g., `ASSISTANT_CHAT.md`)
   - Include a clear title and description of the feature being implemented

2. Structure the file with these sections:
   ```markdown
   # Feature Name Implementation
   
   Brief description of the feature and its purpose.
   
   ## Completed Tasks
   
   - [x] Task 1 that has been completed
   - [x] Task 2 that has been completed
   
   ## In Progress Tasks
   
   - [ ] Task 3 currently being worked on
   - [ ] Task 4 to be completed soon
   
   ## Future Tasks
   
   - [ ] Task 5 planned for future implementation
   - [ ] Task 6 planned for future implementation
   
   ## Implementation Plan
   
   Detailed description of how the feature will be implemented.
   
   ### Relevant Files
   
   - path/to/file1.ts - Description of purpose
   - path/to/file2.ts - Description of purpose
   ```

## Task List Maintenance

1. Update the task list as you progress:
   - Mark tasks as completed by changing `[ ]` to `[x]`
   - Add new tasks as they are identified
   - Move tasks between sections as appropriate

2. Keep "Relevant Files" section updated with:
   - File paths that have been created or modified
   - Brief descriptions of each file's purpose
   - Status indicators (e.g., ✅) for completed components

3. Add implementation details:
   - Architecture decisions
   - Data flow descriptions
   - Technical components needed
   - Environment configuration

## AI Instructions

When working with task lists, the AI should:

1. Regularly update the task list file after implementing significant components
2. Mark completed tasks with [x] when finished
3. Add new tasks discovered during implementation
4. Maintain the "Relevant Files" section with accurate file paths and descriptions
5. Document implementation details, especially for complex features
6. When implementing tasks one by one, first check which task to implement next
7. After implementing a task, update the file to reflect progress

## Example Task Update

When updating a task from "In Progress" to "Completed":

```markdown
## In Progress Tasks

- [ ] Implement database schema
- [ ] Create API endpoints for data access

## Completed Tasks

- [x] Set up project structure
- [x] Configure environment variables
```

Should become:

```markdown
## In Progress Tasks

- [ ] Create API endpoints for data access

## Completed Tasks

- [x] Set up project structure
- [x] Configure environment variables
- [x] Implement database schema
```

Task lists are a powerful way to track project progress within your development workflow. This rule provides a structured approach to creating and maintaining task lists in Markdown files, helping you organize completed work, in-progress items, and future development plans.

What this rule does

The Task List rule establishes a systematic approach to project management through Markdown-based task lists. It defines a clear structure for tracking project progress, including sections for completed tasks, in-progress work, and planned future tasks. The rule also provides guidance on maintaining task lists as your project evolves, ensuring your documentation stays current with development progress.

Creating effective task lists

Following the structure defined in this rule, your task lists should include:

Basic structure

Task lists should be created in dedicated Markdown files, typically named TASKS.md or with descriptive names related to specific features (e.g., ASSISTANT_CHAT.md). Each task list should begin with a title and description of the feature being implemented.

The recommended structure includes these primary sections:

Completed Tasks: Items that have been fully implemented
In Progress Tasks: Work currently being done
Future Tasks: Planned items for future development
Implementation Plan: Detailed explanation of the feature implementation
Relevant Files: List of key files with descriptions

Task formatting

Tasks use standard Markdown checkbox syntax:

[ ] Incomplete task
[x] Completed task

As you make progress, you'll move tasks between sections and update their status accordingly.

Maintaining your task lists

Effective task list management involves:

Regularly updating task status by changing [ ] to [x] as items are completed
Moving tasks between sections as their status changes
Adding new tasks as they're identified during development
Keeping the "Relevant Files" section updated with accurate file paths and descriptions
Documenting implementation details, architectural decisions, and data flow

Using task list in Cursor

The Task List rule is defined in the file task-lists.mdc in your project's .cursor/rules directory. This rule appears to be configured with a glob pattern of *, which means it can be automatically attached when working with any file in your project.

To leverage this rule:

Access the rule by typing @task-lists in the AI chat or command palette (Cmd-K)
The AI will then have context about how to help you manage and update your task lists
You can ask the AI to help create a new task list, update existing tasks, or organize your project tracking

This rule is particularly valuable when you're working on complex features and need to maintain clear visibility of progress across multiple components or when collaborating with team members who need to understand the project status.

Task list best practices

To get the most value from your task lists:

Regular updates

Task lists should be living documents. Update them after implementing significant components or when identifying new requirements. This creates a natural progress log for your project.

Right level of detail

Balance between too much detail (which becomes tedious to maintain) and too little (which doesn't provide enough guidance). Focus on meaningful implementation steps rather than minute code changes.

Use for AI collaboration

When working with Cursor's AI, refer to your task list to provide context about what's next. The AI can help implement the specific task you're focused on while keeping the bigger picture in mind.

Example workflow

Here's how a typical task list update might look:

Check your task list to identify the next in-progress item
Implement that feature or component
Update the task list by marking the item as complete and moving it to the "Completed Tasks" section
Add any new tasks discovered during implementation
Update the "Relevant Files" section with any new or modified files

This systematic approach ensures your project documentation always reflects the current state of development.