Markdown Kanban Roadmap

VS Code extension for task management with interactive Kanban boards

VS Code Markdown Kanban

Table of Contents

Installation

For Cursor Users

If you're using Cursor IDE, add the rules to your User Rules to enable AI assistants to properly create and manage tasks:

  1. Open Cursor Settings → User Rules
  2. Copy the content from rules/.cursorrules (see below)
  3. Paste it into your User Rules

Copy Cursor Rules

# Markdown Kanban & Roadmap - Cursor Rules > **Note for AI Assistants**: These rules are suggested guidelines for AI assistants to understand how to properly create and manage tasks in the Markdown Kanban format. When working with `TASKS.md` files, follow these rules to ensure compatibility with the VS Code Markdown Kanban extension. This file defines the rules for creating and managing tasks in the Markdown Kanban format that works with the VS Code Markdown Kanban extension. ## TASKS.md File Structure The `TASKS.md` file must follow the Kanban format with these required sections: - **Backlog**: Tasks that haven't been started yet - **Doing**: Tasks currently in progress - **Review**: Tasks awaiting review - **Done**: Completed tasks - **Paused**: Temporarily paused tasks - **Notes**: General project notes (optional) ## Task Format ### Basic Structure Each task must follow this format: ```markdown ### Task Name - id: T-001 - tags: [tag1, tag2, tag3] - priority: high|medium|low - workload: Easy|Normal|Hard|Extreme - milestone: sprint-26-1_1 - start: YYYY-MM-DD - due: YYYY-MM-DD - updated: YYYY-MM-DD - completed: YYYY-MM-DD - detail: ./tasks/T-001.md - defaultExpanded: true|false ``` ### Task Properties #### Required - **`id`**: Unique task identifier (format: `T-XXX` where XXX is a sequential number) - Example: `T-001`, `T-002`, `T-010` #### Optional - **`tags`**: Array of tags for categorization - Format: `[tag1, tag2, tag3]` - Example: `[backend, frontend, ui, components]` - Use descriptive and consistent tags - **`priority`**: Priority level - Values: `high`, `medium`, `low` - **`workload`**: Estimated effort - Values: `Easy`, `Normal`, `Hard`, `Extreme` - **`milestone`**: Milestone or marker the task belongs to - Suggested format: `sprint-year-month_number` (e.g., `sprint-26-1_1` for January 2026, sprint 1) - Can use custom strings (e.g., `reconciliation-nn`, `timezone-utc`) - **`start`**: Start date - Format: `YYYY-MM-DD` - Example: `2025-12-01` - **`due`**: Due date - Format: `YYYY-MM-DD` - Example: `2026-01-15` - **`updated`**: Last update date - Format: `YYYY-MM-DD` - Update whenever the task is modified - **`completed`**: Completion date - Format: `YYYY-MM-DD` - Filled when task is moved to "Done" - **`detail`**: Path to detail file - Format: `./tasks/T-XXX.md` - Example: `./tasks/T-001.md` - Points to a markdown file with detailed description - **`defaultExpanded`**: Whether task should be expanded by default - Values: `true` or `false` - When `true`, task shows all details when loaded ### Inline Description If not using a detail file (`detail`), you can include inline description: ```markdown ### Task Name - id: T-001 - tags: [backend] - priority: high ```md Detailed task description here. Can contain multiple lines and markdown formatting. ``` ``` ## Detail Files (tasks/T-XXX.md) When using `detail: ./tasks/T-XXX.md`, the file must follow this format: ```markdown # T-001 - steps: - [ ] Step 1 (not completed) - [x] Step 2 (completed) - [ ] Step 3 (not completed) ```md Detailed task description. Can include context, requirements, examples, etc. ``` ``` ### Steps Format - Use `- [ ]` for uncompleted steps - Use `- [x]` for completed steps - Indentation: minimum 6 spaces before `-` - Example: ```markdown - steps: - [ ] Research existing patterns - [x] Create schema design - [ ] Implement endpoints ``` ## Important Rules 1. **Indentation**: All task properties must have 2 spaces indentation 2. **Date Format**: Always use `YYYY-MM-DD` for all dates 3. **Unique IDs**: Each task must have a unique ID in format `T-XXX` 4. **Tags**: Use arrays in format `[tag1, tag2]` with commas and spaces 5. **Descriptions**: Use markdown code blocks with ` ```md ` for descriptions 6. **Steps**: Only in detail files, not in main TASKS.md 7. **Sections**: Maintain Kanban sections (Backlog, Doing, Review, Done, Paused) ## Status Flow - **Backlog** → **Doing**: When work starts - **Doing** → **Review**: When awaiting review - **Review** → **Done**: When approved/completed - **Doing** → **Paused**: When temporarily paused - **Paused** → **Doing**: When resumed ## Complete Examples ### Simple Task (no detail file) ```markdown ### Implement user authentication - id: T-010 - tags: [authentication, security, backend, frontend] - priority: high - workload: Hard - milestone: sprint-26-1_2 - start: 2026-01-15 - due: 2026-02-15 ``` ### Task with Inline Description ```markdown ### Create analytics dashboard - id: T-011 - tags: [frontend, dashboard, analytics, visualization] - priority: medium - milestone: sprint-26-1_2 - start: 2026-01-15 - due: 2026-02-10 ```md Create an analytics visualization with charts and metrics. Include filters by date and category. ``` ``` ### Task with Detail File ```markdown ### Implement n:n reconciliation between multiple sources - id: T-001 - tags: [reconciliation, multiple-sources, n-to-n, backend, database] - priority: high - workload: Hard - milestone: sprint-26-1_1 - start: 2026-01-01 - due: 2026-01-26 - detail: ./tasks/T-001.md - defaultExpanded: false ``` ## Common Mistakes to Avoid 1. Don't use incorrect indentation (must be 2 spaces for properties) 2. Don't mix date formats (always `YYYY-MM-DD`) 3. Don't forget to update `updated` when modifying tasks 4. Don't put steps directly in TASKS.md (only in detail files) 5. Don't use duplicate IDs 6. Don't forget to move tasks between sections when status changes ## Best Practices 1. Use sequential IDs (`T-001`, `T-002`, etc.) 2. Keep tags consistent and descriptive 3. Update `updated` whenever you modify a task 4. Use `detail` for complex tasks with many steps 5. Set `defaultExpanded: true` for important tasks 6. Use milestones to group related tasks 7. Keep Kanban sections organized ## References - See `example-tasks/TASKS.md` for complete examples - See `example-tasks/tasks/` for detail file examples - See `example-tasks/README.md` for detailed documentation
Note: This ensures AI assistants understand the task format and maintain compatibility with the extension.

