Why we ditched Discord Embeds for Components V2 (and built a minimalist bot)

yuax — Wed, 16 Sep 2026 23:02:19 +0000

If you've used Discord in the past few years, you've probably noticed that almost every bot feels identical: giant colorful embeds, endless emojis, noisy confirmation messages, and clunky reaction-based menus.

When building ego — a curated social utility bot — we decided to take a completely different route: keep it minimal, understated, and built entirely around Discord Components V2.

Here is why we moved away from classic embeds and how we structured the architecture.

The Problem with Traditional Embeds

Classic Discord embeds were great in 2017, but today they have major UX flaws:

Visual noise: High-contrast colored sidebars draw unnecessary attention to trivial status messages.
Screen real estate: A simple command response can take up half a phone screen.
Impersonal feel: They look like automated marketing bots rather than natural platform utilities.

Discord markdown has evolved. Features like subtext, blockquotes, and native Components V2 (containers, sections, buttons, and separators) allow you to build interfaces that feel native to Discord's dark theme.

Instead of big colorful banners with decorative emojis, clean status blocks like this look significantly better:

ws: 16ms
-# shard 0 · 14 guilds

Tech Stack Choices: Pragmatism Over Hype

For ego's core architecture, we opted for:

Runtime: Node.js 22 + TypeScript (ESM)
Library: discord.js v14
Database: SQLite with better-sqlite3 and drizzle-orm
Cache / Hot-State: Optional Redis layer, falling back to in-memory

Why SQLite + Drizzle?

A lot of bot developers immediately spin up PostgreSQL or MongoDB. For a social utility bot handling local guild preferences, fast identity histories, and low-latency lookups, an embedded SQLite database running with WAL mode (Write-Ahead Logging) delivers sub-millisecond query times with zero networking overhead.

export const userSnapshots = sqliteTable('user_snapshots', {
  id: text('id').primaryKey(),
  userId: text('user_id').notNull(),
  username: text('username').notNull(),
  avatarHash: text('avatar_hash'),
  capturedAt: integer('captured_at', { mode: 'timestamp' }).notNull(),
});

───

Killer Feature: Frictionless Media Auto-Resolution

One of the biggest pain points in modern Discord is broken video previews when someone pastes a link from Instagram, X (Twitter), or TikTok.

Rather than making users run commands like /fixlink or paste alternative domains, ego listens passively for supported URLs:

Resolves the direct media source via backend streamers.
Attaches the video/photo directly using native Discord message attachments.
Suppresses the original broken embed using MessageFlags.SuppressEmbeds.

The result: users get instant playable video right in their feed without clutter or friction.

───

What We Learned

Restraint is a feature: Removing information is harder than adding it, but users appreciate tools that don't shout for attention.
Components V2 are the future of Discord UI: Separators, accessory thumbnails, and discreet button rows provide significantly better hierarchy than legacy embeds.
Keep feature logic out of generic event files: Isolate features into dedicated modules with their own lifecycle hooks and services.

You can check out the live project at ego.skin (https://ego.skin).

How are you approaching UI design in Discord applications in 2026? Are you still using embeds or transitioning to components? Let me know in the comments!

How I Detect Discord Selfbots Without Reading a Single Message

yuax — Sat, 23 May 2026 22:49:03 +0000

The Problem

Discord selfbots - automated user accounts - are used for spam raids, phishing, and coordinated attacks. Traditional moderation bots scan message content, but that requires the MESSAGE_CONTENT privileged intent and raises privacy concerns.

I wanted to catch bots without reading what people type.

The Insight

Discord's gateway broadcasts a TYPING_START event every time someone begins typing. This is metadata - it tells you WHO started typing, WHERE, and WHEN.

A human needs 300-500ms just to switch focus between two Discord channels. A selfbot fires parallel HTTP requests and can trigger typing in multiple channels within 5-50ms.

That gap is massive. A hard threshold of 150ms catches every bot without touching a single real user.

  Selfbot           Human
  ┌─────┐          ┌─────────────────┐
  │5-50ms│          │   300-500ms+    │
  └─────┘          └─────────────────┘
       ▲                    ▲
       │                    │
   CAUGHT              SAFE

Beyond Typing: Ghost Detection

Some selfbots disable typing events entirely (using "silent typing" plugins). So I added the inverse detection:

If a message arrives WITHOUT a preceding TYPING_START - that's suspicious.

Normal Discord desktop clients always fire a typing event before sending. No typing + message = likely automation.

Channel Sequence Fingerprinting

Selfbots often iterate channels programmatically - by ID order (ascending or descending). Humans jump between channels randomly based on interest.

If I see typing events hitting channels in perfect numeric ID order - that's a bot fingerprint.

The Stack

Rust - lock-free DashMap correlator, sub-millisecond detection
Twilight - lightweight Discord gateway library (not discord.js)
SQLite - persistent detection history, incident timeline
Zero privileged intents - no MESSAGE_CONTENT, no GUILD_MEMBERS, no PRESENCE

What It Cannot Do

Read messages (by design)
Catch 100% of threats (behavioral signals are probabilistic)
Replace Discord AutoMod (it complements it - AutoMod for content, Wiretrip for behavior)

Try It

https://wiretrip.lol - free, safe defaults (log-only mode), 30-second setup.

DEV Community: yuax