tod

Task management should live where you work. For most developers, that place is the terminal, not a browser tab that competes with Slack, email. And the next distraction. After years of context-switching between my editor and a dozen SaaS productivity apps, I moved my daily task list to a command-line interface that talks directly to Todoist. That tool is tod, a Rust-based CLI that keeps project planning inside the same environment where the code lives.

If you spend more than half your day in a terminal, tod can shrink the gap between "I need to do this" and "it is tracked. " It isn't a replacement for long-form project planning, but it's the fastest way I have found to capture tasks, schedule work. And close tickets without leaving the keyboard. In this article, I will walk through what tod does, how to set it up. And why it became a permanent fixture in my engineering workflow.

What Is the Tod CLI and Why It Exists

Tod is an open-source command-line client for Todoist, written in Rust and distributed through GitHub and Cargo. Its purpose is simple: give keyboard-driven developers a way to create, list, complete. And organize Todoist tasks from the shell. The project exists because Todoist's own web and mobile interfaces, while polished, force a context switch every time you want to update a task. For someone running tests, reviewing logs. Or debugging in a terminal, that switch is expensive.

At its core, tod is a thin wrapper around the Todoist REST API, storing your API token locally and translating shell commands into authenticated HTTP requests. This means your data still lives in Todoist's cloud, your team members can see updates through the standard app, and you get the benefit of Todoist's natural-language parsing without opening a browser. The CLI translates intent into action with minimal ceremony.

Installing Tod on Linux macOS and Windows

The cleanest install path is through Cargo, Rust's package manager. If you already have a Rust toolchain installed, running cargo install tod usually pulls the latest release and drops the binary into your path. On macOS, Homebrew users can also tap the repository if a formula is available. Windows developers can build from source with the same Cargo command or download a precompiled binary from the project's releases page.

After installation, the first step is authentication. You generate a personal API token from the Todoist settings page and run the setup command. Which writes the token to a local configuration file. Keep that file out of version control. I store mine at ~/, and config/todcfg and sync dotfiles separately. Since once the token is in place, tod project list should return your Todoist projects, confirming the handshake with the API.

Core Commands That Make Tod Productive

The command set is deliberately small. You can create tasks, list tasks, complete tasks, and browse projects. A typical morning starts with tod task list to surface everything due today. When a code review reveals a follow-up, I run tod task create "refactor auth middleware" --project work --priority 2 without switching windows. The task lands in Todoist immediately and appears in my list the next time I check.

Natural-language due dates are one of the biggest wins. Phrases like "tomorrow," "next Monday," or "in 3 days" are parsed on Todoist's side, so the CLI can pass them through unchanged. Priorities map to Todoist's p1-p4 scale. And labels can be attached with the appropriate flag. The result is a workflow where capturing a task takes less time than deciding whether it's worth capturing. Learn how we organize engineering sprints in the terminal

Integrating Tod Into Your Development Workflow

The real power of tod comes from integration, not isolation. I keep a small terminal pane open beside my editor running tmux. When a test fails and needs investigation, I create a task in place. When a stand-up item needs tracking, I add it before I forget the context. Because the CLI exits quickly, it never breaks flow state the way a web app does.

You can also alias common commands in your shell. I have td mapped to tod task list, tca mapped to a command that completes a selected task, tn for quick capture. These aliases make the tool feel native. Git hooks are another natural fit: a post-commit hook can remind me to update related tasks. Or a pre-push hook can warn me if high-priority tasks are still open. The CLI becomes infrastructure for attention.

Comparing Tod to Other Task Managers

Tod isn't the only terminal task manager. But its integration with Todoist distinguishes it from tools like Taskwarrior or todo txt. Those alternatives are excellent for purely local lists, yet they lack the cloud sync, mobile apps, and collaboration features that modern teams expect. With tod, I can add a task from the terminal and my product manager can see it in Todoist ten seconds later.

On the other hand, tod is less feature-complete than the Todoist web app. You can't easily rearrange sub-projects, attach files. Or manage kanban boards from the CLI. If your job revolves around visual planning, you will still need the browser. I use tod for capture and triage, then switch to the web interface for weekly reviews. That division keeps daily execution fast without sacrificing planning depth. See our comparison of CLI productivity tools for remote teams

