My Discord Bot: Mastering Interactions with Buttons & Menus

Hey everyone, Marcus here from ai7bot.com. Today, I want to talk about something that’s been buzzing in my own bot-building world lately: managing Discord bot interactions with the new message components. If you’ve been dabbling with Discord bots, you know the pain of command spam, or trying to guide users through complex choices without making them type out essay-length responses. Well, the Discord API updates have been a godsend, and specifically, I’m talking about buttons and select menus.

For a while now, my personal bot, “Chronos,” which helps me manage my D&D campaigns and automates some of the more tedious aspects of being a DM, was getting a bit… chatty. Imagine a command like !add_monster. Then Chronos asks for the monster’s name. Then its HP. Then its AC. Then its initiative bonus. You get the picture. It was a waterfall of text, and frankly, it was a terrible user experience, even for me, the creator!

I tried various tricks – editing messages, deleting previous prompts, but it always felt clunky. Then Discord rolled out message components, and it was like someone finally heard my silent pleas. No, it wasn’t a “game-changer” in the sense of a complete paradigm shift, but it was a massive quality-of-life improvement for how users interact with bots. And for us bot builders, it means we can make our bots feel a lot more intuitive and less like a glorified command-line interface.

Today, I want to dive into how I’ve been using buttons and select menus to streamline Chronos’s interactions, specifically focusing on a common bot use case: user-guided configuration and dynamic choices. We’re not just going to talk theory; I’ll show you some practical examples and even a little Python code (using discord.py, my go-to library) to get you started.

Beyond the Basic Command: Why Components Matter

Think about it. When you interact with any modern application, you’re not typing commands for everything, right? You click buttons, you select options from dropdowns, you use sliders. That’s the natural way we interact with software. Why should bots be any different?

Before components, if you wanted a user to choose between “Orc,” “Goblin,” and “Zombie” for a monster type, you’d probably have your bot send a message like:

Please choose a monster type:
1. Orc
2. Goblin
3. Zombie

Reply with the number.

Then your bot would have to listen for the next message, parse it, handle invalid inputs, and so on. It’s tedious for the user and a pain to program robustly. With components, Chronos can now present those options as clickable buttons or a neat dropdown menu, right there in the Discord client. The user clicks, and the bot instantly knows their choice. It’s clean, efficient, and significantly reduces user error.

My biggest win with this was streamlining the “add monster” flow. Instead of multiple back-and-forth messages, I now present a series of buttons for common monster types, or a “Custom” button that then opens a modal for more detailed input. It’s a huge improvement.

Buttons: The Quick Decision Makers

Buttons are fantastic for simple, immediate actions or choices. Think “Yes/No,” “Confirm/Cancel,” or selecting from a small, fixed set of options. They’re visually prominent and easy to click.

Chronos Example: Confirming a Combat Encounter

When I use Chronos to initiate a combat encounter, after I’ve added all the monsters, Chronos used to just say, “Combat started!” But sometimes I’d forget to add a monster, or accidentally add an extra one. Now, before starting, Chronos sends a summary and asks for confirmation:

Encounter Summary:
- 3 Goblins
- 1 Orc Chieftain

Ready to start combat?

Below this message, I now have two buttons: “Start Combat” and “Cancel & Edit.”

Here’s a simplified look at how you’d create those buttons with discord.py (version 2.0+):

import discord
from discord.ui import Button, View

class CombatConfirmationView(View):
 def __init__(self):
 super().__init__(timeout=60) # Timeout after 60 seconds if no interaction

 @discord.ui.button(label="Start Combat", style=discord.ButtonStyle.green, custom_id="start_combat_button")
 async def start_combat_callback(self, interaction: discord.Interaction, button: Button):
 await interaction.response.send_message("Combat initiated! Let the dice roll!", ephemeral=True)
 # Here you'd add your actual combat start logic
 self.stop() # Stop listening for further interactions on this view

 @discord.ui.button(label="Cancel & Edit", style=discord.ButtonStyle.red, custom_id="cancel_combat_button")
 async def cancel_combat_callback(self, interaction: discord.Interaction, button: Button):
 await interaction.response.send_message("Combat setup cancelled. Use `!add_monster` or `!remove_monster` to adjust.", ephemeral=True)
 self.stop() # Stop listening

@bot.command()
async def prepare_combat(ctx):
 # This is a placeholder for your actual encounter summary
 summary_message = "Encounter Summary:\n- 3 Goblins\n- 1 Orc Chieftain\n\nReady to start combat?"
 await ctx.send(summary_message, view=CombatConfirmationView())

A few things to note here:

• discord.ui.View is the container for your components.
• @discord.ui.button is a decorator to turn a method into a button callback.
• custom_id is crucial! This unique string identifies which button was pressed when the bot receives the interaction.
• interaction.response.send_message(..., ephemeral=True) is great for providing feedback that only the interacting user can see. This keeps the channel clean.
• self.stop() is important if you want the view to stop listening for interactions after a choice has been made. Otherwise, users could keep clicking buttons on an old message.

This simple change made the “start combat” process so much less stressful for me. No more accidental starts or frantic “undo” commands.

