Signal-scanning surfaces that turned fast-moving Discord chatter into a readable workflow for traders moving under time pressure.

Role: Lead Product Designer · Frontend

Year: 2025–2026

Status: Testing

Tools: Product Design / Frontend / Agents / Growth

Quickscope is a trading terminal for memecoins. Our users were spending hours a day inside it, but they were also spending hours inside Discord — discussing tokens, sharing alpha, coordinating entries, asking "is this a rug?" before pulling the trigger. Every real research session still meant leaving Discord: opening a rug checker, scanning X for sentiment, pulling up DexScreener, coming back to paste a verdict.

The Discord bot started as a side project — a prototype to see whether we could collapse the research loop into the chat window. It grew into a product. Today it serves 250+ communities and has routed over $4M in trading volume.

The research should come to the trader, not the other way around. Every context switch between Discord → rug checker → Twitter → DexScreener → back to Discord was a tax — and in memecoin trading, the tax is paid in missed entries. A community pinging a contract address and then waiting five minutes while someone audits it manually is five minutes the trade is already over.

The bet was simple: if the trader's default surface is Discord, the scan should land in Discord, in the form a Discord user expects.

The hardest design problem wasn't the bot — it was the message. What does a good AI token scan look like in a Discord embed? Too terse and traders don't trust it. Too dense and no one reads it. Too confident and the bot misleads on genuinely ambiguous tokens.

I iterated on the report format more than anything else in the project: structured cards with risk signals, confidence levels, on-chain signals, holder distribution, dev wallet activity, and social sentiment — all readable in under two seconds of scanning. Confidence was surfaced explicitly rather than embedded in the copy, so users could trust their own interpretation.

I designed a channel structure that mirrored how traders actually used Discord: dedicated scan channels for AI audits, alpha feeds for community-surfaced tokens, and separate areas for discussion. The goal was that a new community could spin up our server template and immediately feel like the structure already matched their trading workflow.

Beyond the AI summary, serious traders wanted the raw data. I designed a token detail view and a radar visualization for quick risk assessment — the radar reduced six independent risk signals into a single shape the eye could read as "safe" or "off" at a glance. Details still available for anyone who wanted to dig.

The next step was closing the loop. Traders could now scan in Discord. Why were they leaving to trade? We built Quick Buy directly into the scan embed — tap a button, select a size preset, confirm a quote, trade executes in their linked Quickscope wallet. Two to three clicks, no browser, no wallet popup.

The architecture was the part I cared most about. Quickscope's trading backend was already client-agnostic — the same endpoints powered the web terminal and the Telegram bot. The Discord bot was the third client. All three used the same platform wallet, the same swap engine, the same backend signing. The only new piece was the account linking flow. That design decision — one backend, many surfaces — meant the Discord bot shipped in weeks instead of months, and any future surface (iOS, extension, API) could inherit the same pattern.

A few things were technically possible that we chose not to ship. Limit orders from Discord. Social trading with revenue share. Copy trading. Pinging other users with token links that triggered trades on their wallet.

We passed on each. Limit orders had a UX problem that Discord's message format couldn't solve cleanly. Social trading introduced risk surfaces we didn't want to be responsible for on a chat platform. Copy trading needed a second-order product decision we weren't ready to make. And anything that made trades on a user's behalf without explicit confirmation crossed a line we'd drawn early: every financial action had to be initiated, quoted, and confirmed by the user, in ephemeral messages only they could see.

Discord's Developer Policy shaped part of this too. The bot sends interaction signals; it never transmits financial data through Discord's API. Every trade execution happens entirely on Quickscope's infrastructure. That's the same pattern Lute, BonkBot, Trojan, and the other established trading bots use — and the line we made sure not to cross.

The terminal at quickscope.gg is still the core product — but a lot of the value lives in the fifteen minutes before a trader even opens the site. That's where Discord sits. By moving the scan, the audit, and eventually the trade into Discord, the product started showing up earlier in the trader's day and earning trust before the user ever landed on our domain.

The architectural call made the surface work cheap. That's the piece I'd repeat on any future product: one backend, many surfaces, every new surface inherits the whole system.

250+ active Discord communities running the scan bot

5,400+ community members scanning tokens through it

$4M+ in trading volume driven through bot-assisted entries

Shipped across four waves: account linking, scan + AI report, in-Discord trading, settings + polish.

What I took from this: the design problem for an AI product isn't usually the model. It's the message. The scan itself was relatively solved — the hard part was the format the output landed in, the confidence signals, the boundary between information and recommendation. Everything after that — the trading loop, the leaderboards, the architecture — was execution on a frame the format had already set.