diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/CommandListener.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/CommandListener.kt
index 5fe8c84..d3c2eba 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/CommandListener.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/CommandListener.kt
@@ -3,14 +3,21 @@ package at.hannibal2.skyhanni.discord
 import at.hannibal2.skyhanni.discord.Utils.hasAdminPermissions
 import at.hannibal2.skyhanni.discord.Utils.inBotCommandChannel
 import at.hannibal2.skyhanni.discord.Utils.logAction
-import at.hannibal2.skyhanni.discord.Utils.reply
-import at.hannibal2.skyhanni.discord.command.BaseCommand
 import at.hannibal2.skyhanni.discord.command.HelpCommand
-import at.hannibal2.skyhanni.discord.command.PullRequestCommand
+import at.hannibal2.skyhanni.discord.command.BaseCommand
+import at.hannibal2.skyhanni.discord.command.MessageEvent
+import at.hannibal2.skyhanni.discord.command.SlashCommandEvent
 import at.hannibal2.skyhanni.discord.command.ServerCommands
+import at.hannibal2.skyhanni.discord.command.PullRequestCommand.isPullRequest
+import at.hannibal2.skyhanni.discord.command.ServerCommands.isKnownServerUrl
 import at.hannibal2.skyhanni.discord.command.TagCommands
+import at.hannibal2.skyhanni.discord.command.TagCommands.handleTag
 import at.hannibal2.skyhanni.discord.command.TagUndo
-import net.dv8tion.jda.api.events.message.MessageReceivedEvent
+import net.dv8tion.jda.api.entities.Guild
+import net.dv8tion.jda.api.events.interaction.command.CommandAutoCompleteInteractionEvent
+import net.dv8tion.jda.api.interactions.commands.OptionType
+import net.dv8tion.jda.api.interactions.commands.build.Commands
+import net.dv8tion.jda.api.interactions.commands.build.SlashCommandData
 import org.reflections.Reflections
 import java.lang.reflect.Modifier
 