From VS Code Marketplace

  1. Open VS Code Extensions view (Ctrl+Shift+X / Cmd+Shift+X)
  2. Search for "Markdown Kanban Roadmap"
  3. Click Install

From VSIX File

code --install-extension markdown-kanban-roadmap-*.vsix
Note: After installation, restart VS Code to activate the extension.

Usage

1. Create a TASKS.md File

Create a markdown file (typically named TASKS.md) with the following structure:

TASKS.md# Tasks - project-name

## Backlog

### My First Task

  - id: T-001
  - tags: [backend, api]
  - priority: high
  - workload: Medium
  - start: 2026-01-15
  - due: 2026-01-30

## Doing

## Review

## Done

## Paused

## Notes

2. Open Kanban View

You have three ways to open the Kanban board:

3. Manage Tasks

Task Format

Required Properties

ID

- id: T-001

Unique identifier in format T-XXX

Optional Properties

Tags

- tags: [backend, frontend, ui]

Array of tags for categorization

Priority

- priority: high|medium|low

Task priority level

Workload

- workload: Easy|Normal|Hard|Extreme

Estimated effort required

Dates

- start: YYYY-MM-DD
- due: YYYY-MM-DD

Start and due dates

Milestone

- milestone: sprint-26-1_1

Group related tasks

