Design Conversational AI Flows

This skill designs and implements conversational AI flows for natural, engaging, effective dialogue systems, covering conversation state management, context preservation, error handling, and UX optimization. Turn-management principles call for clear turn boundaries with appropriate prompts, graceful conversation-recovery mechanisms, confirmation patterns for critical interactions, and natural handling of interruptions and context switches. A conversation-state class tracks the current intent, extracted entities, conversation history, user context, and position within the flow.

Flow architecture covers intent-based routing (a booking flow triggered by intent and required entities, with named steps each carrying a prompt, validation, and fallback, plus a dedicated fallback flow triggered by low confidence or unrecognized intent) and slot filling (checking which required slots are still missing and prompting for the next one before proceeding). NLU integration covers intent classification with confidence-threshold handling and three fallback strategies - asking for clarification, suggesting alternatives, or escalating to a human. Error handling uses a progressive-disclosure pattern: up to three retry attempts, each with an escalating strategy (rephrase, offer options, or connect to a human agent) rather than repeating the same failure message.

Response generation uses contextual templates (multiple phrasings per situation type, chosen and filled in with the current context) and multimodal rich responses (quick-reply buttons and cards with images and actions) for platforms that support them. Conversation analytics tracks flow performance - completion rate, average turns, fallback rate, user satisfaction, and where users abandon the flow - and feeds an optimizer that identifies bottlenecks and suggests A/B test variations.

def slot_filling_handler(state, required_slots):
    missing_slots = []
    for slot in required_slots:
        if slot not in state.entities or not state.entities[slot]:
            missing_slots.append(slot)
    
    if missing_slots:
        next_slot = missing_slots[0]
        return generate_slot_prompt(next_slot, state)
    
    return proceed_to_next_step(state)

Use this skill when designing a conversational AI flow - intent-based routing, slot filling for structured data collection, confidence-based fallback handling, or a flow-performance analytics and optimization loop.

It is not a fit for the underlying NLU model training itself - the skill assumes an intent classifier and entity extractor already exist and focuses on the flow, state management, and recovery logic built around them.

Inputs are the conversation flows you need to support (intents, required entities per flow, fallback conditions). Outputs are a working conversation-state manager, intent-routed flow definitions with slot filling and fallback handling, contextual response templates, and a flow-analytics tracker with bottleneck-driven A/B test suggestions.

Conversational AI and chatbot developers who need concrete flow-design patterns - state management, slot filling, confidence-based fallback, and progressive error recovery - plus best practices for personality consistency (clear guidelines maintained throughout, formality adapted to context), proactive conversation management (anticipating needs, timeout handling), and testing (happy-path and edge-case scenarios, conversation simulation, real-user monitoring).