Transform Project Management with Git and AI: backlog.md

#productivity #git #mcp

Original post

In modern software development, project management usually lives separately from the code itself. Tools like JIRA, Asana, Monday, ClickUp, or Trello are the industry standard for managing tasks. However, this practice, while powerful, creates a disconnect from where the magic really happens: the code repository. It often forces developers to lose focus by context-switching.

What if you could stay focused and manage the entire project—tasks, documentation, and decisions—directly from the command line, using Markdown files and a Git-native approach?

Today, we're going to explore a tool that does just that. 🚀

Backlog.md: Git-Native Project Management

Backlog.md is an innovative command-line interface (CLI) tool that transforms any Git repository into a self-contained project board. Its approach is simple yet revolutionary: it uses Markdown files to manage everything, allowing project administration to live directly inside your code, versioned and accessible to anyone with access to the repository.

Principles and Architecture

Built with Bun and TypeScript, backlog.md is a zero-configuration npm package. All tasks, drafts, documents, and decisions are stored as Markdown files with YAML metadata in a backlog/ directory. This means every change to the project is a Git commit.

.
└── backlog
    ├── archive
    │   ├── drafts
    │   └── tasks
    ├── completed
    ├── config.yml
    ├── decisions
    ├── docs
    ├── drafts
    └── tasks

Its CLI, based on Commander.js, offers an intuitive set of commands for the entire project lifecycle, from backlog task create to backlog board view.

$ backlog --help
Usage: backlog [options] [command]

Backlog.md - Project management CLI

Options:
  -v, --version           display version number
  -h, --help              display help for command

Commands:
  init [options] [projectName]   initialize backlog project in the current repository
  task|tasks [options] [taskId]
  draft [options] [taskId]
  board [options]           display tasks in a Kanban board
  doc
  decision
  agents [options]          manage agent instruction files
  config
  cleanup                   move completed tasks to completed folder based on age
  browser [options]         open browser interface for task management (press Ctrl+C or Cmd+C to stop)
  overview                  display project statistics and metrics
  help [command]            display help for command

Key Features That Make a Difference

Hierarchical Task Management: Tasks are organized with a clear numbering system (e.g., task-42, task-42.1), facilitating parent-child relationships and the breakdown of complex problems.

$ backlog task create "Parent Test task" -d "This is the parent test task description" -l "test" --ac "ac1,ac2,ac3"
Created task task-1
File: /home/kratos/Development/the-dave-stack/social/backlog.md/backlog/tasks/task-1 - Parent-Test-task.md
$ backlog task create "Child Test task" -d "This is the child test task description" -l "test" --ac "ac1,ac2,ac3" -p "task-1"
Created task task-1.1
File: /home/kratos/Development/the-dave-stack/social/backlog.md/backlog/tasks/task-1.1 - Child-Test-task.md
$ tree -L 3 .
.
└── backlog
    ├── archive
    │   ├── drafts
    │   └── tasks
    ├── completed
    ├── config.yml
    ├── decisions
    ├── docs
    ├── drafts
    └── tasks
        ├── task-1.1 - Child-Test-task.md
        └── task-1 - Parent-Test-task.md

Focus on Outcomes: One of its best ideas is the distinction between Acceptance Criteria (the what must be achieved, in a measurable way) and Implementation Plans (the how it will be technically solved). This brings immense clarity to the process.

---
id: task-1
title: Parent Test task
status: To Do
assignee: []
created_date: '2025-08-23 14:20'
labels:
  - test
dependencies: []
---

## Description

This is the parent test task description

## Acceptance Criteria
- [ ] ac1
- [ ] ac2
- [ ] ac3

Designed for AI: backlog.md treats AI agents as first-class citizens. It provides structured plain-text outputs and even instruction files (AGENTS.md) to guide language models, preparing them for true collaboration.
Deep Git Integration: Every operation is an atomic and descriptive commit. Its ability to synchronize tasks between different branches is simply brilliant, intelligently resolving conflicts.
Web Interface: Although it's a CLI-first tool, it also features a React web interface that includes interactive Kanban boards, complementing the terminal experience.

Taking Backlog.md to the Next Level with AI: `mcp-backlog-md`

The AI-oriented design of backlog.md solves a major initial problem: it presents project information in a structured way. Thanks to this, an AI agent can easily understand the status of tasks. However, this doesn't solve the next challenge: how do we give that AI the ability to execute actions safely and in a standardized way? Historically, every tool that wanted to connect with an AI needed a unique, custom connector, resulting in a fragile and costly-to-maintain ecosystem of integrations.

To solve this, the Model Context Protocol (MCP) was born—an open standard aiming to be the "USB-C of AI." Just as USB-C unified peripheral connections, MCP standardizes how LLMs connect to external tools and data sources.

Instead of forcing the AI to parse CLI output, an MCP server offers it a catalog of capabilities (tools, resources, and prompts) that it understands natively. It's the difference between having to "read a manual" and plugging in a device that "just works."

This is exactly what I've built with mcp-backlog-md: an MCP server that exposes the functionalities of backlog.md as a set of native tools for AI. This eliminates the fragility of text parsing and adopts a robust, standard protocol, enabling much deeper and more reliable collaboration.

Full Integration via MCP Tools

My implementation exposes the entire functionality of backlog.md through a set of MCP tools, allowing an AI agent to:

Manage tasks: createTask, editTask, viewTask, listTasks.
Work with drafts and documents: createDraft, promoteDraft, createDoc.
Check the project status: exportBoard.
And much more...

Most importantly, mcp-backlog-md offers full feature parity with the original CLI, ensuring that the AI has the same power and flexibility as a human user.

Conclusion

In a world dominated by complex project management platforms that are often disconnected from our workflow, backlog.md emerges as a refreshing and powerful alternative. Its "Git-native" philosophy gives control back to the developer, integrating task management directly where the code is born. It offers an agile and transparent solution for teams and professionals who value simplicity and efficiency over overwhelming features.

And for those who, in addition to this simplicity, want to explore the frontier of AI collaboration, the ecosystem is ready. My project, mcp-backlog-md, acts as that precise connector, allowing an AI agent to safely integrate into this system to assist with management.

Thus, backlog.md is not only an excellent tool in itself but also a solid foundation on which to build advanced, AI-assisted workflows.

Want to try it out?

I invite you to explore both projects. You can find the original tool in its repository and my MCP server implementation in mine.

Backlog.md Repository: https://github.com/MrLesk/Backlog.md
My MCP Server mcp-backlog-md: https://github.com/The-Dave-Stack/mcp-backlog-md

I'd love to hear your thoughts in the comments! Do you think this "Git-native" approach has a future? What tasks would you delegate to an AI agent in your projects?