There's Someone Going Viral on X Lately

If you've been scrolling X (Twitter) recently, you may have already come across this account: @aleabitoreddit, handle "Serenity."

Their bio is a single line: former well-known Reddit WallStreetBets trader, AI / semiconductor supply-chain analyst, former RISC-V Foundation member, former AI research scientist, now trading exclusively "those overlooked bottleneck companies."

Sounds like the standard X braggart bio? But the numbers speak for themselves: they only registered on X in July 2025, and by May this year their follower count had grown past 350,000, with paid subscribers rivaling Musk's.

What turns even more heads is the track record. They claim a peak annualized return of +501%, currently holding steady around +122%, and have publicly named more than 38 stock tickers. Someone even built a "Serenity Tracker" website to follow the positions, finding that the claimed 3,840% annualized return came mainly from getting in early on obscure small-cap names in the AI and semiconductor supply chain.

Has anyone fact-checked this? Yes. Back in their Reddit days, they were banned by a WallStreetBets moderator for recommending $AXTI early (which ran from $12 to $70), allegedly because "retail making too much money made the mods uncomfortable." That detail is rather interesting.

Of course, return screenshots on social media should always be taken with a grain of salt. But purely in terms of stock-picking ability, independent verifications of their recommended tickers basically all conclude the same thing — they really are accurate. So I started wondering: could I wire their tweet signals into a trading system in real time?

Where Does the Value of This Kind of Information Come From?

First, some background.

In China's A-share market, we're used to reading research reports, watching institutional money flows, and chasing news. But in U.S. equities and crypto, the influence of KOLs on X is sometimes no less than institutional research — especially those with genuine depth in a vertical niche.

Serenity's core methodology is called "Chokepoint theory": start from high-certainty end demand (the explosion in AI compute), reverse-engineer the supply chain layer by layer, and find the upstream small-cap companies with extremely high technical barriers and severe supply-demand mismatch. These companies often have tiny market caps and no institutional coverage, but once demand spikes, their upside elasticity is enormous.

The logic is clear, and they track names persistently under a real (if pseudonymous) identity — not the kind of short-term hype account that pumps and disappears.

Similar logic can be extended to many places:

• A single Musk tweet on X can send Dogecoin soaring within minutes.
• A crypto big shot shilling an altcoin is often the beginning of retail being left holding the bag (you can also use this in reverse).
• Some analysts in traditional finance circles disclose positions on X ahead of their official reports.

Social-media information is itself a form of alpha — most people just haven't systematically plugged into it.

But There's a Practical Problem: We Can't Buy U.S. Stocks Directly

Most of Serenity's recommended tickers are U.S. equities — NVDA, MRVL, AVGO, SIVE, and the like. The average user doesn't have a U.S. brokerage account, or doesn't want to go down that road. What then?

Here's one idea: Binance's TradFi stock perpetual contracts.

Binance has listed a batch of perpetual contracts using U.S. stocks as the underlying, settled in USDT, supporting both long and short positions, requiring no U.S. brokerage account, and trading 24/7. They currently cover dozens of mainstream U.S. tickers including NVDA, MRVL, AMD, AVGO, META, MSFT, AMZN, and GOOGL, and the list keeps expanding.

This means: if Serenity recommends MRVL, I don't need to open a U.S. brokerage account — I can just open a long position on the MRVL_USDT perpetual contract on Binance.

Of course, these contracts differ from holding the stock directly — there are no dividends, it's purely price tracking, and there's a funding-rate cost. But for short-to-medium-term directional trades, it's good enough.

The Overall Design of the System

Once I'd thought this through, I started designing the system.

The whole thing is just three steps:

            
            
            
① Fetch Serenity's tweets in real time
        ↓
② Parse the tweet signal with an LLM (which ticker is bullish? how high is the confidence?)
        ↓
③ Match it to a Binance TradFi contract, execute the trade + risk control

