🌐 Translation: Translated from Korean.

TL;DR

  • Core Concept: 4-stage message processing pipeline + channel-based FIFO task queue
  • Result: Manage multiple projects via Slack channels with guaranteed FIFO order
  • Keywords: Plain text, DSL, FIFO, Channel = Project
  • Target Audience: Developers working on multiple projects simultaneously
  • Time Required: 10 minutes to understand, 5 minutes to practice

1. Why Do You Need to Manage Multiple Projects Simultaneously?

The Core Problem: Claude Code Wait Time

When working with Claude Code, you frequently encounter situations like this:

In #project-blog:
"Write a draft post for me"

→ Claude Code running... (estimated 5 minutes)
→ You just wait idly ⏳
→ This time is wasted!

What If You Could Use That Wait Time?

The key to managing multiple projects simultaneously is utilizing wait time:

1. Start work in #project-blog
   "Write a draft post for me" (takes 5 min)

2. While waiting, switch to #project-api
   "Debug this API error" (takes 3 min)

3. Return to #project-blog later
   → The draft is ready!

Result: Complete 2 tasks across multiple projects in 5 minutes instead of 8 ✨

Limitations of Existing Solutions:

  • Terminal tab switching: Confusing which project you’re in, context loss
  • VS Code workspaces: Heavy, not available on mobile

remote-claude’s Solution:

Slack Channel = Project

#project-blog    → /Users/idongho/proj/blog
#project-api     → /Users/idongho/proj/api
#project-frontend → /Users/idongho/proj/frontend
  • Switch projects by changing channels (1 second)
  • Each channel’s conversation history = project work log
  • More than 2x efficiency by utilizing wait time

2. Deep Dive into the 4-Stage Message Processing Pipeline

2.1 Why 4 Stages?

Message Processing Pipeline Design Goals:

  1. Flexibility: Support various input methods (Plain text, DSL, Slash Commands)
  2. Priority: Process important commands first
  3. Stability: Prevent errors through stage-by-stage validation

The 4-Stage Pipeline:

Incoming message
    ↓
Stage 1: Check for Slack native commands (passthrough)
    ↓ (if not)
Stage 2: Bot meta commands (/setup, /state, /cancel)
    ↓ (if not)
Stage 3: DSL (interactive input responses)
    ↓ (if not)
Stage 4: Plain text → Execute Claude Code

2.2 Stage 1: Slack Native Commands (Pass-through)

Purpose: Let Slack’s built-in commands pass through untouched

Examples:

/invite @remote-claude  → Handled directly by Slack
/archive               → Handled directly by Slack

Processing Logic: The message processing pipeline doesn’t intervene

2.3 Stage 2: Bot Meta Commands

Purpose: Commands for managing remote-claude itself

Supported Commands:

  • /setup <project-name> <path>: Connect a project
  • /state: Check status (channel, task queue)
  • /cancel: Cancel running task
  • /download [file]: Download a file

Key Feature: Immediate execution (not added to task queue)

Example:

/state

→ Immediate response:
   Current channel: #project-blog
   Project: /Users/idongho/proj/blog
   Task queue: 1 waiting

2.4 Stage 3: DSL (Domain-Specific Language)

Purpose: Send arrow key and Enter events to Claude Code

The Problem:

When Claude Code shows selection options, you can’t press arrow keys in Slack:

Claude Code shows:
  > Create new file
    Update existing file
    Delete file

→ Can't use arrow keys to navigate in Slack
→ Can't press Enter to select
→ Work stops!

The Solution: DSL (5 Commands)

Format: `command`

Supported commands:
`r`  → Right arrow (→)
`l`  → Left arrow (←)
`u`  → Up arrow (↑)
`p`  → Down arrow (↓)
`e`  → Enter

Real-World Usage Example:

Claude Code shows:
  > Create new file
    Update existing file
    Delete file

In Slack:
→ Type `p` (move down)

Claude Code screen changes:
    Create new file
  > Update existing file
    Delete file

In Slack:
→ Type `p` (move down again)
→ Type `e` (select Delete file)

→ Work continues ✅

Advantages:

  • Send arrow key events from Slack
  • Clearly distinguished by backticks
  • Instant delivery (< 1 second)

