Agent skill · Data & Analytics

chatbot-flow-design

Designing conversational flows for website chatbots and AI agents. Intent recognition architecture, branching logic, fallback handling, escalation to human, conversation analytics. Honest about scripted-bot (rigid trees, fail edge cases), hallucinating-bot (LLM without structure, makes things up), and structured-guided-conversation (LLM-powered with intent architecture and fallback discipline) patterns. Distinguishes chatbot DESIGN (this skill) from chatbot IMPLEMENTATION (engineering and platform work). Triggers on chatbot, conversational AI, AI agent, chat widget, intent design, conversation

RampStack477★ · 1 repos on radarProfile →
claude-codeMIT
Install
npx skills add rampstackco/claude-skills --skill chatbot-flow-design --agent claude-code

Same command for any agent — swap --agent for codex, cursor, copilot.

Facts
Files in the skill folder: 10
SKILL.md size: 20 KB
Bundled scripts: none
Path: skills/chatbot-flow-design/SKILL.md
Open the folder on GitHub →
Where it comes from
Stars: 515
Language: Python
Read our review of the source →

Weekly change comes from our own snapshots, not the repository page — it measures attention, not adoption.

Review
written from the skill's own SKILL.md · Aug 5, 2026

What it does

Describes how to design chatbot conversational flows with a defined set of intents, grounding in a knowledge base, and structured fallback and escalation patterns. It positions three archetypes (scripted-bot, hallucinating-bot, structured-guided-conversation) and provides guidance on when to use a design approach, how to create intent architectures (named intents, hierarchies, boundaries), grounding practices, branching logic, fallbacks, and escalation to human agents. It also covers when to deploy a chatbot and how to measure performance through conversation analytics and common failure modes. The skill emphasizes avoiding ungrounded, over-generalized, or misrouted conversations and aims for honest scope and maintainable design.

How it works

Outlines concrete design components and patterns:

  • Intent architecture: define a bounded set of explicit intents, potentially with hierarchies and clear boundaries; ensure 70-90 percent coverage with intents and reserve rest for fallback.
  • Knowledge-base grounding: require responses to be grounded to a knowledge base, using retrieval-augmented generation and a source-of-truth design; cite sources when answering.
  • Branching and conditional logic: enable intent-driven, context-driven, and user-attribute branching with multi-turn depth, keeping branching depth manageable (3-5 turns typical).
  • Fallback patterns: implement clarifying questions, suggested intents, resource handoffs, and human escalation with multiple fallback layers and honesty about limitations.
  • Escalation to human: escalate based on user requests, out-of-scope intents, repeated unclear exchanges, sentiment, or high-stakes topics, passing conversation history and recognized intent.
  • Conversation analytics: track intent recognition rate, resolution rate per intent, fallback rate, escalation rate, and user satisfaction to guide improvements.
  • Common failure modes: recognize hallmarks such as ungrounded hallucinations, rigid scripted behavior, or misrouted flows, and address grounding and intent sets accordingly.

When to use it

Use this design approach when scoping a chatbot for the first time, auditing a chatbot that hallucinates or fails edge cases, designing the intent architecture and fallback patterns, or deciding when to escalate to humans.

What it can touch

The skill references and relies on knowledge-base grounding and escalation patterns, and specifies using retrieval-augmented grounding, source-of-truth design, and citation discipline as part of the bot's behavior. It involves designing intent architecture, branching logic, fallbacks, and escalation pathways, and measuring performance with analytics.

Caveats

Outlines limitations and risks, including the need for maintenance of intents and knowledge bases, the potential for drift and stale knowledge, and the trade-offs between scripted, hallucinating, and structured-guided approaches. It notes that the structured-guided-conversation approach requires upfront design effort and ongoing maintenance. All statements describe design principles, patterns, and measurement practices without promising outcomes beyond what is stated.

From the SKILL.md

# Chatbot Flow Design A senior growth practitioner's playbook for designing conversational flows for website chatbots and AI agents. Intent recognition architecture, branching logic, fallback handling, escalation to human, conversation analytics. The discipline of building a bot that knows what it knows and routes appropriately when it does not. Most chatbots on the web fail in one of two ways. Scripted bots break the moment a user phrases something the script did not anticipate; the user gets pushed through a decision tree that does not fit their situation. LLM-powered bots without structure hallucinate; they confidently answer questions about pricing, policy, or capabilities and frequently make up answers, creating support burden and trust damage. The chatbots that work do something different. They have an intent architecture that defines what the bot can and cannot handle. They ground their responses in a knowledge base so they do not invent facts. They have explicit fallback paths for unclear or out-of-scope intents. They escalate to humans cleanly when the bot's job is done. The audience trusts the bot because the bot is honest about its scope. The voice is the senior growth p

What's inside
Steps it walks through
  1. What this skill covers
  2. The chatbot decision: when chatbots earn deployment
  3. Scripted-bot vs hallucinating-bot vs structured-guided-conversation
  4. Intent architecture
  5. Knowledge-base grounding
  6. Branching and conditional logic
  7. Fallback patterns
  8. Escalation to human
  9. Conversation analytics
  10. Common failure modes
  11. The framework: 12 considerations for chatbot flow design
  12. Reference files
  13. Closing: chatbots earn deployment when they know what they don't know
Ships with 9 files
  • references/branching-and-conditional-logic.md
  • references/chatbot-anti-patterns.md
  • references/chatbot-decision-criteria.md
  • references/common-chatbot-failures.md
  • references/conversation-analytics-patterns.md
  • references/escalation-to-human-patterns.md
  • references/fallback-pattern-design.md
  • references/intent-architecture-patterns.md
  • references/knowledge-base-grounding-patterns.md
More from claude-skills
All skills →
About this skill
What does the chatbot-flow-design skill do?

Designing conversational flows for website chatbots and AI agents. Intent recognition architecture, branching logic, fallback handling, escalation to human, conversation analytics. Honest about scripted-bot (rigid trees, fail edge cases), hallucinating-bot (LLM without structure, makes things up), and structured-guided-conversation (LLM-powered with intent architecture and fallback discipline) patterns. Distinguishes chatbot DESIGN (this skill) from chatbot IMPLEMENTATION (engineering and platform work). Triggers on chatbot, conversational AI, AI agent, chat widget, intent design, conversation

How do I install it?

Run `npx skills add rampstackco/claude-skills --skill chatbot-flow-design --agent claude-code` — it drops the skill into your project so the agent can pick it up. Swap the --agent value for codex, cursor or copilot if you use one of those.

Where does this skill come from?

From rampstackco/claude-skills, a repository with 515 stars. We read it straight from the repository tree rather than a submitted listing, so what you see here is what is actually published.

Is a popular skill a good skill?

Not necessarily. Stars measure attention, not adoption — a repository can trend for a week and be abandoned. That is why we show the weekly change from our own snapshots next to the total, instead of a single flattering number.

Keep going