conversation-flow

Conversation Flow and Routing Design

R — Original Text (Reading)

Core conversation management patterns emerging from cross-vendor system prompts: first split user input into "questions" and "tasks" (Warp), then route by domain to specialized processing pipelines (Claude Chrome's "chip" mechanism). Claude Design requires at least 10 questions to be asked before starting any new design; ChatGPT Agent advocates "push forward as much as possible, and only request clarification when blocked." Codex skips planning for simple tasks, while Jules has a formal plan review step. The core tension lies in the balance between "ask clearly first" and "do it first and figure it out later."

I — Methodological Skeleton (Interpretation)

1. Intent Dichotomy — First classify user input as "information query" (question) or "task execution" (action), triggering different processing pipelines
2. Domain Routing Table — Establish a specialized processing pipeline for each identified domain (email/document/code/search, etc.), including input validation and output formatting
3. Clarification Strategy Spectrum — From "ask first, then do" (high clarification) to "assume and continue" (low clarification), selected according to task complexity and risk level
4. Autonomy Grading — Define the extent to which the AI can proceed autonomously: low (confirm every step) → medium (confirm at key nodes) → high (report after completion)
5. Structured Workflow Lifecycle — Ask → Explore → Plan → Execute → Verify → Summarize, with clear entry/exit conditions for each stage
6. Simplified Task Fast Track — For tasks estimated to be below the complexity threshold (such as Codex's 25% simple tasks), skip planning and execute directly
7. Tool-First Principle — If a request can be resolved directly through a tool call, call the tool immediately without requesting permission (Notion AI)

A1 — Case Analysis (Past Application)

Case: Claude Design's Ten-Question Startup Process

• Problem: The highly open-ended nature of design tasks causes the AI to often produce results that deviate from user expectations based on vague requirements
• Use of the Design Pattern: The Claude Design system prompt requires at least 10 clarification questions before starting any new design, covering dimensions such as target users, design style, functional scope, and technical constraints. The workflow is: Ask → Explore → Plan → Build → Verify → Summarize
• Conclusion: Although the mandatory clarification stage adds upfront turns, it significantly reduces the later rework rate

Case: ChatGPT Agent's "Push Forward as Much as Possible" Strategy

• Problem: Frequently requesting user confirmation leads to low task completion efficiency and a fragmented user experience
• Use of the Design Pattern: The ChatGPT Agent system prompt requires "push forward as much as possible, without unnecessary checks." Only request user clarification when truly blocked; otherwise, use the "assume... and continue" pattern to proceed autonomously
• Conclusion: This strategy is suitable for high-autonomy scenarios, but its tolerance for ambiguous requirements is relatively low, requiring a trade-off between "advancement speed" and "directional accuracy"

Case: Warp's binary routing

• Problem: Mixed handling of queries and tasks leads to chaotic output formats—providing execution steps when answering questions, and theoretical explanations when executing tasks
• Use of the design pattern: The Warp system prompt strictly dichotomizes user input into "questions" (→ concise instructional answers) and "tasks" (→ direct execution), eliminating format ambiguity
• Conclusion: Simple binary routing significantly improves output consistency, and is especially suitable for efficient scenarios such as terminal/CLI

A2 — Trigger Scenarios (Future Trigger) ★

In what situations do users need this?

1. Designing multi-task AI assistants that need to route to different processing flows based on user intent (e.g., customer service bots for tickets/FAQ/human handoff)
2. Building programming/design tool AI that needs to find a balance between "ask clearly first" and "do first, talk later"
3. Optimizing the conversational experience of existing AI products—users report "asks too many questions" or "acts without asking, frequently goes off track"
4. Designing workflow lifecycles for AI Agents, requiring definition of a standard process of planning → execution → verification
5. Implementing a "fast track" mechanism—simple tasks skip planning and execute directly, complex tasks go through the full process

Language signals

• "AI asks too many/too few questions"
• "Different types of requests need different handling methods"
• "Simple tasks should not go through a complex process"
• "Need to plan before executing"
• "Users expect the AI to start working after saying just one sentence"

Distinction from adjacent skills

• Difference from output-formatting : output-formatting controls the "form" of output, while this Skill controls the process logic that determines "what to output"
• Difference from agent-delegation : agent-delegation manages task allocation among multiple agents, while this Skill manages conversation routing within a single agent
• Difference from context-management : context-management manages information storage and loading, while this Skill manages conversation decision logic

E — Executable Steps (Execution)

1. Define the intent classification system — Completion criteria: Establish at least a three-level intent classification (e.g., information query / simple task / complex task), with each level having clear judgment criteria and example inputs

2. Design the domain routing table — Completion criteria: Define a dedicated processing flow for each supported domain (at least 3), including input validation rules, processing steps, output format requirements, and exception handling paths

3. Establish a clarification strategy spectrum — Completion criteria: Define at least three clarification strategy levels (high/medium/low), each with clear trigger conditions (e.g., task risk level, information completeness score), and provide example dialogue patterns for each level

4. Design the workflow lifecycle — Completion criteria: Define at least five stages (questioning → exploration → planning → execution → verification), each with clear entry conditions, core actions, exit conditions, and skippable conditions

5. Implement the fast-track mechanism — Completion criteria: Define the criteria for determining simple tasks (e.g., input length < N and contains explicit instruction verbs), as well as the skip rules for the fast track (which stages to skip, which checkpoints to retain)

B — Boundary ★

Do not use in the following cases

• Single-turn Q&A systems — there is no conversation state to manage, and routing is redundant
• Pure API services — request-response pattern, there is no conversation flow to design
• Automated processes with very fixed rules — AI autonomous decision routing is not needed
• Creative conversation/small talk scenarios — over-structuring will break the natural feel

Common failure modes

• Over-routing: designing a dedicated flow for every possible input, causing the routing table to bloat and become hard to maintain
• Insufficient clarification: under the "advance as much as possible" strategy, directly executing even ambiguous requirements, leading to wrong direction and extensive rework
• Excessive clarification: forcing a complete questioning process on simple tasks, making the user experience feel like filling out a form rather than a conversation
• Fast-track misjudgment: misjudging a complex task as a simple task and skipping planning, leading to execution failure and having to roll back
• Ignoring context continuity: reclassifying on every input, losing intent information from the conversation history