Select Menus: For More Complex Choices

When you have more than a handful of options, or options that might change dynamically, a select menu (dropdown) is a much better choice than a long row of buttons. Buttons get visually overwhelming very quickly.

Chronos Example: Choosing a Target for a Spell

In D&D, when a spell like “Magic Missile” is cast, I need to know who the caster is targeting. Before, I’d have to type out each target, and Chronos would try to match them. Now, when a spell is cast, Chronos can present a dropdown with all active combatants.

import discord
from discord.ui import Select, View

class TargetSelectionView(View):
 def __init__(self, targets: list[str]):
 super().__init__(timeout=60)
 self.add_item(TargetSelect(targets))

class TargetSelect(Select):
 def __init__(self, targets: list[str]):
 options = [
 discord.SelectOption(label=target, description=f"Select {target} as a target.")
 for target in targets
 ]
 super().__init__(placeholder="Choose your target(s)...", min_values=1, max_values=len(targets), options=options, custom_id="target_select_menu")

 async def callback(self, interaction: discord.Interaction):
 selected_targets = interaction.data['values']
 await interaction.response.send_message(f"You selected: {', '.join(selected_targets)}. Processing spell effects...", ephemeral=True)
 # Here you'd integrate with your spell logic, applying damage, etc.
 # You might also want to disable the select menu after selection:
 # self.view.stop() # If you want to stop the view
 # await interaction.message.edit(view=None) # To remove the view entirely from the message

@bot.command()
async def cast_spell(ctx, spell_name: str):
 # This would come from your active combatants list
 active_combatants = ["Goblin 1", "Goblin 2", "Orc Chieftain", "Player_Bard"]
 if not active_combatants:
 await ctx.send("No active combatants to target!")
 return

 await ctx.send(f"Who are you targeting with {spell_name}?", view=TargetSelectionView(active_combatants))

A few key differences for select menus:

• You create discord.SelectOption objects for each item in the dropdown.
• placeholder is the text shown before selection.
• min_values and max_values control how many options the user can pick (1 and len(targets) in my example, allowing single or multiple targets).
• The selected values are found in interaction.data['values'].

This has made casting area-of-effect spells or multi-target spells so much easier. No more typos in monster names, no more forgetting who’s on the field. It’s all presented clearly.

Putting it all Together: Designing Your Interaction Flow

The real power comes when you combine these components. You can have a button that, when clicked, brings up a select menu, or a modal (another component type for more complex text input). This allows you to build multi-step, guided interactions without flooding the channel with messages.

My “Add Monster” Evolution

My !add_monster command now looks something like this:

1. User types !add_monster.
2. Chronos sends a message with buttons: “Common Monsters,” “Custom Monster,” “Import from Compendium.”
3. If “Common Monsters” is clicked:
   • Chronos edits the message to replace the buttons with a select menu populated with a list of frequently used monsters (Goblin, Orc, Skeleton, etc.).
   • User selects one or more monsters.
   • Chronos adds them and sends a confirmation.
4. If “Custom Monster” is clicked:
   • Chronos brings up a modal asking for Name, HP, AC, Initiative.
   • User fills out the modal and submits.
   • Chronos adds the custom monster and sends a confirmation.
5. If “Import from Compendium” is clicked:
   • Chronos sends a message asking for the monster’s name, then uses an API to fetch stats. (This is still a text input for now, but I’m looking into using an autocomplete text input for the modal).
   • Confirmation message.

This flow is infinitely better than the old text-based waterfall. It feels like a real application, not just a bot spitting out prompts.

Actionable Takeaways for Your Bots

1. Identify Repetitive Text Prompts: Go through your bot’s commands. Are there places where you constantly ask users to type “Yes” or “No,” or choose from a fixed list? That’s your first target for buttons or select menus.
2. Simplify Complex Workflows: If a command requires multiple pieces of information from the user, consider breaking it down with components. A button could lead to a modal, or a select menu could branch into different follow-up questions.
3. Reduce User Error: Typographical errors are a bot’s worst enemy. Components eliminate them for fixed choices, making your bot more reliable and less frustrating to use.
4. Use ephemeral=True for Feedback: When a user interacts with a component, use ephemeral messages for simple “Action received!” or “Option selected!” feedback. This keeps the main channel tidy.
5. Manage View Lifecycles (self.stop() and timeout): Don’t let old components clutter up your channel and remain interactive indefinitely. Set timeouts for your views, and use self.stop() when an interaction is complete to prevent further use. You can also edit the message to remove the view entirely after interaction (await interaction.message.edit(view=None)).
6. Test Thoroughly: Components add a new layer of asynchronous interaction. Test all paths, especially error handling and what happens when users don’t interact within the timeout period.

Implementing Discord message components isn’t just about making your bot look cooler; it’s about making it genuinely easier and more pleasant for users to interact with. For Chronos, it’s meant more smooth D&D sessions and less time spent fighting the bot interface. For your bots, it means higher engagement and a better experience for everyone. So go on, give those buttons and select menus a try. Your users (and your future self) will thank you for it!

🕒 Published: April 19, 2026