@@ -23,42 +30,51 @@ object CommandListener {
 
     fun init() {
         loadCommands()
+
+        BOT.jda.awaitReady()
+
+        BOT.jda.getGuildById(BOT.config.allowedServerId)?.let { createCommands(it) }
     }
 
-    fun onMessage(bot: DiscordBot, event: MessageReceivedEvent) {
+    fun onMessage(bot: DiscordBot, event: MessageEvent) {
         event.onMessage(bot)
     }
 
-    private fun MessageReceivedEvent.onMessage(bot: DiscordBot) {
+    fun onInteraction(bot: DiscordBot, event: SlashCommandEvent) {
+        event.onInteraction(bot)
+    }
+
+    fun onAutocomplete(event: CommandAutoCompleteInteractionEvent) {
+        event.onCompletion()
+    }
+
+    private fun MessageEvent.onMessage(bot: DiscordBot) {
         val message = message.contentRaw.trim()
         if (!isFromGuild) {
             logAction("private dm: '$message'")
             return
         }
-        if (guild.id != bot.config.allowedServerId) return
+        if (event.guild.id != bot.config.allowedServerId) return
 
-        if (this.author.isBot) {
-            if (this.author.id == BOT_ID) {
-                BotMessageHandler.handle(this)
+        if (author.isBot) {
+            if (author.id == BOT_ID) {
+                BotMessageHandler.handle(event)
             }
             return
         }
 
         if (TagUndo.getAllNames().none { "!$it" == message }) {
-            TagCommands.lastMessages.remove(this.author.id)
+            TagCommands.lastMessages.remove(author.id)
         }
 
-        if (ServerCommands.isKnownServerUrl(this, message)) return
-        if (PullRequestCommand.isPullRequest(this, message)) return
-
-        if (!isCommand(message)) return
+        if (isKnownServerUrl(message) || isPullRequest(message) || !isCommand(message)) return
 
         val split = message.substring(1).split(" ")
         val literal = split.first().lowercase()
         val args = split.drop(1)
 
         val command = getCommand(literal) ?: run {
-            TagCommands.handleTag(this)
+            handleTag()
             return
         }
 
@@ -74,13 +90,22 @@ object CommandListener {
             }
         }
 
-        // allows to use `!<command> -help` instaed of `!help -<command>`
+        // allows to use `!<command> -help` instead of `!help -<command>`
         if (args.size == 1 && args.first() == "-help") {
             with(HelpCommand) {
                 sendUsageReply(literal)
             }
             return
         }
+        // allows to use `!<command> -help` instead of `!help -<command>`
+        if (args.size == 1) {
+            if (args.first() == "-help") {
+                with(HelpCommand) {
+                    sendUsageReply(literal)
+                }
+                return
+            }
+        }
         try {
             with(command) {
                 execute(args)
@@ -90,6 +115,74 @@ object CommandListener {
         }
     }
 
+    private fun SlashCommandEvent.onInteraction(bot: DiscordBot) {
+        if (event.guild?.id != bot.config.allowedServerId || author.isBot) return
+
+        val command = getCommand(event.fullCommandName) ?: return
+
+        if (!command.userCommand) {
+            if (!hasAdminPermissions()) {
+                reply("No permissions $PLEADING_FACE")
+                return
+            }
+
+            if (!inBotCommandChannel()) {
+                reply("Wrong channel $PLEADING_FACE")
+                return
+            }
+        }
+
+        try {
+            with(command) {
+                execute(listOf())
+            }
+        } catch (e: Exception) {
+            reply("Error: ${e.message}")
+        }
+    }
+
+    private fun CommandAutoCompleteInteractionEvent.onCompletion() {
+        when (fullCommandName) {
+            "help" -> {
+                if (focusedOption.name != "command") return
+
+                replyChoiceStrings(
+                    commands.filter { it.name.startsWith(focusedOption.value) }
+                        .map { it.name }
+                        .take(25)
+                ).queue()
+            }
+
+            "server" -> {
+                if (focusedOption.name != "keyword") return
+
+                replyChoiceStrings(
+                    ServerCommands.servers.filter { it.name.startsWith(focusedOption.value, true) }
+                        .map { it.name }
+                        .take(25)
+                ).queue()
+            }
+
+            "tagedit" -> {
+                if (focusedOption.name != "keyword") return
+
+                replyChoiceStrings(
+                    Database.listTags().filter { it.keyword.startsWith(focusedOption.value, true) }.map { it.keyword }
+                        .take(25)
+                ).queue()
+            }
+
+            "tagdelete" -> {
+                if (focusedOption.name != "keyword") return
+
+                replyChoiceStrings(
+                    Database.listTags().filter { it.keyword.startsWith(focusedOption.value, true) }.map { it.keyword }
+                        .take(25)
+                ).queue()
+            }
+        }
+    }
+
     private val commandPattern = "^!(?!!)[\\s\\S]+".toPattern()
 
     // ensures the command starts with ! while ignoring !!
@@ -121,6 +214,34 @@ object CommandListener {
         this.commands = commands
         this.commandsMap = commandsMap
     }
+
+    private fun createCommands(guild: Guild) {
+        guild.retrieveCommands().queue {
+            val commandData = commands.map { value -> convertToData(value) }
+
+            guild.updateCommands().addCommands(commandData).queue()
+        }
+    }
+
+    private fun convertToData(old: BaseCommand): SlashCommandData {
+        return Commands.slash(old.name, old.description).apply {
+            old.options.forEach { option ->
+                addOption(
+                    option.type,
+                    option.name.replace(" ", "_"),
+                    option.description,
+                    option.required,
+                    option.autoComplete
+                )
+            }
+        }
+    }
 }
 
-data class Option(val name: String, val description: String, val required: Boolean = true)
\ No newline at end of file
+data class Option(
+    val name: String,
+    val description: String,
+    val required: Boolean = true,
+    val type: OptionType = OptionType.STRING,
+    val autoComplete: Boolean = false
+)
\ No newline at end of file
diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/DiscordBot.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/DiscordBot.kt
index 346f830..b5b20fa 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/DiscordBot.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/DiscordBot.kt
@@ -1,8 +1,12 @@
 package at.hannibal2.skyhanni.discord
 
 import at.hannibal2.skyhanni.discord.Utils.sendMessageToBotChannel
+import at.hannibal2.skyhanni.discord.command.MessageEvent
+import at.hannibal2.skyhanni.discord.command.SlashCommandEvent
 import net.dv8tion.jda.api.JDA
 import net.dv8tion.jda.api.JDABuilder
+import net.dv8tion.jda.api.events.interaction.command.CommandAutoCompleteInteractionEvent
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
 import net.dv8tion.jda.api.events.message.MessageReceivedEvent
 import net.dv8tion.jda.api.hooks.ListenerAdapter
 import net.dv8tion.jda.api.requests.GatewayIntent
@@ -71,12 +75,24 @@ private fun startBot(): DiscordBot {
     }.build()
 
     val bot = DiscordBot(jda, config)
-    jda.awaitReady()
     val messageListener = object : ListenerAdapter() {
         override fun onMessageReceived(event: MessageReceivedEvent) {
-            CommandListener.onMessage(bot, event)
+            CommandListener.onMessage(bot, MessageEvent(event))
+        }
+    }
+    val slashCommandListener = object : ListenerAdapter() {
+        override fun onSlashCommandInteraction(event: SlashCommandInteractionEvent) {
+            CommandListener.onInteraction(bot, SlashCommandEvent(event))
+        }
+
+        override fun onCommandAutoCompleteInteraction(event: CommandAutoCompleteInteractionEvent) {
+            CommandListener.onAutocomplete(event)
         }
     }
+    jda.addEventListener(slashCommandListener)
     jda.addEventListener(messageListener)
+
+    jda.awaitReady()
+
     return bot
 }
diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/Utils.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/Utils.kt
index 1d7b0b7..2b6a2ef 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/Utils.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/Utils.kt
@@ -1,5 +1,6 @@
 package at.hannibal2.skyhanni.discord
 
+import at.hannibal2.skyhanni.discord.command.CommandEvent
 import net.dv8tion.jda.api.EmbedBuilder
 import net.dv8tion.jda.api.entities.Message
 import net.dv8tion.jda.api.entities.MessageEmbed
@@ -20,28 +21,6 @@ object Utils {
 
     private inline val logger get() = BOT.logger
 
-    fun MessageReceivedEvent.reply(text: String) {
-        message.messageReply(text)
-    }
-
-    fun MessageReceivedEvent.userError(text: String) {
-        message.messageReply("❌ $text")
-    }
-
-    fun MessageReceivedEvent.sendError(text: String) {
-        message.messageReply("❌ An error occurred: $text")
-        logAction("Error: $text")
-    }
-
-    fun MessageReceivedEvent.reply(embed: MessageEmbed) {
-        message.messageReply(embed)
-    }
-
-    fun MessageReceivedEvent.replyWithConsumer(text: String, consumer: (MessageReceivedEvent) -> Unit) {
-        BotMessageHandler.log(text, consumer)
-        reply(text)
-    }
-
     fun Message.messageDelete() {
         delete().queue()
     }
@@ -82,31 +61,29 @@ object Utils {
         BOT.jda.getTextChannelById(BOT.config.botCommandChannelId)?.messageSend(text, instantly)
     }
 
-    fun MessageReceivedEvent.logAction(action: String, raw: Boolean = false) {
+    fun CommandEvent.logAction(action: String, raw: Boolean = false) {
         if (raw) {
             logger.info(action)
             return
         }
+
         val name = author.name
         val id = author.id
+        val nickString = member?.nickname?.takeIf { it != "null" }?.let { " (`$it`)" } ?: ""
+        val isFromGuild = isFromGuild
+        val channelSuffix = if (isFromGuild) " in channel '${channel.name}'" else ""
 
-        val nick = member?.nickname?.takeIf { it != "null" }
-        val nickString = nick?.let { " (`$nick`)" } ?: ""
-
-        val channelSuffix = if (isFromGuild) {
-            val channelName = channel.name
-            " in channel '$channelName'"
-        } else ""
         logger.info("$id/$name$nickString $action$channelSuffix")
     }
 
-    fun MessageReceivedEvent.hasAdminPermissions(): Boolean {
+    fun CommandEvent.hasAdminPermissions(): Boolean {
         val member = member ?: return false
+
         val allowedRoleIds = BOT.config.editPermissionRoleIds.values
         return !member.roles.none { it.id in allowedRoleIds }
     }
 
-    fun MessageReceivedEvent.inBotCommandChannel() = channel.id == BOT.config.botCommandChannelId
+    fun CommandEvent.inBotCommandChannel(): Boolean = channel.id == BOT.config.botCommandChannelId
 
     fun runDelayed(duration: Duration, consumer: () -> Unit) {
         Thread {
diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/BaseCommand.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/BaseCommand.kt
index d789707..a8051bf 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/BaseCommand.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/BaseCommand.kt
@@ -1,8 +1,6 @@
 package at.hannibal2.skyhanni.discord.command
 
 import at.hannibal2.skyhanni.discord.Option
-import at.hannibal2.skyhanni.discord.Utils.userError
-import net.dv8tion.jda.api.events.message.MessageReceivedEvent
 
 abstract class BaseCommand {
 
@@ -16,9 +14,9 @@ abstract class BaseCommand {
 
     protected open val aliases: List<String> = emptyList()
 
-    abstract fun MessageReceivedEvent.execute(args: List<String>)
+    abstract fun CommandEvent.execute(args: List<String>)
 
-    protected fun MessageReceivedEvent.wrongUsage(args: String) {
+    protected fun CommandEvent.wrongUsage(args: String) {
         userError("Usage: `!$name $args`")
     }
 
diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/CommandEvent.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/CommandEvent.kt
new file mode 100644
index 0000000..427c013
--- /dev/null
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/CommandEvent.kt
@@ -0,0 +1,114 @@
+package at.hannibal2.skyhanni.discord.command
+
+import at.hannibal2.skyhanni.discord.BotMessageHandler
+import at.hannibal2.skyhanni.discord.Utils.messageReply
+import net.dv8tion.jda.api.entities.Member
+import net.dv8tion.jda.api.entities.Message
+import net.dv8tion.jda.api.entities.MessageEmbed
+import net.dv8tion.jda.api.entities.User
+import net.dv8tion.jda.api.entities.channel.unions.MessageChannelUnion
+import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent
+
+abstract class CommandEvent {
+
+    abstract val member: Member?
+
+    abstract val author: User
+
+    abstract val channel: MessageChannelUnion
+
+    abstract val message: Message?
+
+    abstract val isFromGuild: Boolean
+
+    abstract fun reply(text: String, ephemeral: Boolean = false)
+
+    abstract fun reply(embed: MessageEmbed, ephemeral: Boolean = false)
+
+    abstract fun userError(text: String)
+
+    abstract fun sendError(text: String)
+
+    fun replyWithConsumer(text: String, consumer: (MessageReceivedEvent) -> Unit) {
+        BotMessageHandler.log(text, consumer)
+        reply(text)
+    }
+
+    fun <T> doWhen(
+        isMessage: (MessageReceivedEvent) -> T?,
+        isSlashCommand: (SlashCommandInteractionEvent) -> T?
+    ): T? {
+        return when (this) {
+            is MessageEvent -> isMessage(this.event)
+            is SlashCommandEvent -> isSlashCommand(this.event)
+            else -> null
+        }
+    }
+}
+
+class MessageEvent(val event: MessageReceivedEvent) : CommandEvent() {
+    override val member: Member?
+        get() = event.member
+    override val author: User
+        get() = event.author
+    override val channel: MessageChannelUnion
+        get() = event.channel
+    override val message: Message
+        get() = event.message
+    override val isFromGuild: Boolean
+        get() = event.isFromGuild
+
+    override fun reply(text: String, ephemeral: Boolean) {
+        event.message.messageReply(text)
+    }
+
+    override fun reply(embed: MessageEmbed, ephemeral: Boolean) {
+        event.message.messageReply(embed)
+    }
+
+    override fun userError(text: String) {
+        event.message.messageReply("❌ $text")
+    }
+
+    override fun sendError(text: String) {
+        event.message.messageReply("❌ An error occurred: $text")
+    }
+}
+
+class SlashCommandEvent(val event: SlashCommandInteractionEvent) : CommandEvent() {
+    override val member: Member?
+        get() = event.member
+    override val author: User
+        get() = event.user
+    override val channel: MessageChannelUnion
+        get() = event.channel
+    override val message: Message?
+        get() = null
+    override val isFromGuild: Boolean
+        get() = event.isFromGuild
+
+    fun reply(text: String) {
+        reply(text, false)
+    }
+
+    fun reply(embed: MessageEmbed) {
+        reply(embed, false)
+    }
+
+    override fun reply(text: String, ephemeral: Boolean) {
+        event.reply(text).setEphemeral(ephemeral).queue()
+    }
+
+    override fun reply(embed: MessageEmbed, ephemeral: Boolean) {
+        event.replyEmbeds(embed).setEphemeral(ephemeral).queue()
+    }
+
+    override fun userError(text: String) {
+        reply("❌ $text", ephemeral = true)
+    }
+
+    override fun sendError(text: String) {
+        reply("❌ An error occurred: $text", ephemeral = true)
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/HelpCommand.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/HelpCommand.kt
index 241196a..bd49fb4 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/HelpCommand.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/HelpCommand.kt
@@ -1,18 +1,15 @@
 package at.hannibal2.skyhanni.discord.command
 
 import at.hannibal2.skyhanni.discord.BOT
+import at.hannibal2.skyhanni.discord.PLEADING_FACE
 import at.hannibal2.skyhanni.discord.CommandListener
 import at.hannibal2.skyhanni.discord.Option
-import at.hannibal2.skyhanni.discord.PLEADING_FACE
 import at.hannibal2.skyhanni.discord.Utils.hasAdminPermissions
 import at.hannibal2.skyhanni.discord.Utils.inBotCommandChannel
 import at.hannibal2.skyhanni.discord.Utils.messageDelete
-import at.hannibal2.skyhanni.discord.Utils.reply
-import at.hannibal2.skyhanni.discord.Utils.replyWithConsumer
 import at.hannibal2.skyhanni.discord.Utils.runDelayed
 import net.dv8tion.jda.api.EmbedBuilder
 import net.dv8tion.jda.api.entities.MessageEmbed
-import net.dv8tion.jda.api.events.message.MessageReceivedEvent
 import java.awt.Color
 import kotlin.time.Duration.Companion.seconds
 
@@ -20,15 +17,20 @@ object HelpCommand : BaseCommand() {
     override val name: String = "help"
     override val description: String = "Get help for all OR one specific command."
     override val options: List<Option> =
-        listOf(Option("command", "Command you want to get help for.", required = false))
+        listOf(Option("command", "Command you want to get help for.", required = false, autoComplete = true))
 
     override val userCommand: Boolean = true
 
-    override fun MessageReceivedEvent.execute(args: List<String>) {
+    override fun CommandEvent.execute(args: List<String>) {
         if (args.size > 1) return reply("Usage: !help <command>")
 
-        if (args.size == 1) {
-            sendUsageReply(args.first().lowercase())
+        val command = doWhen(
+            isMessage = { if (args.isEmpty()) null else args.first().lowercase() },
+            isSlashCommand = { it.getOption("command")?.asString }
+        )
+
+        if (command != null) {
+            sendUsageReply(command)
         } else {
             val commands = if (hasAdminPermissions() && inBotCommandChannel()) {
                 CommandListener.commands
@@ -41,17 +43,18 @@ object HelpCommand : BaseCommand() {
             if (hasAdminPermissions() && !inBotCommandChannel()) {
                 val id = BOT.config.botCommandChannelId
                 val botCommandChannel = "https://discord.com/channels/$id/$id"
-                replyWithConsumer("You wanna see the cool admin only commands? visit $botCommandChannel") { consumer ->
+
+                replyWithConsumer("You wanna see the cool admin only commands? visit $botCommandChannel") {
                     runDelayed(3.seconds) {
-                        consumer.message.messageDelete()
+                        val message = message ?: return@runDelayed
+                        message.messageDelete()
                     }
                 }
             }
         }
     }
 
-
-    fun MessageReceivedEvent.sendUsageReply(commandName: String) {
+    fun CommandEvent.sendUsageReply(commandName: String) {
         val command = CommandListener.getCommand(commandName) ?: run {
             reply("Unknown command `!$commandName` $PLEADING_FACE")
             return
@@ -62,18 +65,17 @@ object HelpCommand : BaseCommand() {
             return
         }
 
-        this.reply(command.createHelpEmbed(commandName))
+        reply(command.createHelpEmbed())
     }
 
-
-    private fun BaseCommand.createHelpEmbed(commandName: String): MessageEmbed {
+    private fun BaseCommand.createHelpEmbed(): MessageEmbed {
         val em = EmbedBuilder()
 
-        em.setTitle("Usage: /$commandName <" + this.options.joinToString("> <") { it.name } + ">")
-        em.setDescription("📋 **${this.description}**")
+        em.setTitle("Usage: /$name " + options.joinToString("> <", prefix = "<", postfix = ">") { it.name })
+        em.setDescription("📋 **${description}**")
         em.setColor(Color.GREEN)
 
-        for (option in this.options) {
+        for (option in options) {
             em.addField(option.name, option.description, true)
             em.addField("Required", if (option.required) "✅" else "❌", true)
             em.addBlankField(true)
diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/PullRequestCommand.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/PullRequestCommand.kt
index 17dbd23..7664e77 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/PullRequestCommand.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/PullRequestCommand.kt
@@ -14,17 +14,13 @@ import at.hannibal2.skyhanni.discord.Utils.format
 import at.hannibal2.skyhanni.discord.Utils.linkTo
 import at.hannibal2.skyhanni.discord.Utils.logAction
 import at.hannibal2.skyhanni.discord.Utils.messageDelete
-import at.hannibal2.skyhanni.discord.Utils.reply
-import at.hannibal2.skyhanni.discord.Utils.replyWithConsumer
 import at.hannibal2.skyhanni.discord.Utils.runDelayed
 import at.hannibal2.skyhanni.discord.Utils.timeExecution
 import at.hannibal2.skyhanni.discord.Utils.uploadFile
-import at.hannibal2.skyhanni.discord.Utils.userError
 import at.hannibal2.skyhanni.discord.github.GitHubClient
 import at.hannibal2.skyhanni.discord.json.discord.Conclusion
 import at.hannibal2.skyhanni.discord.json.discord.PullRequestJson
 import at.hannibal2.skyhanni.discord.json.discord.RunStatus
-import net.dv8tion.jda.api.events.message.MessageReceivedEvent
 import java.awt.Color
 import java.io.File
 import java.time.Instant
@@ -52,21 +48,33 @@ object PullRequestCommand : BaseCommand() {
         Regex("https://github\\.com/[\\w.]+/[\\w.]+/actions/runs/(?<RunId>\\d+)/job/(?<JobId>\\d+)")
     private val pullRequestPattern = "$BASE/pull/(?<pr>\\d+)".toPattern()
 
-    override fun MessageReceivedEvent.execute(args: List<String>) {
-        if (args.size != 1) return wrongUsage("<number>")
-        val first = args.first()
-        val prNumber = first.toLongOrNull() ?: run {
-            userError("Unknown number $PLEADING_FACE ($first})")
-            return
+    override fun CommandEvent.execute(args: List<String>) {
+        if (args.isNotEmpty() && args.size != 1) {
+            return wrongUsage("<number>")
         }
+
+        val prNumber = doWhen(
+            isMessage = {
+                val first = args.first()
+                first.toLongOrNull() ?: run {
+                    userError("Unknown number $PLEADING_FACE ($first})")
+                    null
+                }
+            },
+            isSlashCommand = {
+                it.getOption("number")?.asLong
+            }
+        ) ?: return
+
         if (prNumber < 1) {
             userError("PR number needs to be positive $PLEADING_FACE")
             return
         }
+
         loadPrInfos(prNumber)
     }
 
-    private fun MessageReceivedEvent.loadPrInfos(prNumber: Long) {
+    private fun CommandEvent.loadPrInfos(prNumber: Long) {
         logAction("loads pr infos for #$prNumber")
 
         val prLink = "$BASE/pull/$prNumber"
@@ -242,7 +250,7 @@ object PullRequestCommand : BaseCommand() {
         stringBuilder: StringBuilder,
         suffix: String = ""
     ): StringBuilder {
-        val labelsWithType = labels.intersect(labelTypes[labelType] ?: setOf())
+        val labelsWithType = labels.intersect((labelTypes[labelType] ?: setOf()).toSet())
         if (labelsWithType.isEmpty()) return stringBuilder.append(if (suffix.isNotEmpty()) "> $labelType: $suffix\n" else "")
         return stringBuilder.append("> $labelType: `${labelsWithType.joinToString("` `")}`$suffix\n")
     }
@@ -268,13 +276,13 @@ object PullRequestCommand : BaseCommand() {
     }
 
     @Suppress("unused") // TODO implement once we can upload the file
-    private fun MessageReceivedEvent.pullRequestArtifactCommand(args: List<String>) {
+    private fun CommandEvent.pullRequestArtifactCommand(args: List<String>) {
         if (args.size != 2) {
             reply("Usage: `!prupload <number>`")
             return
         }
         val prNumber = args[1].toLongOrNull() ?: run {
-            reply("unknwon number $PLEADING_FACE (${args[1]})")
+            reply("unknown number $PLEADING_FACE (${args[1]})")
             return
         }
 
@@ -304,7 +312,7 @@ object PullRequestCommand : BaseCommand() {
         val (_, downloadTime) = timeExecution {
             github.downloadArtifact(artifactId, fileRaw)
         }
-        reply("artifact downnloaded in ${downloadTime.format()}")
+        reply("artifact downloaded in ${downloadTime.format()}")
 
         Utils.unzipFile(fileRaw, fileUnzipped)
         fileRaw.delete()
@@ -327,16 +335,16 @@ object PullRequestCommand : BaseCommand() {
         return directory.walkTopDown().firstOrNull { it.isFile && it.name.startsWith("SkyHanni-") }
     }
 
-    fun isPullRequest(event: MessageReceivedEvent, message: String): Boolean {
+    fun MessageEvent.isPullRequest(message: String): Boolean {
         val matcher = pullRequestPattern.matcher(message)
         if (!matcher.matches()) return false
         val pr = matcher.group("pr")?.toLongOrNull() ?: return false
-        event.replyWithConsumer("Next time just type `!pr $pr` $PLEADING_FACE") { consumer ->
+        replyWithConsumer("Next time just type `!pr $pr` $PLEADING_FACE") { consumer ->
             runDelayed(10.seconds) {
                 consumer.message.messageDelete()
             }
         }
-        event.loadPrInfos(pr)
+        loadPrInfos(pr)
         return true
     }
 
diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/ServerCommands.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/ServerCommands.kt
index 95830e5..89df135 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/ServerCommands.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/ServerCommands.kt
@@ -4,15 +4,13 @@ import at.hannibal2.skyhanni.discord.BOT
 import at.hannibal2.skyhanni.discord.Option
 import at.hannibal2.skyhanni.discord.Utils
 import at.hannibal2.skyhanni.discord.Utils.logAction
-import at.hannibal2.skyhanni.discord.Utils.reply
 import at.hannibal2.skyhanni.discord.Utils.sendMessageToBotChannel
-import at.hannibal2.skyhanni.discord.Utils.userError
 import at.hannibal2.skyhanni.discord.command.ServerCommands.loadServers
 import at.hannibal2.skyhanni.discord.github.GitHubClient
 import com.google.gson.Gson
 import com.google.gson.reflect.TypeToken
 import net.dv8tion.jda.api.entities.Invite
-import net.dv8tion.jda.api.events.message.MessageReceivedEvent
+import net.dv8tion.jda.api.interactions.commands.OptionType
 import java.util.concurrent.CountDownLatch
 import kotlin.time.Duration.Companion.milliseconds
 
@@ -198,17 +196,28 @@ object ServerCommands {
 
     private fun getServerByInviteUrl(url: String): Server? = servers.firstOrNull { it.invite == url }
 
-    fun isKnownServerUrl(event: MessageReceivedEvent, message: String): Boolean {
+    fun MessageEvent.isKnownServerUrl(message: String): Boolean {
         val server = getServerByInviteUrl(message) ?: run {
             if (isDiscordInvite(message)) {
-                event.logAction("sends unknown discord invite '$message'")
+                logAction("sends unknown discord invite '$message'")
             }
             return false
         }
 
-        event.reply(server.print(tutorial = true))
+        reply(server.print(tutorial = true))
         return true
     }
+
+    fun listServers(): String {
+        if (servers.isEmpty()) return "No servers found."
+
+        val list = servers.joinToString("\n") { server ->
+            val aliases = server.aliases
+            if (aliases.isNotEmpty()) "${server.keyword} [${aliases.joinToString(", ")}]"
+            else server.keyword
+        }
+        return "Server list:\n$list"
+    }
 }
 
 @Suppress("unused")
@@ -216,15 +225,30 @@ class ServerCommand : BaseCommand() {
     override val name: String = "server"
     override val description: String = "Displays information about a server from our 'useful server list'."
     override val options: List<Option> = listOf(
-        Option("keyword", "Keyword of the server you want to display."),
-        Option("debug", "Display even more useful information (-d to use).", required = false)
+        Option("keyword", "Keyword of the server you want to display.", autoComplete = true),
+        Option(
+            "debug",
+            "Display even more useful information (-d to use).",
+            required = false,
+            type = OptionType.BOOLEAN
+        )
     )
     override val userCommand: Boolean = true
 
-    override fun MessageReceivedEvent.execute(args: List<String>) {
-        if (args.size !in 1..2) return wrongUsage("<keyword>")
-        val keyword = args.first()
-        val debug = args.getOrNull(1) == "-d"
+    override fun CommandEvent.execute(args: List<String>) {
+        if (args.isNotEmpty() && args.size !in 1..2) {
+            wrongUsage("<keyword>")
+            return
+        }
+        val keyword = doWhen(
+            isMessage = { args.first() }, isSlashCommand = { it.getOption("keyword")?.asString }
+        ) ?: return
+
+        val debug = doWhen(
+            isMessage = { args.getOrNull(1) == "-d" },
+            isSlashCommand = { it.getOption("debug")?.asBoolean }
+        ) ?: false
+
         val server = ServerCommands.getServer(keyword.lowercase())
         if (server == null) {
             userError("Server with keyword '$keyword' not found.")
@@ -233,7 +257,6 @@ class ServerCommand : BaseCommand() {
         if (debug) reply(server.printDebug())
         else reply(server.print())
     }
-
 }
 
 @Suppress("unused")
@@ -246,17 +269,25 @@ class ServerUpdate : BaseCommand() {
         loadServers(startup = true)
     }
 
-    override fun MessageReceivedEvent.execute(args: List<String>) {
-        reply("updating server list ...")
+    override fun CommandEvent.execute(args: List<String>) {
+        doWhen(
+            isMessage = { reply("updating server list ...") },
+            isSlashCommand = { it.deferReply(true).queue() }
+        )
+
         loadServers(startup = false) { source, removed ->
             val removedSuffix = if (removed > 0) {
                 " (removed $removed servers)"
             } else ""
-            reply("Updated server list from $source.$removedSuffix")
+
+            doWhen(
+                isMessage = { reply("Updated server list from $source.$removedSuffix") },
+                isSlashCommand = { it.hook.sendMessage("Updated server list from $source.$removedSuffix").queue() }
+            )
+
             logAction("updated server list from github")
         }
     }
-
 }
 
 @Suppress("unused")
@@ -265,16 +296,7 @@ class ServerList : BaseCommand() {
     override val description: String = "Displays all servers in the database."
     override val aliases: List<String> = listOf("servers")
 
-    override fun MessageReceivedEvent.execute(args: List<String>) {
-        if (ServerCommands.servers.isEmpty()) {
-            reply("No servers found.")
-            return
-        }
-        val list = ServerCommands.servers.joinToString("\n") { server ->
-            val aliases = server.aliases
-            if (aliases.isNotEmpty()) "${server.keyword} [${aliases.joinToString(", ")}]"
-            else server.keyword
-        }
-        reply("Server list:\n$list")
+    override fun CommandEvent.execute(args: List<String>) {
+        reply(ServerCommands.listServers(), ephemeral = true)
     }
 }
\ No newline at end of file
diff --git a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/TagCommands.kt b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/TagCommands.kt
index ddeb25a..209be73 100644
--- a/src/main/kotlin/at/hannibal2/skyhanni/discord/command/TagCommands.kt
+++ b/src/main/kotlin/at/hannibal2/skyhanni/discord/command/TagCommands.kt
@@ -6,20 +6,16 @@ import at.hannibal2.skyhanni.discord.Option
 import at.hannibal2.skyhanni.discord.PING_HANNIBAL
 import at.hannibal2.skyhanni.discord.PLEADING_FACE
 import at.hannibal2.skyhanni.discord.Tag
-import at.hannibal2.skyhanni.discord.Utils
 import at.hannibal2.skyhanni.discord.Utils.logAction
 import at.hannibal2.skyhanni.discord.Utils.messageDelete
 import at.hannibal2.skyhanni.discord.Utils.messageDeleteAndThen
-import at.hannibal2.skyhanni.discord.Utils.reply
 import at.hannibal2.skyhanni.discord.Utils.replyWithConsumer
-import at.hannibal2.skyhanni.discord.Utils.sendError
+import at.hannibal2.skyhanni.discord.Utils.runDelayed
 import at.hannibal2.skyhanni.discord.Utils.sendMessageWithConsumer
-import at.hannibal2.skyhanni.discord.Utils.userError
 import at.hannibal2.skyhanni.discord.command.TagCommands.addLastMessage
 import at.hannibal2.skyhanni.discord.command.TagCommands.lastMessages
 import at.hannibal2.skyhanni.discord.command.TagCommands.lastTouchedTag
 import net.dv8tion.jda.api.entities.Message
-import net.dv8tion.jda.api.events.message.MessageReceivedEvent
 import kotlin.time.Duration.Companion.seconds
 
 object TagCommands {
@@ -32,7 +28,7 @@ object TagCommands {
         lastMessages.getOrPut(author) { mutableListOf() }.add(message)
     }
 
-    fun handleTag(event: MessageReceivedEvent): Boolean {
+    fun MessageEvent.handleTag(): Boolean {
         val message = event.message
         var keyword = message.contentRaw.substring(1).trimStart()
         var deleting = false
@@ -46,34 +42,34 @@ object TagCommands {
             info = true
         }
         val response = Database.getResponse(keyword, increment = !info) ?: run {
-            event.reply("Unknown command $PLEADING_FACE Type `!help` for help.")
+            reply("Unknown command $PLEADING_FACE Type `!help` for help.")
             return false
         }
 
         if (info) {
             val count = Database.getTagCount(keyword)
-            event.reply("Tag `!$keyword` got used $count times in total.")
+            reply("Tag `!$keyword` got used $count times in total.")
             return true
         }
 
         val author = message.author.id
         lastTouchedTag[author] = keyword
         message.referencedMessage?.let {
-            event.logAction("used tag '$keyword' (with reply)")
+            logAction("used keyword '$keyword' (with reply)")
             message.messageDelete()
             it.replyWithConsumer(response) { consumer ->
                 addLastMessage(author, consumer.message)
             }
         } ?: run {
             if (deleting) {
-                event.logAction("used tag '$keyword' (with delete)")
+                logAction("used keyword '$keyword' (with delete)")
                 message.messageDeleteAndThen {
                     event.channel.sendMessageWithConsumer(response) { consumer ->
                         addLastMessage(author, consumer.message)
                     }
                 }
             } else {
-                event.logAction("used tag '$keyword'")
+                logAction("used keyword '$keyword'")
                 addLastMessage(author, message)
                 message.replyWithConsumer(response) { consumer ->
                     addLastMessage(author, consumer.message)
@@ -91,10 +87,10 @@ class TagList : BaseCommand() {
     override val aliases = listOf("tags")
     override val userCommand: Boolean = true
 
-    override fun MessageReceivedEvent.execute(args: List<String>) {
+    override fun CommandEvent.execute(args: List<String>) {
         val list = Database.listTags()
         if (list.isEmpty()) {
-            reply("No tags set.")
+            reply("No tags set.", ephemeral = true)
             return
         }
 
@@ -114,14 +110,25 @@ class TagEdit : BaseCommand() {
     override val name = "tagedit"
     override val description = "Edits a tag in the database."
     override val options: List<Option> = listOf(
-        Option("tag", "The tag you want to edit."), Option("response", "Response you want the tag to have.")
+        Option("keyword", "The tag you want to edit.", autoComplete = true),
+        Option("response", "Response you want the tag to have.")
     )
     override val aliases = listOf("tagchange")
 
-    override fun MessageReceivedEvent.execute(args: List<String>) {
-        if (args.size < 2) return wrongUsage("<tag> <response>")
-        val keyword = args.first()
-        val response = args.drop(1).joinToString(" ")
+    override fun CommandEvent.execute(args: List<String>) {
+        if (args.isNotEmpty() && args.size < 2) {
+            wrongUsage("<keyword> <response>")
+            return
+        }
+        val keyword = doWhen(
+            isMessage = { args.first() }, isSlashCommand = { it.getOption("keyword")?.asString }
+        ) ?: return
+
+        val response = doWhen(
+            isMessage = { args.drop(1).joinToString(" ") },
+            isSlashCommand = { it.getOption("response")?.asString }
+        ) ?: return
+
         val oldResponse = Database.getResponse(keyword)
         val count = Database.getTagCount(keyword) ?: 0
         if (oldResponse == null) {
@@ -129,17 +136,18 @@ class TagEdit : BaseCommand() {
             return
         }
         if (Database.addTag(keyword, response, count)) {
-            message.messageDeleteAndThen {
-                val id = author.id
-                reply("✅ Tag '$keyword' edited by <@$id>:")
-                reply(response)
-                logAction("edited tags '$keyword'")
-                logAction("old response: '$oldResponse'", raw = true)
-                logAction("new response: '$response'", raw = true)
-                lastTouchedTag[id] = keyword
-            }
+            doWhen(isMessage = { it.message.messageDelete() }, isSlashCommand = {})
+
+            val id = author.id
+
+            reply("✅ Tag '$keyword' edited by <@$id>:")
+            doWhen(isMessage = { reply(response) }, isSlashCommand = { it.channel.sendMessage(response).queue() })
+            logAction("edited tags '$keyword'")
+            logAction("old response: '$oldResponse'", raw = true)
+            logAction("new response: '$response'", raw = true)
+            lastTouchedTag[id] = keyword
         } else {
-            reply("❌ Failed to edit tags.")
+            sendError("❌ Failed to edit tags.")
         }
     }
 }
@@ -149,13 +157,16 @@ class TagEditLast : BaseCommand() {
     override val name = "tageditlast"
     override val description = "Show info on how to edit the last tag used."
 
-    override fun MessageReceivedEvent.execute(args: List<String>) {
+    override fun CommandEvent.execute(args: List<String>) {
         val id = author.id
+
         val lastTag = lastTouchedTag[id] ?: run {
             return userError("No last tag found $PLEADING_FACE")
         }
         val response = Database.getResponse(lastTag) ?: run {
-            return sendError("Last tag `$lastTag` got deleted, this should not happen, therefore we ping $PING_HANNIBAL")
+            return sendError(
+                "Last tag `$lastTag` got deleted, this should not happen, therefore we ping $PING_HANNIBAL"
+            )
         }
         reply("```!tagedit $lastTag $response```")
     }
@@ -170,31 +181,36 @@ class TagAdd : BaseCommand() {
     )
     override val aliases = listOf("tagcreate")
 
-    override fun MessageReceivedEvent.execute(args: List<String>) {
-        if (args.size < 2) return wrongUsage("<keyword> <response>")
-
-        val keyword = args.first()
-        if (CommandListener.existsCommand(keyword)) {
-            reply("❌ Can not create tag `!$keyword`. There is already a command with that name")
+    override fun CommandEvent.execute(args: List<String>) {
+        if (args.isNotEmpty() && args.size < 2) {
+            wrongUsage("<keyword> <response>")
             return
         }
-        val response = args.drop(1).joinToString(" ")
 
-        if (Database.containsKeyword(keyword)) {
-            reply("❌ Tag already exists. Use `!tagedit` instead.")
-            return
-        }
+        val keyword = doWhen(isMessage = { args.first() }, isSlashCommand = {
+            it.getOption("keyword")?.asString
+        }) ?: return
+
+        if (CommandListener.existsCommand(keyword))
+            return userError("Can not create tag `!$keyword`. There is already a command with that name")
+        if (Database.containsKeyword(keyword))
+            return userError("Keyword already exists. Use `!tagedit` instead.")
+
+        val response = doWhen(
+            isMessage = { args.drop(1).joinToString(" ") },
+            isSlashCommand = { it.getOption("response")?.asString }
+        ) ?: return
+
         if (Database.addTag(keyword, response)) {
-            message.messageDeleteAndThen {
-                val id = author.id
-                reply("✅ Tag '$keyword' added by <@$id>:")
-                reply(response)
-                logAction("added tag '$keyword'")
-                logAction("response: '$response'", raw = true)
-                lastTouchedTag[id] = keyword
-            }
+            doWhen(isMessage = { it.message.messageDelete() }, isSlashCommand = {})
+
+            reply("✅ Keyword '$keyword' added by ${author.asMention}:")
+            doWhen(isMessage = { reply(response) }, isSlashCommand = { it.channel.sendMessage(response).queue() })
+            logAction("added keyword '$keyword'")
+            logAction("response: '$response'", raw = true)
+            lastTouchedTag[author.id] = keyword
         } else {
-            reply("❌ Failed to add keyword.")
+            sendError("❌ Failed to add keyword.")
         }
     }
 }
@@ -204,15 +220,20 @@ class TagDelete : BaseCommand() {
     override val name: String = "tagdelete"
     override val description: String = "Deletes a tag from the database."
     override val options: List<Option> = listOf(
-        Option("keyword", "Keyword of the tag you want to delete.")
+        Option("keyword", "Keyword of the tag you want to delete.", autoComplete = true)
     )
     override val aliases: List<String> = listOf("tagremove")
 
-    override fun MessageReceivedEvent.execute(args: List<String>) {
-        if (args.size != 1) return wrongUsage("<keyword>")
-
-        val keyword = args.first()
+    override fun CommandEvent.execute(args: List<String>) {
+        if (this is MessageEvent && args.size != 1) {
+            wrongUsage("<keyword>")
+            return
+        }
+        val keyword = doWhen(
+            isMessage = { args.first() }, isSlashCommand = { it.getOption("keyword")?.asString }
+        ) ?: return
         val oldResponse = Database.getResponse(keyword)
+
         if (Database.deleteTag(keyword)) {
             reply("🗑️ Tag '$keyword' deleted!")
             logAction("deleted tag '$keyword'")
@@ -220,7 +241,7 @@ class TagDelete : BaseCommand() {
             val id = author.id
             lastTouchedTag.remove(id)
         } else {
-            reply("❌ Tag '$keyword' not found.")
+            userError("Tag '$keyword' not found.")
         }
     }
 }
@@ -232,32 +253,39 @@ object TagUndo : BaseCommand() {
     override val userCommand: Boolean = true
     override val aliases: List<String> = listOf("undo")
 
-    override fun MessageReceivedEvent.execute(args: List<String>) {
-        val author = author.id
-        val message = message
-        if (undo(author)) {
+    override fun CommandEvent.execute(args: List<String>) {
+        if (undo(author.id)) {
             logAction("undid last send tag.")
-            lastTouchedTag.remove(author)
-            message.messageDelete()
+            lastTouchedTag.remove(author.id)
+            doWhen(
+                isMessage = { it.message.messageDelete() },
+                isSlashCommand = { reply("Undid last sent tag.", ephemeral = true) }
+            )
         } else {
-            addLastMessage(author, message)
-            message.replyWithConsumer("No last tag to undo found!") { consumer ->
-                addLastMessage(author, consumer.message)
-            }
-            Utils.runDelayed(2.seconds) {
-                undo(author)
-            }
+            doWhen(
+                isMessage = {
+                    addLastMessage(author.id, it.message)
+                    it.message.replyWithConsumer("No last tag to undo found!") { consumer ->
+                        addLastMessage(author.id, consumer.message)
+                    }
+                    runDelayed(2.seconds) {
+                        undo(author.id)
+                    }
+                },
+                isSlashCommand = {
+                    sendError("No last tag to undo found!")
+                }
+            )
         }
     }
+}
 
-    private fun undo(author: String): Boolean {
-        return lastMessages[author]?.let {
-            for (message in it) {
-                message.messageDelete()
-            }
-            lastMessages.remove(author)
-            true
-        } ?: false
-    }
-
+fun undo(author: String): Boolean {
+    return lastMessages[author]?.let {
+        for (message in it) {
+            message.messageDelete()
+        }
+        lastMessages.remove(author)
+        true
+    } ?: false
 }
\ No newline at end of file