The first step is the most critical — how do you fetch tweets in real time?

Twitter's official API now charges, and it isn't cheap. Is there a free option?

Yes: RSSHub. It's an open-source tool that turns all kinds of websites into RSS feeds, including Twitter tweets. Paired with your own account's cookie, it can convert any user's tweets into an RSS feed in real time — essentially using your own account to scrape the page, completely free.

Deploying RSSHub

I deployed RSSHub on an overseas server, so there's no extra network plumbing to deal with. The server runs Podman (a common container runtime on CentOS), and one command does it:

            bash
            
            
podman run -d \
  --name rsshub \
  -p 1200:1200 \
  -e NODE_ENV=production \
  -e CACHE_TYPE=memory \
  -e TWITTER_AUTH_TOKEN="your_auth_token" \
  -e TWITTER_COOKIE="auth_token=your_auth_token; ct0=your_ct0" \
  diygod/rsshub:latest

Here auth_token and ct0 are cookies from your Twitter account, found in the browser's developer tools (F12 → Application → Cookies → under x.com).

These two values are effectively your account's login credentials — only use a throwaway account, and don't leak them.

Verify it:

            bash
            
            
curl "http://localhost:1200/twitter/user/aleabitoreddit" | head -3

If you see RSS content beginning with <?xml, it worked. After that, the strategy just makes an HTTP request to this address to get the latest list of tweets.

Fetching the Contract List Dynamically

Binance's TradFi contracts are continuously being added, so the contract table can't be hardcoded — refresh it on every startup and on a timer:

            python
            
            
def refresh_equity_contracts():
    ms = exchange.GetMarkets()
    new_map = {}
    for key, market in ms.items():
        info = market.get("Info", {}) or {}
        sub_type = info.get("underlyingSubType", [])
        # Filter for TradFi EQUITY perpetual contracts
        if (
            ".swap" in key
            and "TradFi" in sub_type
            and info.get("underlyingType") == "EQUITY"
        ):
            ticker = key.replace("_USDT.swap", "")
            new_map[ticker] = key   # {"NVDA": "NVDA_USDT.swap", ...}
    return new_map

This way newly listed contracts are automatically included, and when the LLM parses a tweet it's also handed the latest contract list as its reference scope.

Teaching the LLM to Understand Serenity's Language

This step is the most interesting part of the whole system, and also the part that needs the most polishing.

Asking the LLM directly whether "this tweet is bullish or bearish" is too crude — Serenity's way of expressing things is distinctive, and someone unfamiliar with them will misjudge a lot.

For example, they often post tweets like this:

"Wow… new extremely transformative news got released today. Making a certain photonics company the effective upstream laser chokepoint for $NVDA NVLink fusion CPO ecosystem. Can anyone guess the name?"

This tweet is essentially teasing to drive engagement — the next tweet is the one that actually names the bullish target. If the LLM doesn't know this habit, it might judge this as a strong bullish signal for NVDA — completely off the mark.

So the system prompt needs to spell out their expression habits explicitly:

            python
            
            
system_prompt = (
    "You are a trading-signal extractor specialized in interpreting tweets from the Twitter user 'Serenity'. "
    "This user is an AI and semiconductor supply-chain analyst, and you need to understand their particular expression habits:\n"
    "1. They rarely say 'buy' directly; instead they hint at being bullish by describing a company's supply-chain position and moat\n"
    "2. Strongly bullish keywords: 'I personally think', 'undervalued', 'going much higher', "
    "'chokepoint', 'structural', 'thesis validated', 'go brrr', 'bullish'\n"
    "3. Bearish keywords: 'avoid', 'overvalued', 'nuking', 'ban', 'bearish'\n"
    "4. Question-style tweets ('Can anyone guess?', 'Does anyone know?') "
    "are teasers to drive engagement and do not themselves constitute a trading signal; direction should be neutral\n"
    "5. Macro-trend descriptions that don't express a stance on a specific named ticker do not constitute a signal\n"
    "Output only valid JSON, nothing else."
)

