DEV Community: kohei_wada

Building a CLI Task Manager That Solves the "When to Do It" Problem Taskwarrior Lacked

kohei_wada — Mon, 12 Oct 2026 15:42:06 +0000

Introduction

Taskdog is a CLI/TUI task management tool that auto-generates schedules from task deadlines, estimated durations, and priorities — all while respecting a daily work-hour limit.

👉 https://github.com/Kohei-Wada/taskdog

There are mountains of task management tools out there. Todoist, Notion, Trello — all of them are great tools.

But none of them fit my workflow.

So I decided to build my own.

Why I Built It

The Tools I Tried Along the Way

Taskwarrior

The first tool I tried was Taskwarrior.

Taskwarrior is a fantastic CLI task manager. It has over 15 years of history, is simple and fast, and highly customizable. I used it for a while.

But there was one big complaint.

No automatic schedule generation.

You can set a deadline and an estimated duration on a task, but figuring out "OK, so when do I actually do this?" is still up to you. Taskwarrior is great at prioritizing what to do, but scheduling when to do it seems to be out of scope.

Manually deciding "what and how much to do today" every single morning was, frankly, a pain.

Motion / Reclaim.ai

Next I tried AI scheduling services.

Motion and Reclaim.ai are built around the concept of "AI auto-schedules your day." That certainly sounded convenient.

But a few things bothered me:

$19–34/month is steep (over $200/year)
Cloud-required (I don't want to hand my task data over to a third party)
Black-box AI (you can't tell why it picked this schedule)

Even when told "the AI decided," I felt like I was being handed a schedule I couldn't really get behind.

Asana / Jira / ClickUp

I also tried team-oriented tools.

They have tons of features, but they're way too heavy for personal use. Parent-child tasks, subtasks, epics, stories...

One person working solo doesn't need that kind of complex structure.

Notion

I use Notion for organizing team docs at work. The page hierarchy and database features are excellent.

But it didn't suit my workflow.

Heavy — just to add a task I have to open a browser, wait for the page to load...
Weak task management — you can fake it with databases, but in the end it's a general-purpose tool
Automatic scheduling? — nope

What I Actually Wanted

In the end, here's the kind of tool I wanted:

Lives entirely in the terminal — opening a GUI is annoying. I want to bang things out on the command line
Generates the schedule for me — give it priority, deadline, and estimate, and have it tell me "do this today"
No cloud dependency — privacy first. Data stays local
Transparent algorithms — not "the AI decided," but "this logic produced this result" — something explainable

I couldn't find any existing tool that ticked all those boxes, so I built one.

Comparison with Existing Tools

Feature	Taskdog	Taskwarrior	Motion/Reclaim
Auto schedule generation	✅	❌	✅
Work-hour limit aware	✅	❌	✅
Skips weekends/holidays	✅	❌	✅
Fully local	✅	✅	❌
Transparent algorithms	✅	-	❌
Price	Free	Free	$19–34/mo
CLI/TUI	✅	✅	❌
Dependencies	✅	✅	Partial

Where Taskdog fits: Taskwarrior's usability + Motion/Reclaim's automatic scheduling — done fully locally.

What Is Taskdog?

The name is arbitrary. I happened to see Datadog while using Taskwarrior, and went with "Task + dog = Taskdog." No deeper meaning.

It's a task management system written in Python, with three interfaces:

CLI — quick command-line operations
TUI — full-screen terminal UI
REST API — programmatic access

Main Features

Basic Task Operations

# Add a task
taskdog add "READMEを書く" --priority 3 --tag docs

# List tasks (table view)
taskdog table

# Start / complete a task
taskdog start 1
taskdog done 1

Schedule Optimization (The Core Feature)

Taskdog's core feature is auto-scheduling that never exceeds your daily work-hour limit.

If you add a 10-hour task with a deadline three days out, it automatically spreads the work across those three days. Weekends and holidays are skipped automatically, so the schedule it produces is actually realistic.

# A 10-hour task with a 3-day deadline
taskdog add "レポート作成" --estimate 10h --deadline 2025-01-05

# Run the optimizer
taskdog optimize
# → Distributes across weekdays only, capped at 6 hours/day (default is configurable)

It builds a schedule that respects priorities, deadlines, and dependencies — and stays within your work-hour cap.

Three practical algorithms:

taskdog optimize                            # greedy (default)
taskdog optimize --algorithm backward       # deadline-driven
taskdog optimize --algorithm dependency_aware # dependency-aware

Algorithm	Description	When to use
greedy	Schedule everything as early as possible	When you want it done sooner
backward	Work backward from deadlines (JIT)	Deadline-driven work
dependency_aware	Critical Path Method (CPM)	When dependencies are heavy

These are the three I actually use day to day.

Experimental algorithms for learning (six of them):

I've also implemented balanced, priority_first, earliest_deadline, round_robin, genetic, and monte_carlo. These were built as experiments. See the repo for details.

Difference from Motion/Reclaim:

Motion/Reclaim: black-box AI (you don't know why this schedule)
Taskdog: transparent algorithms (source-readable, swappable)

Gantt Chart View

taskdog gantt

You get a Gantt chart right in the terminal. It also shows the daily load, so you can spot "this day is overpacked" at a glance.

TUI (Full-Screen Mode)

taskdog tui

The look and feel lean toward Vim/Neovim.
Real-time task search with / is modeled after telescope.nvim, so Neovim users should feel right at home.

Key	Action
`a`	Add task
`s`	Start
`d`	Complete
`/`	Search
`Ctrl+P`	Command palette
`?`	Show help

Other Features

Task dependencies: taskdog add-dependency 2 1 (task 2 starts after task 1 is done)
Fixed tasks: exclude meetings and other immovable events from optimization
Skip weekends/holidays: only schedule on weekdays (supports Japanese public holidays)
Markdown notes: attach notes to any task
Tag management: categorize tasks
Time tracking: compare planned vs. actual
MCP support: AI agents can manipulate tasks directly

Tech Stack

Layer	Library
CLI	Click + Rich
TUI	Textual
API	FastAPI + Uvicorn
DB	SQLite + SQLAlchemy + Alembic
Type checking	mypy
Linter	Ruff
Package manager	uv

Architecture

Built with Clean Architecture, organized as a monorepo via uv workspaces.

packages/
├── taskdog-core/    # Business logic (no UI dependencies)
├── taskdog-client/  # HTTP API client
├── taskdog-server/  # FastAPI REST API
├── taskdog-ui/      # CLI/TUI
└── taskdog-mcp/     # Claude Desktop integration (MCP)

This structure means:

The UI can be swapped without touching core
server and ui can be deployed independently
Tests are easy to write

Design Principles

1. Embrace That It's Personal

Team features, cloud sync, collaboration — I cut all of it.

Reasons:

Keeps things simple
Protects privacy
The peace of mind of being fully local

2. Transparent Algorithms

Instead of "the AI built your schedule," it should be possible to say "this algorithm produced this result."

All three of the practical algorithms (greedy, backward, dependency_aware) are readable in source. If you don't agree with one, you can tweak it yourself.

3. Following GTD Principles

I borrowed ideas from David Allen's Getting Things Done:

Tasks should be concrete actions
Dependencies should be explicit
Regular review (taskdog today, taskdog gantt)

What Was Hard, What I Learned

The Parent-Child Task Feature That Didn't Work Out

Early on I tried to implement parent/child tasks (subtasks).

I figured "being able to decompose big tasks into smaller ones would be useful."

But as I dug in, the problems piled up:

Should the parent task be scheduled? Just the children?
Is the parent's estimate the sum of the children? Or independent?
When all children are done, does the parent auto-complete?
When you delete the parent, what happens to the children?

The fit with the optimization algorithms was particularly awful. Every optimizer needed special-case logic for parent/child relationships, and the code kept growing more tangled.

In the end I scrapped parent-child tasks and replaced them with dependencies + tags + notes.

I realized I'm only juggling a handful of tasks at a time — there's no need to organize them in a tree.

Migrating to Clean Architecture

I started with a simple structure, but as features grew the code got messy. (At the very beginning it was literally just a pile of commands editing a JSON file.)

Partway through I migrated to Clean Architecture. That was a lot of work:

Separating domain, application, and infrastructure layers
Aligning the direction of dependencies
Introducing the Use Case pattern

But the payoff was worth it:

All three interfaces — CLI, TUI, API — run on the same business logic
Tests are easy to write
Adding new features got much easier

What's Next

24-hour task execution
Recurring tasks
Improving the scheduling algorithms

For details, see DESIGN_PHILOSOPHY.md.

Closing Thoughts

Building your own task manager for yourself might be one of the privileges of being a programmer.

Taskdog is still under development and probably has bugs and rough edges. Even so, it fits my workflow perfectly.

I think it's particularly suited to:

People using Taskwarrior who wish it auto-generated schedules
People interested in Motion or Reclaim but unwilling to pay $20/month
People who want their task data to stay local
People who want a schedule built by transparent logic, not "because the AI said so"

If any of that sounds like you, give it a try. Stars, issues, and PRs are all welcome.

👉 GitHub repository

This post was written with AI assistance and reviewed by the author.

Beyond AWK: Bringing Haskell into Unix Pipelines

kohei_wada — Sun, 11 Oct 2026 15:38:48 +0000

1. A Problem Born from Daily Developer Life

"I want to use Haskell more in real work."

For any developer who has tasted the beauty of functional programming, this is a heartfelt wish. But the reality is that Haskell gets shunned as "impractical" or "too expensive to introduce," and there are almost no opportunities to use it at work.

Couldn't we at least use Haskell for the small everyday tasks? When you stop and look, a shell pipeline really does resemble function composition.

cat file | grep pattern | sort | uniq

Pipeline = function composition. The more I sat with that intuition, the more convinced I became that Haskell ought to fit right in.

The AWK Wall

When you want to do something a bit longer than a typical one-liner, AWK comes to mind. But...

"How do you write an array in AWK again?"
"What's the syntax for a for loop...?"

Haven't you ended up wasting time on Google, watching all the fun of shell trickery slip away?

2. The Moment of Inspiration: The Birth of phs

My Three Big Problems

No chance to use Haskell at work
Wanting more powerful processing inside shell pipelines
Hating having to look up AWK syntax every time

I tried existing options like stack script and cabal script, but the first run is way too slow. Waiting several seconds for a trivial bit of processing just isn't practical.

"Haskell ought to be more usable than this"

Convinced of that, I figured fine, I'll just build it myself. If we use ghc -e for immediate execution, couldn't we drop Haskell directly into a pipeline?
That is phs (PipeLine Haskell Script).

3. phs in Everyday Work

Example 0: stack script is too slow

#!/usr/bin/env stack
-- stack script --resolver lts-22.33
main = interact (show . length . lines)

This code takes several seconds on its first run. So you end up reaching for wc -l instead, and Haskell drifts further out of daily life.

With phs, it's instant:

cat file.txt | ./phs --all 'length'

Example 1: Character count per line

In AWK:

awk '{print length($0)}' file.txt

But with phs, it's intuitive:

cat files.txt | ./phs 'length'

Example 2: Word count and character count

# AWK
awk '{print NF, length($0)}' file.txt

# phs
./phs '\s -> (length (words s), length s)'

Example 3: Sum of numbers

# AWK
awk '{sum=0; for(i=1;i<=NF;i++) sum+=$i; print sum}'

# phs
./phs 'sum . map read . words'

4. A Thorough Comparison of AWK and Haskell (phs)

The classic text-processing tool of UNIX culture is AWK. But phs covers what AWK is good at while pushing expressiveness even further.

Item	AWK	phs (Haskell)
First-run speed	Instant	Instant (via `ghc -e`)
Syntax	Custom syntax (C-like)	Standard Haskell
Functions / types	Built-ins are limited	Haskell's standard library is available
Numeric processing	Floating point by default	Precision managed via types
Extensibility	Relies on external commands	Extensible by adding modules
Learning cost	Must memorize a custom grammar	Zero if you already know Haskell

Comparison on basic text processing

Count characters per line

# AWK
awk '{print length($0)}'

# phs
./phs 'length'

Take the first 10 characters of each line

# AWK
awk '{print substr($0, 1, 10)}'

# phs
./phs 'take 10'

Filter lines that are uppercase only

# AWK (regex)
awk '/^[A-Z]+$/'

# phs (functional)
./phs 'all isUpper'

Comparison on numeric processing

Sum of numbers per line

# AWK (imperative loop)
awk '{sum=0; for(i=1;i<=NF;i++) sum+=$i; print sum}'

# phs (function composition)
./phs 'sum . map read . words'

Sum of numbers across all lines

# AWK (messy state handling)
awk '{for(i=1;i<=NF;i++) total+=$i} END {print total}'

# phs (simple function composition)
./phs --all 'sum . map read'

Example: word count per line

AWK:

awk '{print NF}' file.txt

phs:

./phs 'length . words'

Where the gap really shows: mathematical algorithms

First 10 terms of the Fibonacci sequence

AWK (a tangle of iteration):

awk 'BEGIN{a=1;b=1;for(i=1;i<=10;i++){print a;c=a+b;a=b;b=c}}'

phs (an elegant recursive definition):

seq 1 10 | ./phs 'let fib n = if n <= 2 then 1 else fib (n-1) + fib (n-2) in fib . read'

Collatz conjecture

AWK (verbose imperative code):

awk '{n=$1; while(n>1){if(n%2==0)n=n/2;else n=3*n+1; print n}}'

phs (the formula expressed as-is):

seq 10 | ./phs 'let collatz n = if n == 1 then [1] else n : collatz (if even n then n `div` 2 else 3*n+1) in collatz . read'

Power set

AWK: I don't want to (you'd need multi-dimensional arrays)

phs: You can write the mathematical definition verbatim

echo "abc" | ./phs 'let powerset [] = [[]]; powerset (x:xs) = powerset xs ++ map (x:) (powerset xs) in powerset'

Advanced text processing

Sorting lines

# AWK (depends on an external command)
awk '{print}' | sort

# phs (self-contained via built-in functions)
./phs --all 'sort'

Removing duplicate lines

# AWK (needs external commands)
awk '{print}' | sort | uniq

# phs (solved in one shot)
./phs --all 'nub'

Reversing line order

# AWK (requires a clunky implementation)
awk '{a[NR]=$0} END {for(i=NR;i>0;i--) print a[i]}'

# phs (intuitive)
./phs --all 'reverse'

Joining all lines into a single string

# AWK (newline handling is a pain)
awk '{printf "%s%s", (NR>1?" ":""), $0} END {print ""}'

# phs (natural)
./phs --all 'unwords'

Conclusion:

AWK is ideal for "simple row/column processing"
phs shines at "mathematical or recursive processing," "type-safe aggregation," and "functional transformations," all writable as one-liners
Especially for complex algorithms, AWK turns into verbose imperative code, while phs can express the mathematical definition directly

5. The Edge in Mathematical Algorithms

Collatz conjecture

AWK: imperative and verbose

awk '{n=$1; while(n>1){if(n%2==0)n=n/2;else n=3*n+1; print n}}'

phs: the formula expressed directly

seq 10 | ./phs 'let collatz n = if n == 1 then [1] else n : collatz (if even n then n `div` 2 else 3*n+1) in collatz . read'

Power set

AWK: I don't want to

phs: write the mathematical definition verbatim

echo "abc" | ./phs 'let powerset [] = [[]]; powerset (x:xs) = powerset xs ++ map (x:) (powerset xs) in powerset'

6. The Simplicity of phs

The implementation of phs is shockingly simple:

Command-line parsing
Immediate evaluation via ghc -e
Config file loading

That's all you need for a lightweight implementation that works. The secret to its speed is ghc -e's immediate execution with no precompilation required.

Current limitations and future improvements

Because phs is a lightweight implementation, it has a few constraints:

String display issue:

echo "hello" | ./phs 'id'
# Output: "hello"  (double quotes are included)

This happens because results are displayed using the Show instance.

But anyone who regularly uses the shell can just do:

echo "hello" | ./phs 'id' | tr -d '"'
# Output: hello  (double quotes removed)

Problem solved (lol).

The current simple implementation stays lightweight by running every result through show uniformly. It's a design that follows the Unix philosophy of "rather than chasing perfection, get something working first." Any fine-grained tweaking is best handled by combining it with other shell tools — that's the Unix way!

7. How phs Sets Itself Apart from Existing Tools

Approach	First run	Subsequent runs	Learning cost
stack script	3-5 sec	Instant	Medium
cabal script	2-4 sec	Instant	Medium
AWK	Instant	Instant	High (you forget)
phs	Instant	Instant	Low

Learning and research

Algorithm exploration
Generating and analyzing number sequences

# Sum of squares
seq 1 100 | ./phs --all 'sum . map (\x -> let t = read x in t * t)'

# Searching for perfect numbers
seq 1 1000 | ./phs --all 'let isPerfect n = sum [i | i <- [1..n-1], n `mod` i == 0] == n in \xs -> filter isPerfect $ map read xs'

8. Looking Ahead

phs has made "everyday Haskell" a reality:

No need to recall AWK syntax
The beauty of functional programming, every day

9. Getting Started with phs Today

git clone https://github.com/Kohei-Wada/phs.git
cd phs
chmod +x phs

echo "hello world" | ./phs 'reverse'

And you'll notice: "oh, this is actually handy." (lol)

Repository: https://github.com/Kohei-Wada/phs

Let's bring Haskell more into daily life!

phs is more than just a tool. It's a first step toward folding Haskell into everyday work. Why not join me in bringing the beauty of functional programming into your daily tasks?

I'm pretty sure it'll make writing code a lot more fun.

This post was written with AI assistance and reviewed by the author.

I built supernemawashi — a Claude Code plugin that manages psychological profiles for talking to colleagues

kohei_wada — Sun, 11 Oct 2026 08:29:39 +0000

Introduction

In conversations with colleagues and stakeholders, working out "will this phrasing land with this person, or step on a landmine?" from scratch every time is quietly exhausting. There's a limit to how many people I can keep in my head, and I forget anyway.

So I built supernemawashi, a Claude Code plugin that solves this by managing profiles as data.

The workflow: collect facts from Slack / Gmail / Calendar / GitHub, classify them with psychology frameworks, generate situation-specific DO / DON'T rules, and call them up when I'm writing a reply. Everything runs locally — nothing is sent anywhere.

Why I built it

Saying "most of an engineer's job is talking to people" is blunt, but it's true. I spend more time asking, reporting, arguing, and persuading than I do writing code. And for all of it, I'm working out the optimal phrasing for each person's type, every single time. That wears you down.

Concretely, situations like these:

I phrased something "too bluntly" for someone and stepped on a landmine. I tell myself I'll be careful next time, then forget.
One person is convinced by numbers; another responds better to a story. Do it backwards and you get ignored.
One person acts when you push in a meeting; another shuts down when you push in a meeting.

"Remembering it from experience" breaks down as the number of people grows. With someone I don't have committed to memory, I start from zero every time — and even with people I think I remember, I forget things.

How it solves the problem

The idea itself is simple:

Record facts about the person (who said what, when) as data
Classify the facts with psychology frameworks (defense mechanisms / conflict modes / ego states / motivators / biases / attachment style)
From the classification, generate situation-specific DO / DON'T rules
When writing a reply, pull up that person's profile plus the rules for the relevant situation

In other words, pre-compute "how do I talk to this person" and keep it in a file — so I don't re-derive it on every reply.

Profiles live in ~/.local/share/supernemawashi/profiles/<person-name>/, entirely local. Even when it reads Slack / Gmail over MCP, the collected data never leaves the machine.

Skills

The operational skills are all verb-first under a nemawashi- prefix:

Skill	What it does
`nemawashi-collect`	Collect facts from MCP sources (Slack / Gmail / Calendar / GitHub) into a profile
`nemawashi-analyze`	Classify the gathered facts with psychology frameworks, generate situation DO / DON'T rules
`nemawashi-show`	View profiles (list / drill into one / aggregated situation rules)
`nemawashi-discover`	Find people you talk to but haven't profiled yet, from MCP sources
`nemawashi-check`	Dashboard of stale profiles (analyses gone old)
`nemawashi-note`	Manually add a one-line fact MCP can't see (1on1, phone, hallway chat)
`nemawashi-reply`	Load only the frameworks relevant to the situation, generate 2–3 reply drafts
`nemawashi-migrate`	Convert old-format profiles to the new format
`nemawashi-issue`	Shape an improvement idea into the house style and file it as a GitHub issue

A basic workflow looks like this:

[1] /nemawashi-collect "John"
        ↓ collect facts from MCP sources
[2] /nemawashi-analyze "John"
        ↓ classify per framework, generate DO/DON'T
[3] /nemawashi-reply "How should I reply to John about the deadline?"
        ↓ load John's profile + only the relevant frameworks
[4] 2–3 drafts come back

Install is via the marketplace:

/plugin marketplace add Kohei-Wada/supernemawashi
/plugin install supernemawashi@supernemawashi

Restart the Claude Code session and the using-supernemawashi entry-point skill is injected via a SessionStart hook — from there it runs in natural language.

Gotchas

The discomfort of "turning people into data": profiles are for people you talk to, not surveillance targets. This isn't built for profiling random coworkers behind their backs (and the MCP sources only run through your own account).
MCP rate limits: hammering Slack or Gmail hits limits. The --all bulk operations are throttled to batches of 5.
Stale profiles: a profile not analyzed for a month is less trustworthy. nemawashi-check surfaces staleness, and nemawashi-update --all re-analyzes everything at once.
"Collect everyone" is heavy: collect is MCP-bound and slow, while analyze is local-file-only and fast — so the two are split into separate skills, letting you re-run just the analysis.

Results

For someone I have a profile on, the time spent figuring out "how do I phrase this" dropped from ~5 minutes to ~30 seconds.
For "someone I haven't talked to in a while" or "someone I rarely talk to," facts auto-collect from past Slack / Gmail, so the first-contact cost went down.
I built a profile of myself and ran analyze on it — my own coping patterns became visible, which turned out to be a bit therapeutic (an unexpected side effect).

Wrap-up

The cost of figuring out "how to talk to this person" from scratch every time can be cut down by turning it into data
supernemawashi wires fact collection / psychological analysis / situation-rule generation / reply drafting into a single plugin
Profile data never leaves your machine; MCP sources are read only through your own account
It installs as a Claude Code plugin

The repo is here: supernemawashi (GitHub)

This post was written with AI assistance and reviewed by the author.

I made a terminal task manager, got featured by the creator of Textual, and Reddit banned me 🤣

kohei_wada — Wed, 25 Mar 2026 04:54:23 +0000

Have you ever spent weeks building an open-source project, finally launched it, and then had Reddit's spam filter silently delete your post because your account was too new?

That was my experience launching taskdog.

But the Reddit drama isn't the point. The real story is why I built a terminal task manager from scratch.

The Problem: No task manager fit my workflow

I was inspired by Taskwarrior — powerful, keyboard-driven, terminal-native. But I wanted a proper TUI and a local API I could build on top of. Nothing out there quite fit, so I built my own.

The Design Decisions

Why no subtasks?

Most task managers let you nest tasks infinitely. I removed subtasks entirely. Dependencies + tags cover 99% of personal task organization, and keeping the structure flat makes the schedule optimizer dramatically simpler. I documented the full reasoning in DESIGN_PHILOSOPHY.md.

Why Clean Architecture for a personal tool?

The codebase is split into three packages: taskdog-core (business logic), taskdog-server (FastAPI REST API), taskdog-ui (CLI/TUI). Overkill for a personal project? Maybe. But it forced me to keep business logic completely independent of the UI and transport layer — and it paid off when I added the API server without touching the core.

What it does

Full-screen TUI powered by Textual
FastAPI + SQLite backend running locally
9 scheduling optimization algorithms
Time tracking with planned vs actual comparison
Gantt chart view
Task dependencies with circular detection

Try it instantly (no install needed)

docker run --rm -it ghcr.io/kohei-wada/taskdog:demo

Spins up the server and launches the TUI in one shot, with demo data preloaded.

The Reception

After shipping it, some nice things happened:

Featured on Terminal Trove
Featured on LinuxLinks in the CLI/TUI/Productivity category
Will McGugan — creator of Textual, the library powering the TUI — said: "The author of this project has clearly got a good eye for design in the terminal"

Note: Built with the help of Claude Code (credited as contributor in the repo). Architecture, algorithms, and all design decisions are my own.

GitHub: https://github.com/Kohei-Wada/taskdog