Why Plain Text Task Management Is the Right Move in the AI Age

Most task managers are apps that own your data.

Notion. Linear. Jira. Todoist. They all have the same fundamental contract: give us your tasks, we’ll store them, you access them through our interface.

That works until it doesn’t — until the app goes away, the API changes, the export is broken, or an AI agent entering your codebase has no idea what you’re working on because your task list is in a separate silo that it can’t see.

There’s a better contract.

The Philosophy: Tasks Live Next to Code

The idea is simple: every project gets a TODO.md in its root directory.

# TODO — my-app

## Current
- [ ] Fix the login redirect bug
- [ ] Add rate limiting to the auth endpoint

## Backlog
- [ ] Migrate to Postgres

## Done
- [x] Set up CI pipeline — 2026-04-20

Plain Markdown. No schema. No database. No sync service. Readable by any editor, any terminal, any human, and critically — any AI.

When a project is done, its task history is in the repository alongside the code. When you revisit a project six months later, git log tells you what changed, and TODO.md tells you what was on the table. Both are in the same place.

This isn’t a new idea. Developers have been dropping TODO.md files into projects for years. What’s new is that this pattern is now worth formalizing — because of AI.

Why This Matters More Now

AI coding assistants — Claude, Copilot, Cursor, Gemini — work best when they understand context. And context, for a project, includes:

• What’s currently being worked on
• What’s deferred
• What’s already done

If that context lives in a TODO.md next to the code, any AI entering the project in any session sees the current state immediately. No prompt engineering required. No “here’s what we’re working on” preamble every single time.

A task file that lives outside the repo is invisible to AI. A TODO.md that lives inside the repo is always in scope.

This is the real argument for plain text task management in 2026: it makes your projects AI-readable by default.

Building a CLI for It

The philosophy is useful on its own. But a CLI makes it frictionless. I built tasks — a per-project task manager with auto-discovery, a rollup view, and a live-watching TUI.

Install

git clone https://github.com/techiediaries/tasks-cli
cd tasks-cli
npm install
ln -sf "$(pwd)/bin/tasks.js" ~/.local/bin/tasks

Initialize a project

cd my-app
tasks init

This creates TODO.md in the current directory and registers the parent directory as a root to watch. From that point on, tasks anywhere on your system knows this project exists.

Add tasks

tasks add "Fix the login redirect bug"
tasks backlog "Migrate to Postgres"
tasks done "Fix the login redirect bug"
tasks note "Auth uses JWT with 1h expiry"

Notes go to NOTES.md in the same directory — same format, same philosophy.

The rollup

Running tasks without arguments shows every project with open tasks:

  📁 my-app          2 current, 1 backlog
     [ ] Fix the login redirect bug
     [ ] Add rate limiting to the auth endpoint

  📁 side-project     1 current
     [ ] Deploy to production

No configuration. It scans registered root directories 2 levels deep and surfaces any directory that has a TODO.md.

Auto-Discovery, Not Manual Registration

The critical design decision: projects are discovered by TODO.md presence, not by manual registration.

You don’t tell the tool “watch this project.” You run tasks init inside it, which creates the file, and from then on the tool finds it automatically. If you delete TODO.md, the project disappears from the rollup. If you create one somewhere new, it appears.

This keeps the tool honest. The list shows exactly what’s initialized, nothing more.

On Linux, the tool auto-registers common developer directories as roots on first run — ~/Projects, ~/dev, ~/work, and others — so projects in those directories are found the moment you tasks init inside them.

The TUI

tasks ui launches a full-screen terminal interface built with blessed.

It uses chokidar for file watching — not Node’s built-in fs.watch, which doesn’t support recursive watching on Linux. When any TODO.md anywhere in a watched root changes, the TUI updates in real time.

Key bindings:

The sidebar shows open task counts per project. Pinned projects sort to the top.

The File Format Is the API

One of the underrated benefits of this approach: the file format is the API.

Any tool that can read Markdown can read your tasks. That includes:

• Every text editor
• grep, cat, less
• AI coding assistants
• Git history
• Any script you write

There’s no SDK to install, no token to manage, no rate limit to hit. You own the data completely. The CLI is a convenience layer on top of a convention — not the other way around.

If the tool disappears tomorrow, your TODO.md files are still there.

Platform Support

The codebase has a platform abstraction layer at lib/platform/. Currently Linux is fully supported. macOS should work without changes. Windows support is stubbed — getDefaultRoots() returns [] until someone implements the standard folder detection. The architecture is there; it’s just waiting.

Get It

The tool is open source at github.com/techiediaries/tasks-cli.

Built by Ahmed Bouchefra.

The argument for plain text task management isn’t that it’s simpler (though it is). It’s that it’s honest — your tasks are where your code is, versioned alongside it, readable by everything, owned by no one but you.

In the age of AI-assisted development, that honesty is also a superpower.

• Date: 26 Apr 2026