Advanced Features Power Users Should Know

Beyond basic CRUD operations, tod supports task prioritization, due-date assignment. And project filtering. You can list tasks for a single project. Which is useful when you want to focus on one codebase or one initiative. Some versions also support recurring task creation and label management, though the exact feature set evolves with each release. Check the official tod GitHub repository for the latest flags.

One underrated capability is piping and shell scripting. Because tod returns plain text, you can pipe its output into fzf for fuzzy selection, into grep for filtering. Or into a custom script that formats your daily stand-up update. I have a shell function that combines tod task list with git log --since="24 hours ago" to produce a concise status report. That kind of composability is hard to replicate in a graphical app.

Common Pitfalls When Adopting Tod

New users often try to replace Todoist entirely with the CLI and end up frustrated. Tod is designed for speed, not completeness. If you attempt to manage complex dependencies, comments, and attachments through terminal commands, you will fight the tool. The better approach is to use tod for the 80% of actions that are simple and fast, then drop into the web or mobile app for the remaining 20%.

Another pitfall is leaking your API token. Because authentication relies on a personal token, it's tempting to store it in an environment variable exported in your shell profile. That is acceptable on a private machine. But dangerous in shared environments or CI pipelines. Treat the token like a password. Rotate it periodically, and never commit configuration files that contain it. Following these habits keeps your Todoist data secure.

Why Terminal-Based Task Management Still Matters

There is a persistent idea that terminal tools are nostalgic rather than practical. In my experience, the opposite is true. The command line offers lower latency, better composability. And fewer notifications than any modern web app. When I am debugging a production incident, I don't want to open a browser to record an action item. I want to type a short command and stay focused on the log stream,

Terminal tools also age wellA CLI script I wrote five years ago still runs today because it depends on stable shell conventions, not a redesigned user interface. Tod benefits from this longevity. Even if Todoist updates its visual design, the underlying REST API and the CLI commands built on top of it remain predictable. That stability matters for engineering workflows that span years. Explore our guide to Building durable developer tooling

Building Automated Workflows Around Tod

Once tod is part of your environment, automation becomes natural. I use a Makefile target that creates a release checklist from a template, spawning tasks for version bumping - changelog updates. And smoke tests. Each task is assigned to the right Todoist project with a due date relative to the release day. This turns a repetitive manual process into a single command.

Another workflow combines tod with issue trackers. When I close a GitHub issue, a GitHub Action can append a reminder to my Todoist inbox to verify the fix in staging. I then use tod to triage that reminder from the terminal. Bridging systems this way reduces the chance that important items fall through the cracks. The CLI acts as a lightweight adapter between the tools you already use.

Frequently Asked Questions About Tod

• Does tod require a paid Todoist account? No. Tod works with both free and paid Todoist accounts. Though some features such as reminders and larger project limits depend on your Todoist plan, not the CLI.
• Can I use tod offline? Tod needs an internet connection because it communicates with the Todoist API. If you need offline task capture, pair it with a local note file and sync later.
• Is tod available on Windows. YesYou can install it via Cargo or download a precompiled binary from the project's releases page. Windows Terminal and PowerShell both work well.
• Where is my Todoist API token stored? The token is stored in a local configuration file on your machine. Keep that file out of version control and treat it like a password,
• Can tod manage shared team projects Yes. Because tod writes to Todoist, tasks created in shared projects are visible to teammates who use the Todoist web or mobile apps.

Bringing Tod Into Your Daily Practice

Tod won't fix a broken productivity system. But it will remove friction from a good one. The transition is easiest if you start with one habit: capture every new task from the terminal for one week. You will quickly notice how rarely you need to open Todoist during focused work. After that week, add aliases, scripts. And hooks that match the way your team operates.

The best developer tools are the ones that disappear into the workflow. Tod has done that for me. It lives in the same terminal where I run tests, inspect logs, and deploy services. If you value speed and keyboard control, it is worth an afternoon of experimentation. Install it, connect your Todoist account. And see whether your task list feels closer to your code.

What do you think?

Has a command-line task manager changed the way you work,? Or do you prefer the visual structure of a web-based tool?

What shell integrations or automations would make tod indispensable in your current development environment?

Should modern productivity apps prioritize terminal interfaces, or is the command line destined to remain a niche for power users?