Detail File

- detail: ./tasks/T-001.md

Link to detailed task file

Complete Example

Example with detail file reference:

TASKS.md### Implement user authentication

  - id: T-010
  - tags: [authentication, security, backend, frontend]
  - priority: high
  - workload: Hard
  - milestone: sprint-26-1_2
  - start: 2026-01-15
  - due: 2026-02-15
  - detail: ./tasks/T-010.md
  - defaultExpanded: false

Corresponding detail file:

tasks/T-010.md# T-010

  - steps:
      - [ ] Set up JWT token generation
      - [ ] Implement login endpoint
      - [ ] Create registration flow
      - [ ] Add password reset functionality
    ```md
    Implement complete authentication system with JWT tokens.
    Include login, registration, and password reset functionality.
    
    Requirements:
    - Secure token storage
    - Refresh token mechanism
    - Password hashing with bcrypt
    ```
Important: Use exactly 2 spaces for indentation. All task properties must be indented with 2 spaces.

Features

Kanban Board View

Kanban Board View

Roadmap View

Roadmap View

How to Open Kanban

How to Open Kanban

Feature Overview

Kanban Board

Interactive Kanban board with drag & drop support

Roadmap View

Timeline view of tasks with start and due dates

Tag Filtering

Filter tasks by tags (supports multiple tags)

Sorting

Sort by name, date, priority, workload

Task Details

Support for detailed task files and inline descriptions

Real-time Sync

Two-way synchronization between Kanban and Markdown

AI Development Rules

For AI Assistants: This extension includes comprehensive rules for AI assistants to properly create and manage tasks. These rules ensure compatibility and maintain consistency across projects.

Rules Documentation

The project includes detailed rules in the rules/ directory:

.cursorrules

Rules for Cursor IDE - copy to User Rules

rules/.cursorrules

AGENTS.md

Comprehensive rules for any AI assistant working with Markdown Kanban files

rules/AGENTS.md

CLAUDE.md

Specific rules and quick reference for Claude AI

rules/CLAUDE.md

Key Rules for AI Assistants

Task Creation

Task Properties

File Structure

TASKS.md structure# Tasks - project-name

## Backlog
## Doing
## Review
## Done
## Paused
## Notes

Detail Files

For complex tasks, create separate detail files:

tasks/T-001.md# T-001

  - steps:
      - [ ] Step 1
      - [x] Step 2 (completed)
      - [ ] Step 3
    ```md
    Detailed task description here.
    Can include multiple lines and formatting.
    ```
Best Practice: When working with TASKS.md files, always refer to the rules in rules/ directory to ensure proper format and compatibility.

Quick Reference

# Task format
### Task Name

- id: T-001
- tags: [tag1, tag2]
- priority: high
- workload: Medium
- start: 2026-01-15
- due: 2026-01-30

Team Organization Patterns

Choose the organization pattern that best fits your team size and project structure:

Pattern 1: Centralized TASKS.md in Main Branch

Ideal for: Small to medium teams, projects with few modules

Structureproject/
  ├── TASKS.md          # Single file in main branch
  ├── src/
  └── tasks/            # Detail files
      ├── T-001.md
      └── T-002.md

Advantages

  • Single centralized view
  • Easy to track overall progress
  • Simple to implement
  • Ideal for smaller projects

Disadvantages

  • Frequent merge conflicts
  • Requires discipline to update
  • Can become too large
  • Difficult parallel work
Workflow: Everyone works on main, creates feature branches, and updates TASKS.md when needed. Reference task IDs in commits (e.g., "Fixes T-001").

Pattern 2: TASKS.md per Module/Component

Ideal for: Large projects, large teams, modular architecture

Structureproject/
  ├── frontend/
  │   ├── TASKS.md
  │   └── tasks/
  ├── backend/
  │   ├── TASKS.md
  │   └── tasks/
  ├── shared/
  │   ├── TASKS.md
  │   └── tasks/
  └── TASKS.md          # General/cross-cutting tasks

