CLI Productivity Tools for Developers: Writing, Tasks, Projects & Daily Workflow
cli productivity terminal tasks documentation note-taking project-management writing workflow organization open-source time-management focus

CLI Productivity Tools for Developers: Writing, Tasks, Projects & Daily Workflow

Master command-line tools for personal productivity. Organize tasks, manage projects, write documentation, and stay organized—all from the terminal.

By Omar Flores

Introduction: The Terminal is Your Productivity Hub

Most developers use the terminal for coding only. Wrong.

Your terminal can be your entire productivity system.

Why?

Because terminal tools are:

  • Fast (no GUI overhead, no mouse required)
  • Scriptable (automate everything)
  • Portable (work on any machine)
  • Keyboard-driven (no context switching to mouse)
  • Open source (free, customizable)
  • Pipeable (chain tools together)

A developer who masters CLI productivity tools outships a developer who bounces between web apps and GUIs.

This guide teaches you the CLI tools that matter for daily productivity.

Not DevOps tools. Not deployment tools.

Tools for organizing your life, your work, your thoughts, your time.

Chapter 1: Task Management from the Terminal

Most developers use a web app for tasks. Mistake.

Terminal task tools are faster. They integrate with your workflow. They keep you focused.

Todo.txt - The Simplest Format

Todo.txt is a text-based task format. Super simple.

Write blog post about CLI tools
Buy groceries
Fix bug in payment module +urgent
Call manager @work

Format:

(A) Task description +project @context due:2026-02-20
  • (A), (B), (C) = priority
  • +project = project tag
  • @context = context tag
  • due:date = due date

Why this format:

  • Works in any text editor
  • Version control friendly (Git sees changes)
  • Portable (copy anywhere)
  • Simple (no complex software)

Tools:

  • todo-cli or todotxt-cli - Simple task manager
  • Plain text with grep and sort

Installation:

brew install todotxt-cli

Usage:

# Add task
todo add "Write blog post +writing"

# List all
todo list

# List by project
todo list +writing

# Mark done
todo do 1

# View
cat ~/todo.txt

Time saved: 30 min/week (no context switching to web app)

Taskwarrior - More Powerful

Taskwarrior is a feature-rich task manager. Still terminal-based. Still simple.

# Install
brew install task

# Add task
task add "Write blog post"
task add "Fix bug" due:2026-02-20 priority:H

# List
task list

# Check what's due today
task due

# Report (custom views)
task burndown.weekly
task history.yearly

# Sync (with taskserver)
task sync

Features:

  • Priorities
  • Tags
  • Due dates
  • Recurring tasks
  • Reporting
  • Filtering
  • Burndown charts

Config in ~/.taskrc:

# Change report format
report.next.labels=ID,Active,Tag,Project,Recur,Priority,Due,Until,Description
report.next.sort=due+,priority-,entry+

Time saved: 1-2 hours/week (powerful workflows, no web app switching)

Remind - Simple Event/Task Reminders

Remind is an old tool that still works. Tracks dates and sends reminders.

# ~/.reminders

# Format: REMIND date message

REM Jan 1 +1 "New Year"
REM Feb 14 "Valentine's Day"
REM 15 +2 "Dentist appointment" AT 10:00

# Weekly reminders
REM Monday +1 "Weekly standup" AT 9:00

# Monthly reminders
REM 1 +1 "Review expenses"

Then run:

remind -c ~/.reminders
# Output: Reminders for this week

Add to cron to get daily reminders:

# Every morning at 8 AM
0 8 * * * remind -c ~/.reminders | mail -s "Daily reminders" your@email.com

Time saved: 30 min/week (no forgetting things)

Chapter 2: Note-Taking from the Terminal

Most developers use Notion or Evernote. They’re slow. They’re complex.

Better: Simple text files + terminal tools.

Plain Text Notes with Folders

Simplest approach: Just use folders and text files.

~/notes/
├── 2026-02-17.md     (daily notes)
├── projects/
│   ├── blog-series.md
│   ├── cli-tools.md
│   └── architecture.md
├── ideas/
│   ├── startup-ideas.md
│   └── book-ideas.md
└── references/
    ├── go-concurrency.md
    └── system-design.md

Advantages:

  • Works with any editor
  • Version control with Git
  • Search with grep
  • Fast

Daily notes pattern:

# Create today's note
touch ~/notes/$(date +%Y-%m-%d).md

# Edit in vim
vim ~/notes/$(date +%Y-%m-%d).md

# Search all notes
grep -r "topic" ~/notes/

# This week's notes
find ~/notes -type f -mtime -7