Return a uniform JSON format:

            python
            
            
{
    "tickers": ["MRVL", "LITE"],  # Only tickers the author explicitly takes a stance on; must be in the contract list
    "direction": "long",           # long / short / neutral
    "confidence": 85,              # 0-100, the combined strength of the signal
    "reason": "The author clearly expresses bullishness on AI networking/interconnect demand"
}

Criteria for judging confidence:

• Explicit stance + concrete supporting logic: 80–95
• Describes positive facts but takes no explicit stance: 55–75
• Question / teaser / engagement-style: 10–40 (force direction to neutral here)
• Macro description with no specific ticker: 30–50 (return empty tickers)

In practice, accuracy on identifying "teaser tweets" is quite high — this category basically all gets filtered out correctly.

Risk-Control Design

Once you have the signal, the order logic isn't actually that complex — the key is keeping risk control solid.

Position management:

• Per-trade position size: 5% of account equity
• Maximum concurrent positions: 5 tickers
• Leverage: 1x, no leverage

Stop-loss:

• Hard stop: close immediately at a 5% loss from entry price, no room for negotiation

Take-profit: no fixed take-profit, only a drawdown-based take-profit

This design comes from Serenity's holding style — their logic is to wait for the supply-demand mismatch to play out, so holding periods tend to be long, and a fixed take-profit would cut off a lot of profit. So I switched to a trailing drawdown take-profit:

            python
            
            
# Once unrealized gain reaches 8% → activate trailing
# Actual drawdown threshold = max(30%, peak × 35%)
# The larger the peak, the larger the allowed drawdown

giveback_pct = max(30, peak * 0.35)
drawdown = peak - pnl_pct
if drawdown >= giveback_pct:
    # Execute close

An example to get a feel for it:

• Peak +20%, threshold = max(30%, 7%) = 7%, exit on a pullback to +13%
• Peak +80%, threshold = max(30%, 28%) = 28%, exit only on a pullback to +52%

Big winners get to run fully, small losses get cut quickly — this structure matches Serenity's own holding style.

A Safety Valve: Notify First, Trade Second

By default the strategy runs in "notify-only" mode: when there's a signal it only logs it, without actually placing an order. After observing for a while and confirming the LLM's judgments match your own expectations, you then manually switch to "live trading" mode.

The dashboard has four tables:

The Tweet History table has a "signal type" column that automatically labels each tweet as either "💎 Strong signal" or "🎭 Teaser/Question," making it easy to go back and verify the quality of the LLM's judgments.

A Bit of Further Thinking

This framework is essentially about structuring a specific information source in real time and wiring it into a trading system — Serenity is just one example. As long as there's an RSS feed or a scrapable data source, in theory it can be plugged in. RSSHub already supports more than several thousand sources, not just Twitter.

Of course, the quality of the signal source sets the ceiling for the entire system. Pick someone who shills recklessly, and no matter how elegant the system is, it's useless. Serenity works because they have a complete analytical framework — not the kind of short-term influencer who pumps and runs.

A Few Closing Words

Building out the whole system, the parts that actually took time were two: first, deploying RSSHub (overseas server + cookie configuration), and second, tuning the LLM prompt (getting it to accurately understand a specific KOL's expression habits).

The code itself isn't that complex — the FMZ platform's framework wraps up a lot of the low-level details, so the focus is on thinking through the business logic clearly.

I'd suggest newcomers run notify-only mode for a while first, watch the logs to see whether the LLM's judgments go noticeably off the rails, and only switch to live trading after confirming it's stable. After all, trading by following social-media signals is itself a bet on a KOL's judgment — keep position sizes light, diversify, and hold your stops.

The strategy code and full implementation are in the comments section — feedback welcome.

Strategy code: Social-Media KOL Signal Tracking — Binance TradFi Stock Contracts