Limitations:

  • Only 5 commands available (r, l, u, p, e)
  • Can’t type directly (y/n, number input not supported)

Use Cases:

  • When Claude Code shows a selection list
  • When selecting items from a menu
  • “Press Enter to continue” prompts
  • UI that can be navigated with arrow keys

2.5 Stage 4: Plain Text (Claude Code Execution)

Format: Just speak naturally

Examples:

"Find the cause of the test failure"
"Add a new script to package.json"
"API response is slow. Optimize it"

Processing Flow:

  1. Message processing pipeline forwards to Claude Code
  2. Added to task queue
  3. Claude Code understands context and executes
  4. Requests interactive input via DSL when needed

Advantages:

  • Natural: No need to memorize commands
  • Intelligent: AI understands intent and chooses the best approach
  • Context-aware: Remembers previous conversations
  • Complex tasks possible: Debugging, refactoring, analysis

Limitations:

  • Slow: Claude Code analysis takes time (10-30 seconds)
  • Uncertainty: AI might misunderstand your intent

Use Cases:

  • Complex tasks (debugging, refactoring)
  • When you don’t know the exact command
  • Tasks requiring multiple steps

3. Plain Text vs /run vs DSL: When to Use What?

3.1 Comparison Table

Method Format Purpose Processing Speed Example
Plain text “Just speak” Task requests Slow (10-30s) “Find the bug”
DSL `r/l/u/p/e` Arrow/Enter input Instant (< 1s) `p`, `e`
/run /run snippet-name Execute complex commands Medium (2-5s) /run deploy

3.2 When to Use Plain Text

Complex Analysis:

"API response is slow. Find the cause and optimize it"
→ Claude Code profiles → finds bottleneck → suggests optimization

Code Modifications:

"Add an email field to the User model and create a migration"
→ Claude Code finds files → modifies → generates migration

3.3 When to Use DSL

Navigating Selection Lists:

Claude Code:
  > Option A
    Option B
    Option C

→ In Slack: `p` (move down)
→ In Slack: `e` (select)

Menu Navigation:

Claude Code:
  [File] [Edit] [View]

→ In Slack: `r` (move right)
→ In Slack: `e` (select)

Enter Prompts:

Claude Code: "Press Enter to continue..."
→ In Slack: `e`

3.4 When to Use /run (Snippets)

Frequently Used Complex Commands:

/run deploy

→ Snippet contents:
   npm run build &&
   npm test &&
   git push &&
   ssh deploy@server "cd /app && git pull && pm2 restart app"

Patterned Tasks:

/run backup
/run lint-fix
/run db-migrate

4. Channel-Based Project Management: The Channel = Project Pattern

4.1 Setup Method

Step 1: Create Slack channels



#project-blog
#project-api
#project-frontend

Step 2: Invite the Slack Bot to each channel

/invite @remote-claude

Step 3: Connect projects in each channel

# In #project-blog
/setup blog /Users/idongho/proj/blog

# In #project-api
/setup api /Users/idongho/proj/api

# In #project-frontend
/setup frontend /Users/idongho/proj/frontend

Done: Each channel now operates independently

4.2 How It Works

Channel Identification:

// Simplified code
const channelId = message.channel;
const projectPath = channelProjects.get(channelId);
// #project-blog → /Users/idongho/proj/blog

Separate tmux Sessions:

Each channel has an independent tmux session

#project-blog    → tmux session: blog-session
#project-api     → tmux session: api-session
#project-frontend → tmux session: frontend-session

Separate Task Queues:

Each channel has an independent task queue

#project-blog    → Queue: [task1, task2]
#project-api     → Queue: [task3]
#project-frontend → Queue: []

4.3 Switching Between Channels

Scenario: API error occurs while working on blog

1. Working in #project-blog
   "Help me write a post"
   → Claude Code running...

2. Switch to #project-api
   "Debug API 500 error"
   → Starts working immediately, independently
   → No impact on blog session

3. Return to #project-blog later
   → Previous context preserved

5. Task Queue System: FIFO Guarantee

5.1 Why Is a Task Queue Necessary?

The Problem:

3 commands sent 1 second apart:
1. "Modify file A"
2. "Modify file B"
3. "Test using files A and B"

→ If executed simultaneously? Tests run before files are modified!

