I use Kanban Board for My AI Agents. Here's Why.

Dmitrii Galkin — Sun, 29 Mar 2026 13:51:55 +0000

The Problem Nobody Talks About

I use Claude Code every day. It writes code, runs tests, ships features. It's fast. It's good. But there's a trap.

The more you delegate thinking to AI, the less you think. MIT Media Lab proved this: people who used ChatGPT for writing showed up to 55% reduced brain connectivity in regions responsible for critical thinking and memory. 83% couldn't even recall what they'd "written" minutes ago. They call it cognitive debt — and it accumulates silently.

I felt it. I'd approve AI-generated code without fully reading it. I'd skip diffs. I'd let the agent decide architecture. Convenient? Yes. Sustainable? No.

What Actually Works

I've been shipping products for 13 years. Here's what I learned working with AI agents:

You need short iterations. One task = one agent = one terminal. The agent works on the current task while you prepare the next one — write the description, think through the approach, break it down.

You need to stay in the loop. Not micromanaging every line. But reviewing diffs. Understanding architecture decisions. Knowing what to check and why.

You need gates. The agent does the work — coding, testing, whatever. But after every step it comes back to you. You review the result. You decide what happens next. Not "run and forget" — a relay race where you hand off execution but never hand off direction.

You need to use the wait time. While the agent works in terminal 1, you're in terminal 2 writing the next task description, breaking down the next feature, dumping your thoughts into specs. This is the highest-leverage thing you can do — unload your brain while the agent handles the current step. You think ahead, the agent executes now.

The winning move isn't better AI. It's knowing when to think and when to delegate.

My Setup: Kanbani

I built Kanbani — a kanban board made for developers who use Claude Code.

The workflow is simple:

1. Create a task — title, description, project folder.

2. Run an agent — one click spawns Claude Code in an isolated git worktree. No branch conflicts. Multiple agents work in parallel.

3. Review the diff — split or unified view, right in the board. You see every line changed.

4. Merge or discard — approve changes into main, or throw them away. Your call. Always.

5. Resume anytime — comment on a task, and the agent picks up where it left off. Same session, same context.

What makes it different

Git worktree per task — each task gets its own branch and working directory. Agents don't step on each other.
Session persistence — close the tab, come back tomorrow, resume the conversation.
Diff review built in — no switching to terminal to read git diff. It's right there, with file stats and syntax highlighting.
Local and private — runs on localhost:3333, data lives in ~/.kanbani/board.json. Nothing leaves your machine.

The real point

Kanbani isn't a project management tool. It's a cockpit. You're the pilot. Agents are the crew. You see what they did, you review it, you decide.

The key workflow that works for me:

Terminal 1: Agent works on the current task.
Terminal 2: I prepare the next task — write the description, think through the approach, break it down.

Short iterations. One task = one thread = one terminal. While the agent codes, I think ahead. When it's done, I review, merge, and assign the next one.

This is how you stay in control without slowing down.

Try It

npm install -g kanbani
kanbani

That's it. Opens in your browser. Create a task, point it at your project, hit Run.

If you find it useful — star the repo. It helps others find it.

AI is the best teammate I've ever had. But teammates don't make your decisions. You do.

Stop write commit messages by your self

Dmitrii Galkin — Mon, 03 Feb 2025 06:34:26 +0000

Github Repository ⭐️
Support and star pls.

👨🏻‍💻 Supercharging Git Commits with AI: A Developer's Journey

As a developer, writing meaningful commit messages is crucial for maintaining a clean and understandable git history. However, it's often a tedious task that interrupts the flow of coding. That's why I decided to automate this process using OpenAI's GPT and Windsurf IDE.

🤔 The Problem

We've all been there - staring at the terminal trying to craft the perfect commit message that follows conventional commits format, describes the changes accurately, and remains concise. It's especially challenging when you're in the middle of a coding session and don't want to break your concentration.

🧑🏻‍🏭 The Solution

Using Windsurf IDE and OpenAI's GPT-3.5, I created a streamlined workflow that automatically:

🤔 Analyzes git diff to understand changes

Generates meaningful commit messages following conventional commits format
Adds appropriate emojis based on the type of change
Commits and pushes changes without interruption
The Implementation
The solution consists of a simple shell script integrated with Make commands. Here's how it works:

🧙🏻‍♀️ The script captures the git diff of staged changes

Sends this diff to GPT-3.5 with specific instructions to generate a conventional commit message
Processes the response to add relevant emojis (e.g., ✨ for features, 🐛 for fixes)
Automatically commits and pushes the changes
Example messages it generates:

feat:✨ Add authentication middleware for API endpoints fix:🐛 Resolve memory leak in WebSocket connections docs:📚 Update deployment guide with Docker instructions

✚ Benefits

This automation has significantly improved my development workflow:

Time Saving: No more context switching to write commit messages
Consistency: All commits follow the same format and style
Quality: Messages are descriptive and focus on the what and why
Flow: Maintain coding momentum without interruptions

🚀 Getting Started

Github Repository ⭐️
The entire solution is open-source and available in my repository. To try it yourself, you'll need:

Python 3.x
Git
Make
OpenAI API key

Copy code to your repo an use it.

🍺 Conclusion

By leveraging AI through Windsurf IDE, what used to be a mundane task has become a seamless part of the development workflow. This not only saves time but also ensures better documentation of our codebase through consistent and meaningful commit messages.

DEV Community: Dmitrii Galkin