Make a function for daily notes:

# In ~/.config/fish/config.fish
function today
    vim ~/notes/$(date +%Y-%m-%d).md
end

function notes
    cd ~/notes && vim .
end

function findnote
    grep -r "$argv" ~/notes/
end

Then:

today          # Open today's note
notes          # Browse all notes
findnote topic # Search all notes

Time saved: 2-3 hours/week (instant note-taking, searchable)

Obsidian + Git (Hybrid)

Obsidian is a GUI app, but it stores files in plain text.

You get Obsidian’s nice interface, but your notes are just files (version control friendly).

# Initialize git repo in Obsidian vault
cd ~/Obsidian\ Vault
git init
git add .
git commit -m "Initial commit"

# Work in Obsidian (create notes, links, tags)
# Periodically commit from terminal
git add .
git commit -m "Added notes on CLI tools"
git push  # to GitHub

Hybrid approach:

  • Obsidian for fancy stuff (linking, searching, visualization)
  • Terminal for Git (version control, history, branching)

Time saved: 1-2 hours/week (powerful note-taking + version control)

Zettelkasten (Note-Linking System)

Zettelkasten is a note-taking method. Each note is small and linked.

Note: 202602171.md
---
Title: CLI Productivity
Topics: #productivity #tools #cli
Related: 202602168 202602170

Content: CLI tools are fast because...

Link to: 202602172 (Go Concurrency)

Then create a map:

# Extract all links
grep -h "Link to:" notes/*.md | sort | uniq > map.txt

# Create network visualization
cat map.txt | graphviz > network.png

Benefits:

  • Ideas connect
  • Easy to grow
  • Searchable by connection

Terminal workflow:

# Create new note
touch notes/$(date +%s).md

# Search by topic
grep -l "#productivity" notes/*.md

# See what's linked to note
grep "202602171" notes/*.md

Time saved: Not immediate, but compound over time (knowledge system that connects)

Chapter 3: Writing & Documentation Tools

Markdown + Editor

All documentation should be Markdown. All.

# Edit
vim project-guide.md

# Convert to HTML (for publishing)
pandoc project-guide.md -o project-guide.html

# Convert to PDF
pandoc project-guide.md -o project-guide.pdf

# Convert to Word
pandoc project-guide.md -o project-guide.docx

Why Markdown:

  • Plain text (version control friendly)
  • Simple syntax (5 minutes to learn)
  • Renders everywhere
  • Fast to write

Essential Markdown tools:

# Preview in terminal
glow project-guide.md

# Word count
wc -w project-guide.md

# Reading time estimate
pandoc project-guide.md | wc -w | awk '{print int($1/200) " min read"}'

# Check links
markdown-link-check project-guide.md

# Check spelling
aspell check project-guide.md

Time saved: 1-2 hours/week (no switching between tools)

Pandoc - Universal Document Converter

Pandoc is the Swiss Army knife of document conversion.

Convert between ANY formats:

# Markdown to HTML
pandoc README.md -o README.html

# Markdown to PDF
pandoc README.md -o README.pdf

# Word to Markdown
pandoc document.docx -o document.md

# HTML to Markdown
pandoc webpage.html -o webpage.md

# Markdown to Slides
pandoc presentation.md -t beamer -o presentation.pdf

# Multiple files to one
pandoc intro.md chapter1.md chapter2.md -o book.pdf

Time saved: 3-5 hours/week (no copying between tools)

Glow - Terminal Markdown Viewer

Glow renders Markdown beautifully in terminal.

# View markdown
glow README.md

# Browse local markdown files
glow -p       # Opens pager with all .md files

# Fetch from GitHub
glow https://github.com/owner/repo/README.md

Beautiful formatting, syntax highlighting, all in terminal.

Time saved: 30 min/week (no opening files in editor just to read)

Vale - Documentation Linter

Vale checks your writing for style, grammar, tone consistency.

# Install
brew install vale

# Check document
vale README.md

# Output:
# README.md
#  1:5    error   [Vale.Readability]  Flesch-Kincaid Grade Level (15.3) is too high. Try shorter sentences or words.
#  2:10   warning [Vale.PassiveVoice] 'is' detected. Prefer active voice.

Config in .vale.ini:

[*]
BasedOnStyles = Vale, Google, proselint

[*.md]
Google.Headings = NO
Vale.Readability = suggestion

Time saved: 1-2 hours/week (catch issues before publish)

Chapter 4: Project Organization Tools

Tree - Visualize Structure

Show project structure beautifully.

# Install
brew install tree

# View structure
tree -L 2

# Output:
# .
# ├── src/
# │   ├── main.go
# │   └── utils.go
# ├── tests/
# │   └── main_test.go
# ├── README.md
# └── go.mod

# Ignore certain files
tree -I 'node_modules|.git'

# Show only directories
tree -d

# Export to file
tree > structure.txt

Time saved: 10 min/week (quick project overview)

Find + Utilities - Powerful Search

find is incredibly powerful for organizing files.

# Find all Go files modified in last 7 days
find . -name "*.go" -mtime -7

# Find large files
find . -size +100m

# Find files modified today
find . -mtime 0

# Find and count lines
find . -name "*.go" -exec wc -l {} + | tail -1

# Find all TODO comments
find . -name "*.go" -exec grep -H "TODO" {} \;

# Delete old logs
find ./logs -name "*.log" -mtime +30 -delete

# Archive old projects
find ~/projects -type d -mtime +365 -exec tar -czf {}.tar.gz {} \;

Time saved: 2-3 hours/week (automation of manual file tasks)

Ag (The Silver Searcher) - Code Search

Better than grep for searching code.

# Install
brew install the_silver_searcher

# Search
ag "function_name"

# Search in specific files
ag "TODO" --go

# Show file names only
ag -l "error"

# Show with line numbers
ag -n "pattern"

# Case insensitive
ag -i "Pattern"

# Count matches
ag "pattern" --count

Faster than grep. Ignores .gitignore automatically.

Time saved: 1-2 hours/week (faster code searching)

Chapter 5: Time & Focus Management

Pomodoro Timer (Terminal)

Simple terminal timer for Pomodoro technique.

# Install
brew install pomatez    # or pomodoro

# Or use sleep + notify
function pomo() {
    sleep 25m && notify-send "Pomodoro done! Take a break."
}

pomo

Or create a function:

function timer() {
    local minutes=$1
    echo "Timer started for $minutes minutes"
    sleep "${minutes}m" && say "Time is up" && notify-send "⏰ Time is up!"
}

# Usage
timer 25      # 25 minute Pomodoro
timer 5       # 5 minute break

Time saved: 30 min/week (structured focus)

Time Tracking (Simple)

Track time in plain text.

# ~/.timelog

[2026-02-17 09:00] - [09:45] Writing blog post (45 min)
[2026-02-17 10:00] - [12:30] Code review (150 min)
[2026-02-17 13:00] - [14:00] Meeting (60 min)
[2026-02-17 14:15] - [17:00] Development (165 min)

Create a function:

function track() {
    local task=$*
    local start=$(date +"%Y-%m-%d %H:%M")
    echo "[waiting for task completion...]"
    read -p "Press Enter when done: "
    local end=$(date +"%H:%M")
    local mins=$(( ($(date +%s) - $(date -d "$start" +%s)) / 60 ))
    echo "[$start] - [$end] $task ($mins min)" >> ~/.timelog
    echo "✓ Logged: $task ($mins min)"
}

# Usage
track "Writing documentation"
# ... do the task ...
# Press Enter
# ✓ Logged: Writing documentation (25 min)

Then analyze:

# Total time by task
awk '{print $4}' ~/.timelog | sort | uniq -c

# Time this week
grep "$(date +%Y-%m)" ~/.timelog | awk '{print $NF}' | paste -sd+ | bc

# See all tracked
cat ~/.timelog

Time saved: 1-2 hours/week (awareness of where time goes)

Streak - Calendar Visualization

Track daily habits/streaks.

# Install
brew install danielhoherd/automated/Streak

# Mark a day
streak mark

# Show streak
streak show

# Output:
# ✓ ✓ ✓ ✓ ✓ ✓ ✗ ✓ ✓ ✓
# Streak: 3 days (broken on 2026-02-14)

Track consistent habits:

  • Writing
  • Exercise
  • Meditation
  • Coding
  • Learning

Time saved: 30 min/week (motivation through visual tracking)

Chapter 6: File Management & Organization

Fd - Better Find

Find is powerful but verbose. Fd is simpler.

# Install
brew install fd

# Find all JavaScript files
fd "\\.js$"

# Find in specific directory
fd "pattern" src/

# Case insensitive
fd -i "README"

# Show full path
fd -a pattern

# Execute command on matches
fd "\\.log$" -x rm {}     # Delete all .log files

Cleaner syntax than find. Faster.

Time saved: 30 min/week (faster file operations)

Bat - Better Cat

Cat displays file contents. Bat does it with syntax highlighting.

# Install
brew install bat

# View file with highlighting
bat script.sh

# Use as pager
export PAGER="bat"
git log | bat

# Compare files
diff <(bat file1.txt) <(bat file2.txt)

# Show specific lines
bat -r 10:20 file.txt

Time saved: 30 min/week (faster reading code)

Ack - Grep for Programmers

Like grep but optimized for code searching.

# Install
brew install ack

# Search
ack "function_name"

# Search specific file type
ack --go "error"

# Count matches
ack --count "pattern"

# Show only file names
ack -l "pattern"

# Invert match (show lines that DON'T match)
ack -v "debug"

Time saved: 1-2 hours/week (faster code searching)

Chapter 7: Document Generation & Publication

Hugo - Static Site Generator

Build documentation sites from Markdown.

# Install
brew install hugo

# Create site
hugo new site my-docs

# Create page
hugo new docs/cli-tools.md

# Local server
hugo server

# Build
hugo

# Output in public/

Use case: Documentation sites, blogs, project sites.

Time saved: 3-4 hours/week (no manual HTML, Git-based workflow)

Asciidoc - Alternative to Markdown

More powerful than Markdown for technical docs.

== CLI Productivity Tools

=== Installation

[source,bash]
----
brew install tool
----

=== Usage

. Create task
. Complete task
. Archive

.Key features
* Fast
* Scriptable
* Free

Convert:

asciidoctor document.adoc      # To HTML
asciidoctor -b pdf document.adoc   # To PDF

Time saved: 1-2 hours/week (more professional docs)

Reveal.js - Slide Presentations

Create presentations from Markdown.

# Install
npm install -g reveal-cli

# Create presentation
reveal-cli create my-presentation

# Edit in Markdown
# View in browser
reveal-cli open my-presentation

# Export to PDF
reveal-cli export my-presentation --to pdf

Time saved: 2-3 hours/week (no PowerPoint, Git-based slides)

Chapter 8: Personal Automation

Cron Jobs for Productivity

Automate daily/weekly productivity tasks.

# Edit crontab
crontab -e

# Run reminder script every morning
0 8 * * * remind -c ~/.reminders | mail -s "Reminders" you@email.com

# Backup notes every day
0 21 * * * cd ~/notes && git add . && git commit -m "Daily backup"

# Clean up temp files every week
0 2 * * 0 find ~/tmp -mtime +7 -delete

# Generate weekly report
0 9 * * 1 ~/.scripts/weekly-report.sh

# Archive old projects monthly
0 3 1 * * ~/.scripts/archive-old-projects.sh

Time saved: 2-3 hours/week (automation)

Shell Functions for Productivity

Create powerful custom commands.

# ~/.config/fish/config.fish

# Quick project setup
function new-project
    mkdir $argv
    cd $argv
    git init
    touch README.md
    echo "Project initialized"
end

# Note search
function findnote
    grep -r "$argv" ~/notes/ --include="*.md" | head -20
end

# Time spent this week
function week-time
    grep "$(date -d 'last Monday' +%Y-%m-%d)" ~/.timelog
end

# Today's tasks
function today-tasks
    task list due:today
end

# Quick backup
function backup
    tar -czf "backup-$(date +%Y-%m-%d).tar.gz" .
    echo "✓ Backed up"
end

# Open project notes
function pnote
    vim ~/notes/projects/$argv.md
end

Time saved: 3-5 hours/week (custom workflows)

Chapter 9: The Integrated CLI Workflow

Here’s how all these tools work together:

Morning:
  1. terminal: today          (open daily notes)
  2. terminal: task list      (see tasks for today)
  3. terminal: reminder -c    (see what's due)
  4. terminal: findnote       (search past notes)

During day:
  1. terminal: task add "New task"
  2. terminal: timer 25       (Pomodoro)
  3. Work in editor/IDE
  4. terminal: track "task description"   (log time)

End of day:
  1. terminal: task done 1    (mark tasks complete)
  2. terminal: task report    (see what shipped)
  3. Add notes to today file
  4. terminal: git add . && git commit
  5. terminal: streak mark    (track habit)

Weekly:
  1. terminal: week-time      (see total hours)
  2. terminal: task burndown.weekly
  3. Review notes
  4. Plan next week

Benefits:

  • Everything in terminal (no context switching)
  • Everything in text/Git (version controlled)
  • Everything keyboard (fast)
  • Everything automated (scripts and crons)

Chapter 10: Building Your CLI Productivity System

Don’t try to adopt everything at once.

Week 1: Core

  • Set up plain text notes folder
  • Create daily note function
  • Install and use Taskwarrior

Week 2: Workflow

  • Create shell functions for common tasks
  • Set up Git for notes backup
  • Create time tracking

Week 3: Automation

  • Set up Pomodoro timer
  • Add cron jobs for backups
  • Create streak tracking

Week 4: Advanced

  • Set up Obsidian + Git
  • Create custom reports
  • Build personal dashboard

Conclusion: Your Terminal is Your Productivity System

Most developers underuse their terminal.

They use it for coding only.

But your terminal can be your entire productivity hub:

  • Task management
  • Note-taking
  • Time tracking
  • Document generation
  • Automation
  • Focus management

All in one place. All keyboard-driven. All fast.

Master these tools and you’ll be far more productive than developers bouncing between web apps.

Appendix A: Essential CLI Productivity Tools

MUST HAVE:

☐ Shell: Fish or Zsh
☐ Tasks: Taskwarrior
☐ Editor: Vim or Nano
☐ Search: Ag or Ripgrep
☐ Find: fd

HIGHLY RECOMMENDED:

☐ Notes: Plain text + folders
☐ Git: Version control notes
☐ Timer: Pomodoro in terminal
☐ Time log: Text file tracking
☐ Markdown: Glow + Pandoc

NICE TO HAVE:

☐ Obsidian: GUI note-taking
☐ Vale: Writing linter
☐ Tree: Structure visualization
☐ Hugo: Static site generation

Appendix B: Quick Setup Script

#!/bin/bash
# Setup CLI productivity tools

echo "Installing CLI productivity tools..."

# Install tools
brew install fish
brew install task
brew install fzf
brew install the_silver_searcher
brew install glow
brew install pandoc
brew install vale

# Create directories
mkdir -p ~/notes/projects
mkdir -p ~/notes/ideas
mkdir -p ~/.scripts

# Create functions file
cat > ~/.config/fish/config.fish << 'EOF'
# Daily notes
function today
    vim ~/notes/$(date +%Y-%m-%d).md
end

# Task list
function tasks
    task list
end

# Find notes
function findnote
    grep -r "$argv" ~/notes/
end

# Pomodoro
function pomo
    echo "25 minute Pomodoro started"
    sleep 25m && notify-send "✓ Pomodoro complete"
end
EOF

# Initialize Git for notes
cd ~/notes
git init
git add .
git commit -m "Initialize notes repository"

echo "✓ Setup complete!"
echo "Run 'today' to open daily notes"
echo "Run 'task list' to see tasks"
echo "Run 'pomo' for Pomodoro timer"

Appendix C: Daily CLI Productivity Checklist

MORNING (5 minutes):
☐ Open daily notes: today
☐ Review tasks: task list
☐ Check reminders: remind -c ~/.reminders
☐ Search recent notes: findnote topic

DURING DAY:
☐ Add task when it comes up: task add "..."
☐ Use timer: pomo
☐ Log time: track "task"
☐ Take quick notes: vim
☐ Search docs: ag pattern

END OF DAY (10 minutes):
☐ Mark tasks done: task done [id]
☐ Log time worked
☐ Add notes to daily file
☐ Backup to Git: git add . && git commit
☐ Mark streak: streak mark

WEEKLY:
☐ Review all tasks: task report
☐ Analyze time spent: week-time
☐ Organize notes: findnote [project]
☐ Plan next week: task add due:next_monday

Tags

#cli #productivity #terminal #tasks #documentation #note-taking #project-management #writing #workflow #organization #open-source #time-management #focus

Related Articles

Automation with Go: Building Scalable, Concurrent Systems for Real-World Tasks

Automation with Go: Building Scalable, Concurrent Systems for Real-World Tasks

Master Go for automation. Learn to build fast, concurrent automation tools, CLI utilities, monitoring systems, and deployment pipelines. Go's concurrency model makes it perfect for real-world automation.

• Backend Development
Automation Tools for Developers: Real Workflows Without AI - CLI, Scripts & Open Source

Automation Tools for Developers: Real Workflows Without AI - CLI, Scripts & Open Source

Master free automation tools for developers. Learn to automate repetitive tasks, workflows, deployments, monitoring, and operations. Build custom automation pipelines with open-source tools—no AI needed.

• Productivity & Workflow
Developer Tools Mastery: CLI, Web & Desktop - The Complete Toolkit

Developer Tools Mastery: CLI, Web & Desktop - The Complete Toolkit

Discover the best developer tools for productivity. Master CLI tools, web platforms, and desktop applications. Learn what to use, why, and how to integrate them into your workflow.

• Tools & Workflow
← Back to blog