Routing Workflows with Claude: Send Requests to the Right Pipeline

Stop using one-size-fits-all prompts. Learn how routing workflows categorize user requests and send them to specialized pipelines for better, more consistent results.

Routing workflows solve a common problem in AI applications: different types of user requests need different handling approaches. Instead of using a one-size-fits-all prompt, you can categorize incoming requests and route them to specialized processing pipelines.

If you've ever built an AI feature that works great for some inputs but produces mediocre results for others, routing is probably the solution you need.

The Problem with Generic Prompts

Consider a social media marketing tool that generates video scripts from user topics. A user might enter "programming" or "surfing" as their topic, but these should produce very different types of content:

Programming topics call for educational content with clear explanations and definitions.

Surfing topics work better with entertainment-focused scripts that emphasize excitement and visual appeal.

A single generic prompt can't handle both effectively. If you optimize for educational content, your entertainment scripts will be boring. If you optimize for entertainment, your educational scripts will lack depth.

The generic prompt trap:

Generate a video script about: {topic}

Make it engaging and informative.

This prompt is too vague. Claude has to guess what "engaging" means for each topic, leading to inconsistent results.

Setting Up Content Categories

The first step is defining the different types of content your application might need to generate. You might categorize requests into genres like:

Entertainment

High-energy, culturally relevant content with trendy language and viral potential

Example topics: Surfing, skateboarding, music festivals, travel destinations

Prompt focus: Excitement, visual appeal, cultural relevance, shareability

Educational

Clear, engaging explanations with relatable examples and thought-provoking questions

Example topics: Python functions, quantum physics, personal finance, history

Prompt focus: Clarity, depth, examples, learning outcomes

Comedy

Sharp, unexpected content with clever observations and timing

Example topics: Dating apps, office culture, social media trends, everyday frustrations

Prompt focus: Surprise, relatability, punchlines, comedic timing

Personal Vlog

Authentic, intimate content with conversational storytelling

Example topics: Daily routines, personal challenges, life updates, reflections

Prompt focus: Authenticity, vulnerability, connection, narrative flow

Reviews

Decisive, experience-based content highlighting strengths and weaknesses

Example topics: Tech products, restaurants, movies, services

Prompt focus: Balanced analysis, specific details, recommendations, credibility

Storytelling

Immersive content using vivid details and emotional connection

Example topics: Historical events, personal experiences, fictional narratives

Prompt focus: Imagery, emotion, pacing, character development

Specialized Prompt Templates

Each category gets its own specialized prompt template. Here's what they might look like:

Educational Template

Develop a clear, engaging script that transforms complex information into digestible insights.

Topic: {topic}

Requirements:
- Start with a hook that highlights why this matters
- Break down complex concepts into simple terms
- Use relatable examples and analogies
- Include thought-provoking questions
- End with key takeaways
- Maintain an encouraging, accessible tone

Entertainment Template

Create a high-energy script that captures attention and drives engagement.

Topic: {topic}

Requirements:
- Open with an immediate hook (visual or statement)
- Use trendy, culturally relevant language
- Emphasize excitement and visual appeal
- Include moments designed for sharing/clipping
- Build to a climactic moment
- End with a strong call-to-action

Comedy Template

Write a sharp, funny script with unexpected observations and perfect timing.

Topic: {topic}

Requirements:
- Set up relatable scenarios
- Subvert expectations with clever twists
- Use specific, vivid details (not generic observations)
- Build jokes with proper setup and punchline structure
- Maintain consistent comedic voice
- End with a callback or final punchline

Notice how each template has completely different requirements and tone. This is why routing matters — you can't optimize for all of these simultaneously.

How Routing Works in Practice

The routing process happens in two steps:

Step 1: Categorization

Send the user's topic to Claude with a request to categorize it into one of your predefined genres:

Categorize the topic of a video into one of the listed categories:

<topic>Python functions</topic>