Advantages

  • Clear organization by context
  • Fewer merge conflicts
  • Teams work independently
  • Scalable for large projects

Disadvantages

  • Multiple files to manage
  • Fragmented project view
  • Requires coordination
  • Possible duplicate tasks
Workflow: Each team/module maintains its own TASKS.md. Use a root TASKS.md for cross-cutting tasks. IDs can be prefixed (e.g., FE-T-001, BE-T-001).

Pattern 3: Dedicated Branch for Tasks

Ideal for: Teams wanting to separate planning from code, projects with many developers

StructureBranch: main
  └── project code

Branch: tasks/kanban
  └── TASKS.md
  └── tasks/
      ├── T-001.md
      └── T-002.md

Advantages

  • Clear separation of planning and code
  • Zero conflicts with code
  • Can have multiple TASKS.md by context
  • Independent task history

Disadvantages

  • More complex workflow
  • Requires periodic merging
  • Can become outdated
  • Less integrated with code
Workflow: Maintain a tasks/ or kanban/ branch for task management. Feature branches reference tasks by ID. Periodically merge the tasks branch into main.

Pattern 4: Hybrid (Recommended)

Ideal for: Most projects, balance between simplicity and organization

Structureproject/
  ├── TASKS.md          # Overview in main
  ├── tasks/            # Details
  │   ├── T-001.md
  │   └── T-002.md
  └── docs/
      └── TASKS-PLANNING.md  # Future planning

Advantages

  • Balance between simplicity and organization
  • Main TASKS.md for overview
  • Separate detail files
  • Flexible and adaptable
  • Works well with Git Flow

Disadvantages

  • Occasional conflicts still possible
  • Requires team discipline
  • May need adjustments as it grows
Workflow: Main TASKS.md in main branch with overview. Feature branches reference tasks by ID in commits. Use milestones to group related tasks. For future planning, use a separate file (e.g., TASKS-PLANNING.md).

Pattern 5: TASKS.md per Feature/Epic

Ideal for: Projects with large features, agile methodology with epics

Structureproject/
  ├── features/
  │   ├── auth/
  │   │   └── TASKS.md
  │   ├── dashboard/
  │   │   └── TASKS.md
  │   └── api/
  │       └── TASKS.md
  └── TASKS.md          # General tasks

Advantages

  • Organization by feature/epic
  • Easy to track feature progress
  • Fewer conflicts
  • Aligns with agile methodology

Disadvantages

  • Multiple files
  • Features may have related tasks
  • Requires coordination
Workflow: Each feature/epic has its own TASKS.md. Use root TASKS.md for general tasks. IDs can include feature prefix (e.g., AUTH-T-001).

Recommendations by Team Size

1-3 Developers

Recommended: Pattern 1 (Centralized) or Pattern 4 (Hybrid)

Simplicity is more important than complex organization.

4-8 Developers

Recommended: Pattern 4 (Hybrid) or Pattern 2 (Per Module)

Balance between organization and simplicity.

9+ Developers

Recommended: Pattern 2 (Per Module) or Pattern 5 (Per Feature)

Organization and separation of concerns are essential.

General Tip: Start simple (Pattern 1 or 4) and evolve as needed. It's easier to migrate to a more complex pattern than to simplify later.

Examples

Basic Task

TASKS.md### Fix login bug

  - id: T-005
  - tags: [bug, frontend, authentication]
  - priority: high
  - workload: Easy

Task with Dates

TASKS.md### Implement dark mode

  - id: T-012
  - tags: [ui, frontend, feature]
  - priority: medium
  - workload: Normal
  - start: 2026-01-20
  - due: 2026-02-05

Task with Detail File

TASKS.md### Build API endpoints

  - id: T-020
  - tags: [backend, api, rest]
  - priority: high
  - workload: Hard
  - detail: ./tasks/T-020.md
Tip: See the example-tasks/ directory in the repository for complete working examples.