The Solution: Task queue for guaranteed ordering

5.2 The FIFO (First-In-First-Out) Principle

What Is FIFO?
FIFO means “first in, first out” — remote-claude’s task queue system operates using the FIFO method.

FIFO Processing Order:

Message arrival order:
1. "npm run build" (10:00:00)
2. "npm test" (10:00:01)
3. "git push" (10:00:02)

FIFO task queue:
[build] → [test] → [push]

FIFO execution order:
build completes → test starts → test completes → push starts

FIFO Guarantees:

  • Never runs simultaneously within the same channel
  • Following FIFO principle, next task starts after previous completes
  • When task is cancelled, it’s removed from the FIFO queue

5.3 One Task Per Channel Limit

Why This Limitation:

  • Claude Code can’t run multiple tasks simultaneously on one project
  • Prevents file conflicts
  • Resource efficiency

Example:

#project-blog task queue: [task1 running, task2 waiting, task3 waiting]
#project-api task queue: [task4 running]

→ Total 2 tasks running simultaneously (1 per channel)

5.4 Checking and Cancelling Task Queue

Check Status:

/state

→ Response:
   Current channel: #project-blog
   Project: /Users/idongho/proj/blog
   Task queue: 2 waiting
   - Running: "Run tests"
   - Waiting: "Build", "Deploy"

Cancel Task:

/cancel

→ Immediately stops running task
→ Starts next task in queue

6. Managing Multiple Projects in Practice

6.1 Scenario: Working on 3 Projects Simultaneously

Situation:

  • Blog: Writing a new post
  • API: Performance issue occurred
  • Frontend: PR review requested

Slack Channel Setup:

#project-blog
#project-api
#project-frontend

6.2 Real Workflow

10:00 – Start Blog Work

In #project-blog:
"Write a Day 4 post draft"

→ Claude Code running (estimated 5 min)

10:01 – API Error Occurs

Switch to #project-api:
"API response is slow. Profile it"

→ Blog work continues in parallel
→ API work also starts

10:05 – Frontend Review

Switch to #project-frontend:
"Review PR #42"

→ All 3 projects now in progress

10:10 – Blog Work Complete

Return to #project-blog:
"Show me the written post"

→ Previous context preserved
→ Ready to review immediately

6.3 Project Switching Patterns

Quick Switching (easy even on mobile):

Just change channels in the Slack app

#project-blog → #project-api (2 taps)

Context Preservation:

Each channel's conversation history = each project's work log
→ Continue where you left off when you return

Independent Task Queues:

#project-blog: [task1 complete, task2 complete]
#project-api: [task3 running]
#project-frontend: [task4 waiting]

→ No interference between them

7. Practical Tips

7.1 Channel Naming Conventions

Recommended Pattern:

#project-{project-name}

Examples:
#project-blog
#project-api-v2
#project-mobile-app

Benefits:

  • Consistency
  • Easy to search (search “project” to find all project channels)

7.2 Task Queue Usage Tips

Break Up Long Tasks:

❌ "Build, test, and deploy"
   → Takes 30 minutes, hard to cancel midway

✅ Execute separately:
   1. "Build it" (5 min)
   2. Review, then "Run tests" (10 min)
   3. If successful, "Deploy" (15 min)

High Priority Tasks:

In urgent cases, use /cancel to stop current task
→ Process high priority task first

7.3 Message Processing Method Selection Guide

Need Arrow Navigation → DSL

For selection lists or menu navigation:
`r`  (right arrow)
`l`  (left arrow)
`u`  (up arrow)
`p`  (down arrow)
`e`  (Enter to select)

Frequently Used Complex Commands → /run Snippets

/run deploy
/run db-backup

Complex Tasks → Plain Text

"Find performance bottlenecks and optimize"
"Implement the new feature"

8. Next Steps

Day 4 Preview: “Maximizing Productivity (4/5): Snippet System and Interactive Buttons”

Now that you understand the 4-stage message processing and task queue, let’s explore ways to maximize productivity:

  • Full utilization of the snippet system
  • File download functionality
  • Automatic message splitting
  • Real-world productivity patterns

Series Navigation

References

Project

Official Documentation

Related Posts

Was this post helpful?

If you have any questions about managing multiple projects simultaneously, leave a comment! 🙌