<categories>
- Educational
- Entertainment  
- Comedy
- Personal vlog
- Reviews
- Storytelling
</categories>

Respond with only the category name, nothing else.

Claude's response: Educational

Step 2: Specialized Processing

Use the category result to select the appropriate prompt template and generate content:

# Get the category
category = categorize_topic(user_topic)

# Select the appropriate template
if category == "Educational":
    prompt = EDUCATIONAL_TEMPLATE.format(topic=user_topic)
elif category == "Entertainment":
    prompt = ENTERTAINMENT_TEMPLATE.format(topic=user_topic)
elif category == "Comedy":
    prompt = COMEDY_TEMPLATE.format(topic=user_topic)
# ... etc

# Generate content with the specialized prompt
script = call_claude(prompt)

Routing Workflow Architecture

A routing workflow follows this pattern:

User Input
    ↓
Router (Claude categorizes the request)
    ↓
    ├─→ Educational Pipeline → Educational Prompt → Output
    ├─→ Entertainment Pipeline → Entertainment Prompt → Output
    ├─→ Comedy Pipeline → Comedy Prompt → Output
    ├─→ Review Pipeline → Review Prompt → Output
    ├─→ Vlog Pipeline → Vlog Prompt → Output
    └─→ Storytelling Pipeline → Storytelling Prompt → Output

The key insight: User input only goes to one specialized pipeline, not all of them. This allows each pipeline to be highly optimized for its specific use case.

Advanced Routing Patterns

Multi-Level Routing

Sometimes you need to route multiple times:

User Input
    ↓
Level 1 Router: Content Type (Educational vs Entertainment)
    ↓
Level 2 Router: Format (Short-form vs Long-form)
    ↓
Level 3 Router: Audience (Beginner vs Advanced)
    ↓
Specialized Pipeline

Confidence-Based Routing

Ask Claude to provide a confidence score with its categorization:

Categorize the topic and provide a confidence score (0-100):

<topic>Quantum computing for beginners</topic>

<categories>
- Educational
- Entertainment
</categories>

Format: Category | Confidence

Response: Educational | 95

If confidence is low (< 70), you might:

• Use a fallback "general" pipeline
• Ask the user to clarify their intent
• Route to multiple pipelines and let the user choose

Hybrid Routing

Combine multiple categories for complex requests:

Topic: "Funny review of the new iPhone"

Primary category: Reviews
Secondary category: Comedy

→ Use review template with comedy enhancements

Real-World Example: Customer Support Bot

Here's how routing works for a customer support application:

Categories

• Billing — Payment issues, refunds, subscription changes
• Technical — Bug reports, feature questions, troubleshooting
• Account — Login issues, profile updates, security
• General — Product questions, feedback, other inquiries

Router Prompt

Categorize this customer support request:

<request>
I can't log in to my account. I keep getting an "invalid password" error even though I'm sure my password is correct.
</request>

<categories>
- Billing
- Technical
- Account
- General
</categories>

Respond with only the category name.

Response: Account

Specialized Pipelines

Account Pipeline:

1. Check if it's a password reset request
2. Verify account status (active, suspended, locked)
3. Generate response with password reset link
4. Include security tips

Technical Pipeline:

1. Extract error details
2. Search knowledge base for similar issues
3. Generate troubleshooting steps
4. Escalate to engineering if needed

Billing Pipeline:

1. Fetch account billing history
2. Check for recent charges or refunds
3. Generate response with transaction details
4. Offer refund if applicable

Each pipeline has completely different logic, tools, and prompts optimized for its category.

Implementation Best Practices

1. Make Categories Mutually Exclusive

Bad categories (overlap):

• "Technical questions"
• "Product questions"
• "Feature questions"

Good categories (distinct):

• "Bug reports"
• "Feature requests"
• "How-to questions"

2. Provide Clear Category Descriptions

Don't just list category names. Give Claude context:

<categories>
- Educational: Explaining concepts, teaching skills, answering "how" or "why"
- Entertainment: Showcasing experiences, highlighting excitement, emphasizing visuals
- Comedy: Making jokes, satirizing topics, finding humor in situations
</categories>

3. Handle Edge Cases

What happens when Claude can't categorize confidently?

category, confidence = categorize_with_confidence(user_input)

if confidence < 70:
    # Fallback to general pipeline or ask user to clarify
    return handle_ambiguous_request(user_input)
else:
    return route_to_pipeline(category, user_input)

4. Log Routing Decisions

Track which requests go to which pipelines:

log_routing_decision(
    user_input=user_input,
    category=category,
    confidence=confidence,
    timestamp=now()
)

This helps you:

• Identify misrouted requests
• Discover new categories you need
• Optimize your router prompt

5. Test Your Router

Create a test suite with known inputs and expected categories:

test_cases = [
    ("Python functions", "Educational"),
    ("Best surfing spots in Hawaii", "Entertainment"),
    ("Why dating apps are terrible", "Comedy"),
    ("iPhone 15 Pro review", "Reviews"),
]

for input, expected_category in test_cases:
    actual_category = categorize_topic(input)
    assert actual_category == expected_category

When to Use Routing

Routing workflows work well when:

✅ Your application handles diverse types of requests that need different approaches

✅ You can clearly define categories that cover your use cases without too much overlap

✅ The categorization step can be handled reliably by Claude (test this!)

✅ The performance benefit of specialized processing outweighs the overhead of the routing step

✅ Different request types need different tools or data sources (e.g., billing vs. technical support)

When NOT to Use Routing

Routing adds complexity. Avoid it when:

❌ All requests can be handled well by a single prompt — Don't over-engineer

❌ Categories are too similar — If pipelines would be nearly identical, routing adds no value

❌ Categorization is unreliable — If Claude can't categorize accurately, routing will fail

❌ Latency is critical — The extra categorization call adds delay

❌ You have very few request types — Just use conditional logic instead

Measuring Routing Success

Track these metrics to know if routing is working:

📊 Categorization accuracy — What % of requests are routed correctly?

📊 Output quality by category — Are specialized pipelines producing better results?

📊 User satisfaction by category — Do users prefer routed responses?

📊 Routing confidence distribution — How often is Claude uncertain?

📊 Misrouted request rate — How often do you need to manually reroute?

Combining Routing with Other Patterns

Routing works great with other workflow patterns:

Routing + Chaining

User Input
    ↓
Router → Category
    ↓
Specialized Pipeline:
  Step 1: Research
  Step 2: Draft
  Step 3: Revise

Routing + Evaluator-Optimizer

User Input
    ↓
Router → Category
    ↓
Specialized Pipeline:
  Producer: Generate content
  Grader: Evaluate against category-specific criteria
  Loop: Refine until quality threshold met

Routing + Parallel Processing

User Input
    ↓
Router → Multiple Categories (e.g., "Educational + Comedy")
    ↓
Process in parallel:
  Educational Pipeline | Comedy Pipeline
    ↓                      ↓
Merge results → Hybrid output

Conclusion

Routing workflows are especially valuable for customer service bots, content generation tools, and any application where the "right" response depends heavily on understanding the type of request being made.

The routing mindset:

• One size does NOT fit all
• Categorize first, process second
• Specialize your pipelines
• Measure and optimize routing accuracy

Start by identifying the 3-5 most common types of requests your application handles. Build specialized prompts for each. Add a simple router. Test it. You'll likely see immediate quality improvements for requests that were previously handled poorly by your generic prompt.

As your application grows, you can add more categories, refine your router, and build increasingly sophisticated pipelines for each request type.

What types of requests are you routing in your application? Share your routing strategies in the comments or join the discussion on the Anablock community forum.

Want to dive deeper into Claude workflow patterns? Check out our other guides:

• Workflow Chaining with Claude
• Workflows vs Agents: When to Use Each Strategy
• Supercharge Your MCP Servers with Pre-Built Prompts