diff --git a/application/build.gradle b/application/build.gradle
index 23075c96f7..1d2426892e 100644
--- a/application/build.gradle
+++ b/application/build.gradle
@@ -61,10 +61,10 @@ dependencies {
     implementation 'org.scilab.forge:jlatexmath-font-greek:1.0.7'
     implementation 'org.scilab.forge:jlatexmath-font-cyrillic:1.0.7'
 
-    implementation 'com.fasterxml.jackson.dataformat:jackson-dataformat-csv:2.14.0'
-    implementation 'com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.14.0'
-    implementation 'com.fasterxml.jackson.dataformat:jackson-dataformat-xml:2.14.0'
-    implementation 'com.fasterxml.jackson.core:jackson-databind:2.14.0'
+    implementation "com.fasterxml.jackson.dataformat:jackson-dataformat-csv:$jacksonVersion"
+    implementation "com.fasterxml.jackson.datatype:jackson-datatype-jsr310:$jacksonVersion"
+    implementation "com.fasterxml.jackson.dataformat:jackson-dataformat-xml:$jacksonVersion"
+    implementation "com.fasterxml.jackson.core:jackson-databind:$jacksonVersion"
 
 	implementation 'com.github.freva:ascii-table:1.8.0'
 
diff --git a/application/src/main/java/org/togetherjava/tjbot/commands/Features.java b/application/src/main/java/org/togetherjava/tjbot/commands/Features.java
index 853b5be019..76cdd928b7 100644
--- a/application/src/main/java/org/togetherjava/tjbot/commands/Features.java
+++ b/application/src/main/java/org/togetherjava/tjbot/commands/Features.java
@@ -6,13 +6,16 @@
 import org.togetherjava.tjbot.commands.basic.RoleSelectCommand;
 import org.togetherjava.tjbot.commands.basic.SuggestionsUpDownVoter;
 import org.togetherjava.tjbot.commands.basic.VcActivityCommand;
+import org.togetherjava.tjbot.commands.code.CodeMessageAutoDetection;
 import org.togetherjava.tjbot.commands.code.CodeMessageHandler;
+import org.togetherjava.tjbot.commands.code.CodeMessageManualDetection;
 import org.togetherjava.tjbot.commands.filesharing.FileSharingMessageListener;
 import org.togetherjava.tjbot.commands.help.*;
 import org.togetherjava.tjbot.commands.mathcommands.TeXCommand;
 import org.togetherjava.tjbot.commands.mathcommands.wolframalpha.WolframAlphaCommand;
 import org.togetherjava.tjbot.commands.mediaonly.MediaOnlyChannelListener;
 import org.togetherjava.tjbot.commands.moderation.*;
+import org.togetherjava.tjbot.commands.moderation.ReportCommand;
 import org.togetherjava.tjbot.commands.moderation.attachment.BlacklistedAttachmentListener;
 import org.togetherjava.tjbot.commands.moderation.modmail.ModMailCommand;
 import org.togetherjava.tjbot.commands.moderation.scam.ScamBlocker;
@@ -68,6 +71,7 @@ public static Collection<Feature> createFeatures(JDA jda, Database database, Con
         ModAuditLogWriter modAuditLogWriter = new ModAuditLogWriter(config);
         ScamHistoryStore scamHistoryStore = new ScamHistoryStore(database);
         HelpSystemHelper helpSystemHelper = new HelpSystemHelper(jda, config, database);
+        CodeMessageHandler codeMessageHandler = new CodeMessageHandler();
 
         // NOTE The system can add special system relevant commands also by itself,
         // hence this list may not necessarily represent the full list of all commands actually
@@ -95,7 +99,9 @@ public static Collection<Feature> createFeatures(JDA jda, Database database, Con
         features.add(new MediaOnlyChannelListener(config));
         features.add(new FileSharingMessageListener(config));
         features.add(new BlacklistedAttachmentListener(config, modAuditLogWriter));
-        features.add(new CodeMessageHandler());
+        features.add(codeMessageHandler);
+        features.add(new CodeMessageAutoDetection(config, codeMessageHandler));
+        features.add(new CodeMessageManualDetection(codeMessageHandler));
 
         // Event receivers
         features.add(new RejoinModerationRoleListener(actionsStore, config));
@@ -132,6 +138,7 @@ public static Collection<Feature> createFeatures(JDA jda, Database database, Con
         features.add(new AskCommand(config, helpSystemHelper, database));
         features.add(new ModMailCommand(jda, config));
         features.add(new HelpThreadCommand(config, helpSystemHelper));
+        features.add(new ReportCommand(config));
 
         // Mixtures
         features.add(new HelpThreadOverviewUpdater(config, helpSystemHelper));
diff --git a/application/src/main/java/org/togetherjava/tjbot/commands/code/CodeMessageAutoDetection.java b/application/src/main/java/org/togetherjava/tjbot/commands/code/CodeMessageAutoDetection.java
new file mode 100644
index 0000000000..d8adecc0d1
--- /dev/null
+++ b/application/src/main/java/org/togetherjava/tjbot/commands/code/CodeMessageAutoDetection.java
@@ -0,0 +1,79 @@
+package org.togetherjava.tjbot.commands.code;
+
+import net.dv8tion.jda.api.entities.Message;
+import net.dv8tion.jda.api.entities.channel.ChannelType;
+import net.dv8tion.jda.api.entities.channel.concrete.ThreadChannel;
+import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
+
+import org.togetherjava.tjbot.commands.MessageReceiverAdapter;
+import org.togetherjava.tjbot.commands.utils.CodeFence;
+import org.togetherjava.tjbot.commands.utils.MessageUtils;
+import org.togetherjava.tjbot.config.Config;
+
+import java.util.Optional;
+import java.util.function.Predicate;
+import java.util.regex.Pattern;
+
+/**
+ * Automatically detects messages that contain code and registers them at {@link CodeMessageHandler}
+ * for further processing.
+ */
+public final class CodeMessageAutoDetection extends MessageReceiverAdapter {
+    private static final long MINIMUM_LINES_OF_CODE = 3;
+
+    private final CodeMessageHandler codeMessageHandler;
+
+    private final Predicate<String> isStagingChannelName;
+    private final Predicate<String> isOverviewChannelName;
+
+    /**
+     * Creates a new instance.
+     * 
+     * @param config to figure out whether a message is from a help thread
+     * @param codeMessageHandler to register detected code messages at for further handling
+     */
+    public CodeMessageAutoDetection(Config config, CodeMessageHandler codeMessageHandler) {
+        super(Pattern.compile(".*"));
+
+        this.codeMessageHandler = codeMessageHandler;
+
+        isStagingChannelName = Pattern.compile(config.getHelpSystem().getStagingChannelPattern())
+            .asMatchPredicate();
+        isOverviewChannelName = Pattern.compile(config.getHelpSystem().getOverviewChannelPattern())
+            .asMatchPredicate();
+    }
+
+    @Override
+    public void onMessageReceived(MessageReceivedEvent event) {
+        if (event.isWebhookMessage() || event.getAuthor().isBot() || !isHelpThread(event)) {
+            return;
+        }
+
+        Message originalMessage = event.getMessage();
+
+        Optional<CodeFence> maybeCode = MessageUtils.extractCode(originalMessage.getContentRaw());
+        if (maybeCode.isEmpty()) {
+            // There is no code in the message, ignore it
+            return;
+        }
+
+        long amountOfCodeLines =
+                maybeCode.orElseThrow().code().lines().limit(MINIMUM_LINES_OF_CODE).count();
+        if (amountOfCodeLines < MINIMUM_LINES_OF_CODE) {
+            return;
+        }
+
+        codeMessageHandler.addAndHandleCodeMessage(originalMessage);
+    }
+
+    private boolean isHelpThread(MessageReceivedEvent event) {
+        if (event.getChannelType() != ChannelType.GUILD_PUBLIC_THREAD) {
+            return false;
+        }
+
+        ThreadChannel thread = event.getChannel().asThreadChannel();
+        String rootChannelName = thread.getParentChannel().getName();
+        return isStagingChannelName.test(rootChannelName)
+                || isOverviewChannelName.test(rootChannelName);
+    }
+}
diff --git a/application/src/main/java/org/togetherjava/tjbot/commands/code/CodeMessageHandler.java b/application/src/main/java/org/togetherjava/tjbot/commands/code/CodeMessageHandler.java
index 9b087bf39a..a45a5c0f80 100644
--- a/application/src/main/java/org/togetherjava/tjbot/commands/code/CodeMessageHandler.java
+++ b/application/src/main/java/org/togetherjava/tjbot/commands/code/CodeMessageHandler.java
@@ -3,11 +3,11 @@
 import com.github.benmanes.caffeine.cache.Cache;
 import com.github.benmanes.caffeine.cache.Caffeine;
 import net.dv8tion.jda.api.entities.Message;
+import net.dv8tion.jda.api.entities.emoji.Emoji;
 import net.dv8tion.jda.api.events.interaction.ModalInteractionEvent;
 import net.dv8tion.jda.api.events.interaction.component.ButtonInteractionEvent;
 import net.dv8tion.jda.api.events.interaction.component.SelectMenuInteractionEvent;
 import net.dv8tion.jda.api.events.message.MessageDeleteEvent;
-import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
 import net.dv8tion.jda.api.events.message.MessageUpdateEvent;
 import net.dv8tion.jda.api.interactions.components.buttons.Button;
 import net.dv8tion.jda.api.utils.messages.MessageCreateBuilder;
@@ -34,10 +34,13 @@
 import java.util.function.Function;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 /**
- * Handler that detects code in messages and offers code actions to the user, such as formatting
- * their code.
+ * Handles code in registered messages and offers code actions to the user, such as formatting their
+ * code.
+ * <p>
+ * Messages can be registered by using {@link #addAndHandleCodeMessage(Message)}.
  * <p>
  * Code actions are automatically updated whenever the code in the original message is edited or
  * deleted.
@@ -45,6 +48,8 @@
 public final class CodeMessageHandler extends MessageReceiverAdapter implements UserInteractor {
     private static final Logger logger = LoggerFactory.getLogger(CodeMessageHandler.class);
 
+    private static final String DELETE_CUE = "delete";
+
     static final Color AMBIENT_COLOR = Color.decode("#FDFD96");
 
     private final ComponentIdInteractor componentIdInteractor;
@@ -101,23 +106,17 @@ public void acceptComponentIdGenerator(ComponentIdGenerator generator) {
         componentIdInteractor.acceptComponentIdGenerator(generator);
     }
 
-    @Override
-    public void onMessageReceived(MessageReceivedEvent event) {
-        if (event.isWebhookMessage() || event.getAuthor().isBot()) {
-            return;
-        }
-
-        Message originalMessage = event.getMessage();
-        String content = originalMessage.getContentRaw();
-
-        Optional<CodeFence> maybeCode = MessageUtils.extractCode(content);
-        if (maybeCode.isEmpty()) {
-            // There is no code in the message, ignore it
-            return;
-        }
-
+    /**
+     * Adds the given message to the code messages handled by this instance. Also sends the
+     * corresponding code-reply to the author.
+     *
+     * @param originalMessage the code message to add to this handler
+     */
+    public void addAndHandleCodeMessage(Message originalMessage) {
         // Suggest code actions and remember the message <-> reply
-        originalMessage.reply(createCodeReplyMessage(originalMessage.getIdLong()))
+        MessageCreateData codeReply = createCodeReplyMessage(originalMessage.getIdLong());
+
+        originalMessage.reply(codeReply)
             .onSuccess(replyMessage -> originalMessageToCodeReply.put(originalMessage.getIdLong(),
                     replyMessage.getIdLong()))
             .queue();
@@ -131,10 +130,21 @@ private MessageCreateData createCodeReplyMessage(long originalMessageId) {
 
     private List<Button> createButtons(long originalMessageId,
             @Nullable CodeAction currentlyActiveAction) {
-        return labelToCodeAction.values().stream().map(action -> {
+        Stream<Button> codeActionButtons = labelToCodeAction.values().stream().map(action -> {
             Button button = createButtonForAction(action, originalMessageId);
             return action == currentlyActiveAction ? button.asDisabled() : button;
-        }).toList();
+        });
+
+        Stream<Button> otherButtons = Stream.of(createDeleteButton(originalMessageId));
+
+        return Stream.concat(codeActionButtons, otherButtons).toList();
+    }
+
+    private Button createDeleteButton(long originalMessageId) {
+        String noCodeActionLabel = "";
+        return Button.danger(componentIdInteractor
+            .generateComponentId(Long.toString(originalMessageId), noCodeActionLabel, DELETE_CUE),
+                Emoji.fromUnicode("🗑"));
     }
 
     private Button createButtonForAction(CodeAction action, long originalMessageId) {
@@ -146,8 +156,13 @@ private Button createButtonForAction(CodeAction action, long originalMessageId)
     @Override
     public void onButtonClick(ButtonInteractionEvent event, List<String> args) {
         long originalMessageId = Long.parseLong(args.get(0));
-        CodeAction codeAction = getActionOfEvent(event);
+        // The third arg indicates a non-code-action button
+        if (args.size() >= 3 && DELETE_CUE.equals(args.get(2))) {
+            deleteCodeReply(event, originalMessageId);
+            return;
+        }
 
+        CodeAction codeAction = getActionOfEvent(event);
         event.deferEdit().queue();
 
         // User decided for an action, apply it to the code
@@ -166,23 +181,21 @@ public void onButtonClick(ButtonInteractionEvent event, List<String> args) {
                 // since we have the context here, we can restore that information
                 originalMessageToCodeReply.put(originalMessageId, event.getMessageIdLong());
 
-                Optional<CodeFence> maybeCode =
-                        MessageUtils.extractCode(originalMessage.get().getContentRaw());
-                if (maybeCode.isEmpty()) {
-                    return event.getHook()
-                        .sendMessage(
-                                "Sorry, I am unable to locate any code in the original message, was it removed?")
-                        .setEphemeral(true);
-                }
+                CodeFence code = extractCodeOrFallback(originalMessage.get().getContentRaw());
 
                 // Apply the selected action
                 return event.getHook()
-                    .editOriginalEmbeds(codeAction.apply(maybeCode.orElseThrow()))
+                    .editOriginalEmbeds(codeAction.apply(code))
                     .setActionRow(createButtons(originalMessageId, codeAction));
             })
             .queue();
     }
 
+    private void deleteCodeReply(ButtonInteractionEvent event, long originalMessageId) {
+        originalMessageToCodeReply.invalidate(originalMessageId);
+        event.getMessage().delete().queue();
+    }
+
     private CodeAction getActionOfEvent(ButtonInteractionEvent event) {
         return labelToCodeAction.get(event.getButton().getLabel());
     }
@@ -198,13 +211,7 @@ public void onMessageUpdated(MessageUpdateEvent event) {
         }
 
         // Edit the code reply as well by re-applying the current action
-        String content = event.getMessage().getContentRaw();
-
-        Optional<CodeFence> maybeCode = MessageUtils.extractCode(content);
-        if (maybeCode.isEmpty()) {
-            // The original message had code, but now the code was removed
-            return;
-        }
+        CodeFence code = extractCodeOrFallback(event.getMessage().getContentRaw());
 
         event.getChannel().retrieveMessageById(codeReplyMessageId).flatMap(codeReplyMessage -> {
             Optional<CodeAction> maybeCodeAction = getCurrentActionFromCodeReply(codeReplyMessage);
@@ -214,8 +221,7 @@ public void onMessageUpdated(MessageUpdateEvent event) {
             }
 
             // Re-apply the current action
-            return codeReplyMessage
-                .editMessageEmbeds(maybeCodeAction.orElseThrow().apply(maybeCode.orElseThrow()));
+            return codeReplyMessage.editMessageEmbeds(maybeCodeAction.orElseThrow().apply(code));
         }).queue(any -> {
         }, failure -> logger.warn(
                 "Attempted to update a code-reply-message ({}), but failed. The original code-message was {}",
@@ -243,11 +249,15 @@ public void onMessageDeleted(MessageDeleteEvent event) {
         }
 
         // Delete the code reply as well
-        originalMessageToCodeReply.invalidate(codeReplyMessageId);
+        originalMessageToCodeReply.invalidate(originalMessageId);
 
         event.getChannel().deleteMessageById(codeReplyMessageId).queue(any -> {
         }, failure -> logger.warn(
                 "Attempted to delete a code-reply-message ({}), but failed. The original code-message was {}",
                 codeReplyMessageId, originalMessageId, failure));
     }
+
+    private static CodeFence extractCodeOrFallback(String content) {
+        return MessageUtils.extractCode(content).orElseGet(() -> new CodeFence("java", content));
+    }
 }
diff --git a/application/src/main/java/org/togetherjava/tjbot/commands/code/CodeMessageManualDetection.java b/application/src/main/java/org/togetherjava/tjbot/commands/code/CodeMessageManualDetection.java
new file mode 100644
index 0000000000..bd1d770b42
--- /dev/null
+++ b/application/src/main/java/org/togetherjava/tjbot/commands/code/CodeMessageManualDetection.java
@@ -0,0 +1,37 @@
+package org.togetherjava.tjbot.commands.code;
+
+import net.dv8tion.jda.api.events.interaction.command.MessageContextInteractionEvent;
+import net.dv8tion.jda.api.interactions.commands.build.Commands;
+
+import org.togetherjava.tjbot.commands.BotCommandAdapter;
+import org.togetherjava.tjbot.commands.CommandVisibility;
+import org.togetherjava.tjbot.commands.MessageContextCommand;
+
+/**
+ * Context command to allow users to select messages that contain code. They are then registered at
+ * {@link CodeMessageHandler} for further processing.
+ */
+public final class CodeMessageManualDetection extends BotCommandAdapter
+        implements MessageContextCommand {
+    private final CodeMessageHandler codeMessageHandler;
+
+    /**
+     * Creates a new instance.
+     *
+     * @param codeMessageHandler to register selected code messages at for further handling
+     */
+    public CodeMessageManualDetection(CodeMessageHandler codeMessageHandler) {
+        super(Commands.message("code-actions"), CommandVisibility.GUILD);
+
+        this.codeMessageHandler = codeMessageHandler;
+    }
+
+    @Override
+    public void onMessageContext(MessageContextInteractionEvent event) {
+        event.reply("I registered the message as code-message, actions should appear now.")
+            .setEphemeral(true)
+            .queue();
+
+        codeMessageHandler.addAndHandleCodeMessage(event.getTarget());
+    }
+}
diff --git a/application/src/main/java/org/togetherjava/tjbot/commands/help/AutoPruneHelperRoutine.java b/application/src/main/java/org/togetherjava/tjbot/commands/help/AutoPruneHelperRoutine.java
index 926595c270..d3f790745e 100644
--- a/application/src/main/java/org/togetherjava/tjbot/commands/help/AutoPruneHelperRoutine.java
+++ b/application/src/main/java/org/togetherjava/tjbot/commands/help/AutoPruneHelperRoutine.java
@@ -33,9 +33,9 @@ public final class AutoPruneHelperRoutine implements Routine {
 
     private static final int ROLE_FULL_LIMIT = 100;
     private static final int ROLE_FULL_THRESHOLD = 95;
-    private static final int PRUNE_MEMBER_AMOUNT = 10;
+    private static final int PRUNE_MEMBER_AMOUNT = 7;
     private static final Period INACTIVE_AFTER = Period.ofDays(90);
-    private static final int RECENTLY_JOINED_DAYS = 7;
+    private static final int RECENTLY_JOINED_DAYS = 4;
 
     private final HelpSystemHelper helper;
     private final ModAuditLogWriter modAuditLogWriter;
diff --git a/application/src/main/java/org/togetherjava/tjbot/commands/moderation/ReportCommand.java b/application/src/main/java/org/togetherjava/tjbot/commands/moderation/ReportCommand.java
new file mode 100644
index 0000000000..005e779587
--- /dev/null
+++ b/application/src/main/java/org/togetherjava/tjbot/commands/moderation/ReportCommand.java
@@ -0,0 +1,225 @@
+package org.togetherjava.tjbot.commands.moderation;
+
+import com.github.benmanes.caffeine.cache.Cache;
+import com.github.benmanes.caffeine.cache.Caffeine;
+import net.dv8tion.jda.api.EmbedBuilder;
+import net.dv8tion.jda.api.entities.Guild;
+import net.dv8tion.jda.api.entities.Message;
+import net.dv8tion.jda.api.entities.MessageEmbed;
+import net.dv8tion.jda.api.entities.channel.concrete.TextChannel;
+import net.dv8tion.jda.api.events.interaction.ModalInteractionEvent;
+import net.dv8tion.jda.api.events.interaction.command.MessageContextInteractionEvent;
+import net.dv8tion.jda.api.interactions.InteractionHook;
+import net.dv8tion.jda.api.interactions.commands.build.Commands;
+import net.dv8tion.jda.api.interactions.components.Modal;
+import net.dv8tion.jda.api.interactions.components.text.TextInput;
+import net.dv8tion.jda.api.interactions.components.text.TextInputStyle;
+import net.dv8tion.jda.api.requests.restaction.MessageCreateAction;
+import net.dv8tion.jda.api.utils.Result;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.togetherjava.tjbot.commands.BotCommandAdapter;
+import org.togetherjava.tjbot.commands.CommandVisibility;
+import org.togetherjava.tjbot.commands.MessageContextCommand;
+import org.togetherjava.tjbot.commands.utils.DiscordClientAction;
+import org.togetherjava.tjbot.commands.utils.MessageUtils;
+import org.togetherjava.tjbot.config.Config;
+
+import java.awt.*;
+import java.time.Instant;
+import java.time.temporal.ChronoUnit;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Predicate;
+import java.util.regex.Pattern;
+
+
+/**
+ * Implements the /report command, which allows users to report a selected offensive message from
+ * another user. The message is then forwarded to moderators in a dedicated channel given by
+ * {@link Config#getModMailChannelPattern()}.
+ */
+public final class ReportCommand extends BotCommandAdapter implements MessageContextCommand {
+
+    private static final Logger logger = LoggerFactory.getLogger(ReportCommand.class);
+    private static final String COMMAND_NAME = "report";
+    private static final String REPORT_REASON_INPUT_ID = "reportReason";
+    private static final int COOLDOWN_DURATION_VALUE = 3;
+    private static final ChronoUnit COOLDOWN_DURATION_UNIT = ChronoUnit.MINUTES;
+    private static final Color AMBIENT_COLOR = Color.BLACK;
+    private final Cache<Long, Instant> authorToLastReportInvocation = createCooldownCache();
+    private final Predicate<String> modMailChannelNamePredicate;
+    private final String configModMailChannelPattern;
+
+    /**
+     * Creates a new instance.
+     *
+     * @param config to get the channel to forward reports to
+     */
+    public ReportCommand(Config config) {
+        super(Commands.message(COMMAND_NAME), CommandVisibility.GUILD);
+
+        modMailChannelNamePredicate =
+                Pattern.compile(config.getModMailChannelPattern()).asMatchPredicate();
+
+        configModMailChannelPattern = config.getModMailChannelPattern();
+    }
+
+    private Cache<Long, Instant> createCooldownCache() {
+        return Caffeine.newBuilder()
+            .maximumSize(1_000)
+            .expireAfterAccess(COOLDOWN_DURATION_VALUE, TimeUnit.of(COOLDOWN_DURATION_UNIT))
+            .build();
+    }
+
+    @Override
+    public void onMessageContext(MessageContextInteractionEvent event) {
+        long userID = event.getUser().getIdLong();
+        String reportedMessageTimestamp = event.getTarget().getTimeCreated().toInstant().toString();
+
+        if (handleIsOnCooldown(event)) {
+            return;
+        }
+        authorToLastReportInvocation.put(userID, Instant.now());
+
+        String reportedMessage = event.getTarget().getContentRaw();
+        String reportedMessageID = event.getTarget().getId();
+        String reportedMessageChannel = event.getTarget().getChannel().getId();
+        String reportedAuthorName = event.getTarget().getAuthor().getName();
+        String reportedAuthorAvatarURL = event.getTarget().getAuthor().getAvatarUrl();
+        String reportedAuthorID = event.getTarget().getAuthor().getId();
+
+        TextInput modalTextInput = TextInput
+            .create(REPORT_REASON_INPUT_ID, "Anonymous report to the moderators",
+                    TextInputStyle.PARAGRAPH)
+            .setPlaceholder("Why do you want to report this message?")
+            .setRequiredRange(3, 200)
+            .build();
+
+        String reportModalComponentID = generateComponentId(reportedMessage, reportedMessageID,
+                reportedMessageChannel, reportedMessageTimestamp, reportedAuthorName,
+                reportedAuthorAvatarURL, reportedAuthorID);
+        Modal reportModal = Modal.create(reportModalComponentID, "Report this to a moderator")
+            .addActionRow(modalTextInput)
+            .build();
+
+        event.replyModal(reportModal).queue();
+    }
+
+    private boolean handleIsOnCooldown(MessageContextInteractionEvent event) {
+        if (!isAuthorOnCooldown(event.getUser().getIdLong())) {
+            return false;
+        }
+        event
+            .reply("You can only report a message once per %s minutes."
+                .formatted(COOLDOWN_DURATION_VALUE))
+            .setEphemeral(true)
+            .queue();
+        return true;
+    }
+
+    private boolean isAuthorOnCooldown(long userId) {
+        return Optional.ofNullable(authorToLastReportInvocation.getIfPresent(userId))
+            .map(sinceCommandInvoked -> sinceCommandInvoked.plus(COOLDOWN_DURATION_VALUE,
+                    COOLDOWN_DURATION_UNIT))
+            .filter(Instant.now()::isBefore)
+            .isPresent();
+    }
+
+    @Override
+    public void onModalSubmitted(ModalInteractionEvent event, List<String> args) {
+        Optional<TextChannel> modMailAuditLog = handleRequireModMailChannel(event);
+
+        if (modMailAuditLog.isEmpty()) {
+            return;
+        }
+
+        sendModMessage(event, args, modMailAuditLog.orElseThrow());
+    }
+
+    private Optional<TextChannel> handleRequireModMailChannel(ModalInteractionEvent event) {
+        long guildID = Objects
+            .requireNonNull(event.getGuild(),
+                    "Guild is null for ModalInteractionEvent in ReportCommand.")
+            .getIdLong();
+        Optional<TextChannel> modMailAuditLog = event.getJDA()
+            .getTextChannelCache()
+            .stream()
+            .filter(channel -> modMailChannelNamePredicate.test(channel.getName()))
+            .findAny();
+        if (modMailAuditLog.isEmpty()) {
+            event.reply(
+                    "Sorry, there was an issue sending your report to the moderators. We are investigating.")
+                .setEphemeral(true)
+                .queue();
+            logger.warn(
+                    "Cannot find the designated modmail channel in server by id {} with the pattern {}",
+                    guildID, configModMailChannelPattern);
+        }
+        return modMailAuditLog;
+    }
+
+    private MessageCreateAction createModMessage(String reportReason,
+            ReportedMessage reportedMessage, Guild guild, TextChannel modMailAuditLog) {
+
+        MessageEmbed reportedMessageEmbed = new EmbedBuilder().setTitle("Report")
+            .setDescription(MessageUtils.abbreviate(reportedMessage.content,
+                    MessageEmbed.DESCRIPTION_MAX_LENGTH))
+            .setAuthor(reportedMessage.authorName, null, reportedMessage.authorAvatarUrl)
+            .setTimestamp(reportedMessage.timestamp)
+            .setColor(AMBIENT_COLOR)
+            .build();
+
+        MessageEmbed reportReasonEmbed = new EmbedBuilder().setTitle("Reason")
+            .setDescription(reportReason)
+            .setColor(AMBIENT_COLOR)
+            .build();
+        return modMailAuditLog.sendMessageEmbeds(reportedMessageEmbed, reportReasonEmbed)
+            .addActionRow(DiscordClientAction.Channels.GUILD_CHANNEL_MESSAGE.asLinkButton(
+                    "Go to Message", guild.getId(), reportedMessage.channelID, reportedMessage.id));
+    }
+
+    private void sendModMessage(ModalInteractionEvent event, List<String> args,
+            TextChannel modMailAuditLog) {
+        Guild guild = event.getGuild();
+        event.deferReply().setEphemeral(true).queue();
+
+        InteractionHook hook = event.getHook();
+        String reportReason = event.getValue(REPORT_REASON_INPUT_ID).getAsString();
+
+        ReportedMessage reportedMessage = ReportedMessage.ofArgs(args);
+
+        createModMessage(reportReason, reportedMessage, guild, modMailAuditLog).mapToResult()
+            .map(this::createUserReply)
+            .flatMap(hook::editOriginal)
+            .queue();
+    }
+
+    private String createUserReply(Result<Message> result) {
+        if (result.isFailure()) {
+            logger.warn("Unable to forward a message report to modmail channel.",
+                    result.getFailure());
+            return "Sorry, there was an issue sending your report to the moderators. We are investigating.";
+        }
+        return "Thank you for reporting this message. A moderator will take care of the matter as soon as possible.";
+    }
+
+    private record ReportedMessage(String content, String id, String channelID, Instant timestamp,
+            String authorName, String authorAvatarUrl) {
+        static ReportedMessage ofArgs(List<String> args) {
+            String content = args.get(0);
+            String id = args.get(1);
+            String channelID = args.get(2);
+            Instant timestamp = Instant.parse(args.get(3));
+            String authorName = args.get(4);
+            String authorAvatarUrl = args.get(5);
+            return new ReportedMessage(content, id, channelID, timestamp, authorName,
+                    authorAvatarUrl);
+        }
+
+    }
+
+}
diff --git a/application/src/main/java/org/togetherjava/tjbot/commands/moderation/modmail/ModMailCommand.java b/application/src/main/java/org/togetherjava/tjbot/commands/moderation/modmail/ModMailCommand.java
index c50f8af208..8a83c3badb 100644
--- a/application/src/main/java/org/togetherjava/tjbot/commands/moderation/modmail/ModMailCommand.java
+++ b/application/src/main/java/org/togetherjava/tjbot/commands/moderation/modmail/ModMailCommand.java
@@ -35,7 +35,7 @@
 /**
  * Implements the /modmail command, which allows users to contact a moderator within the server
  * which forwards messages to moderators in a dedicated channel given by
- * {@link Config#getModAuditLogChannelPattern()}.
+ * {@link Config#getModMailChannelPattern()}.
  */
 
 public final class ModMailCommand extends SlashCommandAdapter {
diff --git a/build.gradle b/build.gradle
index a452e25d5d..09d6f785df 100644
--- a/build.gradle
+++ b/build.gradle
@@ -10,6 +10,7 @@ version '1.0-SNAPSHOT'
 
 ext {
     jooqVersion = '3.17.2'
+    jacksonVersion = '2.14.0'
 }
 
 // Skips sonarlint during the build, useful for testing purposes.