diff --git a/src/brain.rs b/src/brain.rs
index 5a7510c..151ac53 100644
--- a/src/brain.rs
+++ b/src/brain.rs
@@ -96,7 +96,7 @@ impl Brain {
         let chance = if is_self { 45 } else { 80 };
         let roll = rand.u8(0..=100);
 
-        (FORCE_REPLIES && !is_self) || roll <= chance
+        (FORCE_REPLIES) || roll <= chance
     }
 
     fn extract_final_token(msg: &str) -> Option<Token> {
diff --git a/src/main.rs b/src/main.rs
index 7ca861a..09cc149 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -51,18 +51,17 @@ pub struct BotContext {
 
 async fn handle_discord_event(event: Event, ctx: Arc<BotContext>) -> Result {
     match event {
-        Event::MessageCreate(msg) => handle_discord_message(msg, ctx).await?,
+        Event::MessageCreate(msg) => handle_discord_message(msg, ctx).await,
         Event::Ready(ev) => {
             info!("Connected to gateway as {}", ev.user.name);
             let brain = ctx.brain_handle.lock().await;
-            update_status(&*brain, &ctx.shard_sender).context("Failed to update status")?;
+            update_status(&*brain, &ctx.shard_sender).context("Failed to update status")
         }
         _ => {
             debug!("Ev: {event:?}");
+            Ok(())
         }
     }
-
-    Ok(())
 }
 
 fn load_brain(path: &Path) -> Result<Option<Brain>> {
@@ -176,6 +175,9 @@ async fn main() -> Result {
 
     loop {
         tokio::select! {
+
+            biased;
+
             Ok(()) = tokio::signal::ctrl_c() => {
                 info!("SIGINT: Closing connection and saving");
                 shard.close(CloseFrame::NORMAL);
diff --git a/src/on_message.rs b/src/on_message.rs
index 5032c2f..cd552ee 100644
--- a/src/on_message.rs
+++ b/src/on_message.rs
@@ -20,17 +20,20 @@ pub async fn handle_discord_message(msg: Box<MessageCreate>, ctx: Arc<BotContext
         .is_some_and(|flags| flags.contains(MessageFlags::EPHEMERAL));
     let is_dm = msg.guild_id.is_none();
 
-    // Should Ingest Message?
-    if is_self || !is_normal_message || is_ephemeral || is_dm {
+    // Should we consider this message at all?
+    if !is_normal_message || is_ephemeral || is_dm {
         return Ok(());
     }
 
-    let mut brain = ctx.brain_handle.lock().await;
-    let learned_new_word = brain.ingest(&msg.content);
-    ctx.pending_save.store(true, Ordering::Relaxed);
+    // Should we learn from this message? (We don't want to learn from ourselves)
+    if !is_self {
+        let mut brain = ctx.brain_handle.lock().await;
+        let learned_new_word = brain.ingest(&msg.content);
+        ctx.pending_save.store(true, Ordering::Relaxed);
 
-    if learned_new_word {
-        update_status(&*brain, &ctx.shard_sender).context("Failed to update status")?;
+        if learned_new_word {
+            update_status(&*brain, &ctx.shard_sender).context("Failed to update status")?;
+        }
     }
 
     // Should Reply to Message?
@@ -52,20 +55,27 @@ pub async fn handle_discord_message(msg: Box<MessageCreate>, ctx: Arc<BotContext
         done_tx.send(()).ok();
     });
 
+    let brain = ctx.brain_handle.lock().await;
     if let Some(reply_text) = brain
         .respond(&msg.content, is_self, Some(typ_tx))
         .filter(|s| !s.trim().is_empty())
     {
         drop(brain);
         done_rx.await.ok();
-        ctx.http
+        let allowed_mentions = AllowedMentions::default();
+        let my_msg = ctx
+            .http
             .create_message(msg.channel_id)
             .content(&reply_text)
-            .reply(msg.id)
-            .fail_if_not_exists(false)
-            .allowed_mentions(Some(&AllowedMentions::default()))
-            .await
-            .context("Failed to send message")?;
+            .allowed_mentions(Some(&allowed_mentions));
+
+        let my_msg = if !is_self {
+            my_msg.reply(msg.id).fail_if_not_exists(false)
+        } else {
+            my_msg
+        };
+
+        my_msg.await.context("Failed to send message")?;
     }
 
     Ok(())