A week ago, I shipped Todo — my local kanban for driving AI agents. Since then, I've been using it every day, across multiple projects, with multiple agents. In a week, the tool has changed.
No refactor. No "v2". Just a handful of features added along the way, each born from a real friction I didn't even know existed until I started using the thing.
Here's what strikes me looking back at this week: a tool you make yourself grows differently from a tool you put up with. I think that deserves its own article.
The "friction → feature" cycle got absurdly short
Let me give you a concrete example.
Monday, I create a ticket to rebuild the water system on Aekan. It quickly becomes clear it's too big — my programmer and technical-artist agents need to split the work. I start creating multiple tickets linked via #42 in descriptions. Except the agent loses the thread, and so do I.
Tuesday, I have sub-tickets.
Not because they were on a roadmap. Not because a request bubbled up from a backlog. Because I needed them the day before, the code is mine, and it took me a few hours to add them cleanly.
In SaaS land, this same need would have ended up on a community forum, been aggregated with 50 other similar requests, waited a quarter to reach under consideration, then maybe a year before landing in prod. Or never.
The ratio of "need detected → feature shipped" went from months to hours. That changes everything.
The "too small" features finally exist
Here's the second thing this week revealed: there's an entire category of features that didn't exist anywhere — not because they're useless, but because they're too small for a vendor to bother with.
Example: a Ctrl+Z that undoes the last action on the board.
It's one of the most useful features I've added this week. It literally does one thing: when you mess up on a ticket, you hit Ctrl+Z and it's reversed. Accidental move, wrong priority, sub-ticket dropped in the wrong place — all undone.
A few tools do it partially (Linear has an undo toast on some actions, Trello too on drag-and-drop), but rarely in a fully keyboard-driven, cover-everything way. Why? Because it's too small to justify a roadmap item, and too diffuse to be a marketing argument. But when you use it yourself, it's the difference between "I move tickets without thinking" and "I'm careful with every click".
Psychologically, it's huge. And it's exactly the kind of feature you only get in tools you make for yourself.
The tool knows things I didn't
Another weird observation from this week: my agents surfaced bugs I'd never have found on my own.
One agent created a ticket with "status": "InProgress" instead of "In Progress". The ticket ended up in a ghost column. Another sent comments with an empty author — "null created the ticket" in the activity log.
These are cases I'd never have triggered as a human user. But an agent, which reads the docs fast and tests everything, finds them in a day.
Result: I added silent validations I'd never have written if I'd stayed the only user. The API became more robust because it was tested by agents before being tested by humans.
It's an interesting inversion: agents are my best QA.
The quiet satisfaction of fixing your own bugs
There's also something I hadn't anticipated and want to mention honestly: the emotional satisfaction of fixing your own annoyances.
When you hit a bug in a paid SaaS, what do you do? You report it, you wait, you forget. The irritant persists and ruins your mood every time you hit that part of the workflow.
When you hit a bug in your own tool, you fix it. On the spot. And every time you hit that part of the workflow after, you think "oh right, I fixed that".
That small repeated satisfaction, accumulated over a week, actually affects the energy you bring to your other projects. It's not an argument you see often, but it's real.
What it says about our relationship with tools
I think we're living through an interesting moment. For twenty years, we've outsourced our tooling to SaaS vendors who decide what we can do, at what pace, and at what price. We've learned to live with "almost good" tools that never do exactly what we want, because building our own seemed too expensive.
That cost is collapsing. Not only thanks to AI agents — but through the combination of better stacks, solid templates, and agents that speed up the "writing code" phase by 5-10x.
What this means concretely: custom tools are becoming economically rational again for needs that, yesterday, would never have justified the cost.
Todo is a kanban. There are dozens on the market. But none of them is exactly what I need, and none ever will be — because my need is too niche for their roadmap. So I'm making it myself, and sculpting it week by week.
In summary
This week, Todo gained: sub-tickets, a dedicated sub-kanban, a global Ctrl+Z, and three silent validations. Nothing revolutionary on its own. But each addition solved an irritation I would never have seen fixed in a third-party tool.
And maybe that's the real point: once you start making your own tools, you realize how many compromises you were accepting without noticing.
The code
Everything is up to date on GitHub:
If this approach resonates — or if you're also building custom tools for your workflow — join me on Discord.