🇬🇧 Claude Code + ctm: a simple how-to

[GeRiY]

🇭🇺 Hungarian version: #4

How to work together with Claude Code on the ctm (claude-task-manager) board —
from your side. You don't need to memorize commands: Claude Code runs task.sh
for you, and all you have to do is say what you want in plain language. This post
shows you what to type to Claude Code, through user stories.

---

The gist in one minute

• You talk, Claude does it. You don't write task.sh yourself — just tell Claude
  Code what you want. It records it as a task, assigns it, and moves it on the board.
• Every request becomes a task. When you ask for work, it first lands on the board;
  only then does anyone start on it. Nothing gets lost.
• The main agent is the "project lead". It doesn't write code itself — it breaks the
  work down and hands it to teammates (ctm-frontend-developer,
  ctm-backend-developer, …). You just watch it move on the board.
• The board is the shared surface. http://localhost:3333/ — this is where you see,
  live, what's todo / in_progress / review / done. You can drag a task too, and
  Claude moves them as well.

You don't have to remember a single flag. Just say what you want — the rest is the
tool's job.

---

User stories: what to type to Claude Code

The following are real situations. On the left, what you type to Claude Code; on the
right, what happens on the board.

1. "Record a task"

You: "On the login page the password-reset link expires too soon, let's fix it."

What happens: Claude adds it to the board as a new task in todo, and — if you flag
it as urgent — with a higher priority. You don't have to ask separately to "create a
task": when you request work, it goes up automatically before anyone starts.

💡 If it's urgent, say so: "…this is a blocker, take it first." — that way Claude
raises the priority, and the teammates pick it up sooner.

2. "Where do we stand?"

You: "What's the state of the board? What's left?"

What happens: Claude gives you a compact overview by status, e.g. "12 todo, 1 in
progress, 63 waiting for review, 2 blocked, 166 done." If you ask for detail, it lists
the open tasks too. You don't have to browse the JSON — just ask in words.

Variations you can type:

• "What's in the review column?"
• "Show the open tasks under the auth area."
• "What's the next thing worth working on?"

3. "Get started on this"

You: "OK, dive into the login fix."

What happens: Claude doesn't code it itself — it hands it to the right teammate (e.g.
the backend developer), who moves it to in_progress, does the work, and when it's ready
puts it into review so you (or the main agent) can look it over. You follow the whole
move on the board.

4. "This hit a wall"

The teammate on the board: the task becomes blocked with: "Need the prod SMTP
password."

What happens: when work stalls (a missing password, approval, or decision), the task
goes to blocked, and you see the reason right there. You unblock it (provide what it
asked for), then:

You: "You've got the SMTP password in the password manager, carry on."

5. "This depends on another task"

You: "Before the login fix we need to settle the auth plan — that goes first."

What happens: Claude links the two tasks (the login fix waits for the auth plan).
From then on the "what's next" suggestion never surfaces the login fix until the plan is
done. You only have to state the order; Claude manages the dependency.

6. "Review it and close it"

You: "I reviewed the login fix, it's good — close it."

What happens: the task moves from review to done. But if there's still something
to do on it:

You: "Almost there, but I'd like a test for it too."

Then Claude hands it back to the teammate in todo with your notes — and the loop starts
over. This review → close or hand back cycle is the heart of how the board works.

7. "Let's continue where we left off yesterday"

You (new session, the next day): "Where were we? What was the goal?"

What happens: Claude pulls up the project's saved context — the goal, the earlier
decisions, the rules, the current focus — and continues from there. You don't have to
explain the whole thing again. This works because the important decisions get remembered
by the board along the way:

You, when you decide something: "Note it down: we use Redis for caching, because
it's faster than the DB cache."
You, when you state a rule: "Important rule: we don't modify the DB schema, we
adapt the code to it."

These go into the context, and a fresh session will know them too.

---

The board (the shared surface)

The browser board (http://localhost:3333/) is where you also see and move the
tasks while the agents work:

• Columns: todo → in_progress → review → done (and blocked).
• Use the "Source" picker in the header to switch projects if you use more than one.
• Language: with the language button in the header (or by appending ?lang=hu to the
  URL) you switch — and Claude then automatically replies/works in that language too,
  because the board signals the language to it. You don't even have to ask.
• Drags done on the board go through the same shared, safe path as Claude's
  operations — you can't corrupt the state with it. (Delete-type operations are
  deliberately not enabled from the board.)

---

Good habits (short)

• Say it if it's urgent. "This is a blocker" / "take this first" — that's what
  puts it in the right order.
• One request = one task. If you want several things, just list them — Claude splits
  them into separate tasks.
• Have decisions recorded. "Note down that…" — so a fresh session won't ask again.
• You decide at review. "Good, close it" or "fix this and that first" — the board
  won't consider anything done until you sign off.
• You don't have to know commands. If you get stuck, just ask in words: "What can
  you do on the board?" — Claude will tell you.

---

FAQ

Do I have to call task.sh?
No. Claude Code runs it. You just ask for things in plain language.

Does anything get lost when I close the session?
No. Tasks and context are persistent — in a new session Claude continues from the
context.

What if I move a task on the board while Claude is working?
No problem — both use the same safe writer, there's no conflict.

I work on several projects, do the tasks get mixed up?
No. Every project has its own board/data; you switch with the "Source" picker in the
header.

---

In one sentence

Tell Claude Code in plain language what you want — it turns it into a task, assigns it,
moves it on the board, and remembers the decisions — and you follow along on the board
and decide at review. There's no command you need to learn.

---

Question, idea, your own setup? Post it under
GitHub Discussions.