Xeron

Trading Is a Practice

Sun, 27 Sep 2026 00:00:00 GMT

Know what to do at each stage

Do the right thing and you get results

It isn’t simple. FOMO, boredom, itchy hands, fantasy

Walls at every turn. Trading is the practice of getting past them

Robinhood Is Plugging Stocks Into the Casino

Tue, 01 Sep 2026 16:00:00 GMT

Robinhood Chain is hot again

PONS, CASHCAT, AI and a few others ran to 9-figure caps. DEX volume went from $150–200M at the August lows to over $1.5B

At first glance it looks like another chain having its meme season

The more I watch, the less I think the memes themselves are the point

What’s actually interesting is stocks and crypto getting plugged into the same liquidity network

I’m calling it the stock-meme trade for now

Stocks just became the underlying for memes

Memes used to be simple

On Solana: MEME / SOL. On EVM: MEME / ETH or MEME / USDC

Crypto money just spinning inside crypto

Robinhood Chain is different

Now you see AI / NVDA, SPACEHOOD / SPCX, BONER / HIMS, MOO / MU, SAYLORMOON / MSTR, FATCOIN / LLY

Memes quoting directly against stock tokens

AI against NVIDIA. SPACEHOOD against SpaceX. MOO against Micron. FATCOIN against Eli Lilly

It’s not just borrowing a ticker in the name. The stock token is inside the LP

You buy AI with stables, the router might first buy NVDA stock token, then buy AI with NVDA

For the first time, stocks actually become the meme’s quote asset / liquidity / narrative

This is not a small experiment anymore

Robinhood only opened the chain mainnet in July. The original pitch wasn’t memes at all — it was RWA

Robinhood Stock Tokens are standard ERC-20s. Transferable, tradable, can go into lending, be used as collateral, composed by any DeFi protocol

Degens naturally found the use case: launch memes against stocks

As of Sep 1, someone scanned on-chain

Among the top 19 Robinhood Stock Tokens by liquidity, there are already 432 stock-meme LPs. Those pools lock about 17.2% of all on-chain stock token float, but generate 31.3% of those tokens’ DEX volume

Single pools are even crazier

One AI / NVDA pool locks ~16.2% of all on-chain NVDA tokens. BONER / HIMS at one point locked ~50% of all HIMS tokens

This isn’t a few coins coincidentally using stocks as a pair. It’s becoming its own asset class on Robinhood Chain

What actually matters is the on-ramp changed

Easy to get this wrong: is TradFi money flooding into crypto now?

No evidence for that yet. No sign that hordes of stock holders are selling to ape memes

What actually happened is Robinhood connected two pools that used to be separate

Before, two worlds

Stock pool: NVDA / MSTR / HIMS
Crypto pool: ETH / Stablecoins / Memes

Now

NVDA / MSTR / HIMS / SPCX
          ↓
     Stock Tokens
          ↓
   Robinhood Chain
      ↙       ↘
   DeFi       Meme
      ↘       ↙
   one shared liquidity

It’s not that stock money is already here. It’s that stock assets for the first time have a natural path straight into the crypto casino

That’s a new incremental capital interface

Why this meta is more interesting than animal memes

Normal memes have one big problem: you have to invent narrative from scratch

Today cats, tomorrow dogs, the day after frogs. Attention leaves, story ends

Stock memes don’t. The US stock market manufactures news every day on its own

NVIDIA ships a new chip: NVDA → AI meme

SpaceX launches, raises, talks IPO: SPCX → SPACEHOOD

Strategy buys BTC: MSTR → SAYLORMOON

GLP-1 data drops: LLY → FATCOIN

Micron earnings, memory prices up: MU → MOO

The stock’s own news cycle becomes the meme’s narrative engine

So you can flip the playbook

Instead of finding a meme first and then studying why it pumped, you can watch which stock is sucking up all the attention today, then go find its meme on Robinhood

Crazier still: memes are now feeding back into stock tokens

BONER / HIMS was the textbook case

Because BONER uses HIMS stock token as the LP quote, a ton of HIMS got locked in the pool. But on-chain HIMS supply is tiny

When the stock market closed for the weekend and no fresh tokens could be minted, on-chain HIMS traded at an extreme premium to the real stock

It used to be Stock → Meme. Now we’re seeing Meme → Stock token liquidity

The feedback loop is real

And that’s also the biggest risk

The stock token isn’t the stock. It’s a tokenized debt security issued by Robinhood Assets (Jersey) giving you economic exposure to the underlying

When liquidity is thin, the on-chain price can absolutely depeg from the real stock for a while. Don’t see the ticker NVDA and assume it’s the same as the NVIDIA in your brokerage

What Robinhood looks like now

I don’t think Solana is the right comp anymore

Solana memes were SOL → Pump → Meme

If Robinhood pulls this off, it could be Stock Token → Meme → DEX → Lending → Perps → Infra

Stocks are the base narrative asset. Memes are the attention and volume engine. RAM, UP, PAIR, launchpads, DEXes sell the shovels

Together it forms a TradFi Asset × Crypto Speculation loop

That’s why I’m not just watching the classic memes like PONS and CASHCAT

I’m also watching the stock-meme batch — AI / SPACEHOOD / MOO / FATCOIN — and the infra that taxes all the volume — RAM / UP / PAIR

What I’m watching next

I won’t judge whether this Robinhood run continues by which coin does another 10x. I’m watching three things

1. Do stock memes keep producing new leaders

AI / NVDA proved it once. If SPACEHOOD / SPCX, MOO / MU keep running, it means the meta is replicable, not a one-off

2. Does on-chain stock token liquidity keep growing

This is the real fuel. If stock tokens stay as tiny pools with tens of millions in float, the ceiling stays low

3. Can Robinhood DEX volume hold

Early September already did over $1.5B in a single day. If it holds or makes new highs, it’s not just the first batch of gamblers

If volume fades fast and AI / PONS / CASHCAT all break down together, no narrative, however elegant, matters

Price tells the truth

Closing

I used to treat HOOD as just another meme casino. That read feels incomplete now

What’s actually interesting about Robinhood isn’t that it minted a few more 100x memes

It’s that it’s doing something that was hard to happen naturally before: plugging US stock assets and the crypto casino into the same liquidity network

Still tiny. Stock memes might just be this cycle’s favorite new toy

But if this keeps spreading, the next 10x or 50x might not be the next dog

It might come from the next stock headline

My Kitty + DMS Theme and Font

Tue, 01 Sep 2026 00:00:00 GMT

Two things I’ve settled on recently — worth recommending.

Font: Maple Mono NF CN

Both Kitty and DMS use it at 12.0.

Monospace, CN variant keeps CJK alignment tidy
NF carries icons — yazi / neovim glyphs render correctly
Rounded shapes, easy for long sessions

~/.config/kitty/kitty.conf:

font_family Maple Mono NF CN
font_size 12.0

DMS settings.json uses the same:

"fontFamily": "Maple Mono NF CN"

Theme: Tokyo Night

Kitty uses tokyo-night.conf, DMS uses theme_tokyonight.json — both Tokyo Night.

background #1a1b26
foreground #c0caf5
primary    #7aa2f7

Deep blue base, not harsh, just the right contrast — very comfortable at night. DMS’s light variant is #d5d6db, so switching to light doesn’t feel out of place.

Switching themes in Kitty is one line:

include tokyo-night.conf
# include catppuccin-mocha.conf
# include kanagawa-wave.conf
# include everforest-dark-hard.conf

Skills I Use

Wed, 12 Aug 2026 13:00:00 GMT

I keep the skills I actually use in one repo — one line to install:

npx skills add ArchdevilForge/skills

Most-used:

thinking: thinking router — pick the right thinking mode for the job.

hustler-mind: hustler’s playbook — how to scheme, arbitrage, and work the angles.

prompt: diagnose and rewrite prompts.

Just a Tool

Thu, 02 Jul 2026 16:00:00 GMT

The Funny Debate About Tools Themselves

The irony: even heavy AI users warn that AI makes us worse at coding — that without it we can’t do anything, so we shouldn’t rely on it. Before AI you coded with an IDE. Without that IDE, could you code? So should you not rely on IDEs?

They’re just tools. As Xunzi said: The gentleman is not different in nature; he is good at borrowing from things.

What AI Is

Think of AI as someone always one step ahead of you cognitively. It always knows a little more than you do. The more you use it, the more you learn, the faster your mind expands.

But does that make you dumber?

In some ways, yes. You’ll get rusty at hand-writing bubble sort, crafting regex from scratch, recalling API signatures. Leave something unused long enough and you forget it.

The question is: did you ever need those abilities?

90% of what you learn in a field is dead weight — outdated by the time you learn it. What AI helps you skip isn’t coding itself, but all the things you thought you had to learn yet never actually needed.

AI is leverage, not replacement. It doesn’t make you useless; it lets you spend your energy where you previously couldn’t reach.

For example, disassemble your mind into SKILLs and let AI channel “how would Buffett see this” — suddenly you’re drawing on an information density far beyond your own domain.

AI Is Your Anywhere Door

Every model update is another leap. It takes you places you previously lacked the confidence or ability to go.

You don’t need to learn before you do. You don’t know it, AI does — you learn while doing. That’s the door:

From “learn first, then do” to “do first, learn along the way.”

So don’t hesitate.

The door is already in your hands. Go wherever you want.

The world is full of wonderlands — go wherever you please.

Reverse-Engineering Coinglass's Encrypted API

Mon, 15 Jun 2026 00:00:00 GMT

Every public API on Coinglass is encrypted. The response body is ciphertext — but the key is handed to you in the response headers.

Encryption Scheme

Coinglass uses AES-128-ECB plus double gzip; the decryption key arrives via response header:

Request  → GET /api/spot/rsi/list (with header encryption: true)
Response → Headers: { user: <base64 token>, v: "55" }

Decryption:
1. v=55 → look up constant "170b070da9654622"
2. base64(constant)[:16] → Key0
3. AES-ECB-decrypt(user_token, Key0) → gzip(actual_key)
4. Gunzip → 16-char hex key
5. AES-ECB-decrypt(encrypted_body, actual_key) → gzip(JSON)
6. Gunzip → plaintext JSON

No API key, no cookie, no session. Anyone who can make an HTTP request can decrypt any endpoint.

Key Constants

The v header selects which constant derives the first-layer key:

v	Constant	Source
55	`170b070da9654622`	webpack module 12471, `Kt[22]`
66	`d6537d845a964081`	webpack module 12471, `Kt[38]`
77	`863f08689c97435b`	webpack module 12471, `BatcW`
1	URL path	`btoa(url_path)[:16]`

All constants are hardcoded in the frontend webpack bundle. v=55/66/77 are fixed; v=1 is dynamic — derived from the request path.

How It Was Reversed

The logic lives in Next.js webpack module 12471, publicly fetchable from S3:

https://s3.coinglass.com/v1/cg/_next/static/chunks/pages/_app-f75bb33a408a04d3.js

Module 12471 contains:

AES-ECB encrypt/decrypt — CryptoJS
FP — GET + encrypt + decrypt response
xW — plain request, no encryption
Zl — POST + encryption
Request interceptor — auto-injects encryption: true, cache-ts-v2, etc.
String obfuscation — Qt(offset, seed) lookup

Key derivation is in function Yt. The three constants map to Kt[22], Kt[38], and BatcW. Obfuscation is shallow — strings are directly visible.

Implementation

# decrypt.py — core logic

_KEY_TABLE = {
    "55": "170b070da9654622",
    "66": "d6537d845a964081",
    "77": "863f08689c97435b",
}

def decrypt(encrypted_body, user_token_b64, v, url=""):
    outer = json.loads(encrypted_body)
    payload = base64.b64decode(outer["data"])
    token = base64.b64decode(user_token_b64)

    # Derive Key0
    constant = _KEY_TABLE.get(v) if v != "1" else urlparse(url).path
    key0 = base64.b64encode(constant.encode()).decode()[:16]

    # Layer 1: decrypt user token → actual key
    step1 = unpad(AES.new(key0.encode(), AES.MODE_ECB).decrypt(token), 16)
    actual_key = gzip.decompress(step1).decode()

    # Layer 2: decrypt body → plaintext
    step2 = unpad(AES.new(actual_key.encode(), AES.MODE_ECB).decrypt(payload), 16)
    return json.loads(gzip.decompress(step2).decode())

Usage:

from decrypt import fetch_and_decrypt

data = fetch_and_decrypt(
    "https://capi.coinglass.com/api/spot/rsi/list",
    {"pageSize": 500, "pageNum": 1},
)
print(data["list"][0]["rsi4h"])  # → "62.34"

Scale

More than 280 encrypted endpoints were uncovered, covering:

Spot — RSI, market cap, price moves
Futures — funding rates, open interest, liquidations, long/short ratios
Options — OI, volume, Max Pain
ETF flows — BTC/ETH/SOL/XRP
On-chain metrics — SOPR, MVRV, active addresses, CDD and 50+ more
On-chain indices — CGDI, CGRI, Pi Cycle, AHR999, Puell Multiple
Macro — economic calendar, TradFi overview
Hyperliquid — vaults, whale positions, user distribution

Full list in discovered_endpoints.py

Disclaimer

For education and research only. The scheme was reversed from publicly accessible frontend code. Please respect Coinglass’s Terms of Service.

Repo: github.com/xeronsh/coinglass-decrypt

MiMo Code Free Model Proxy

Mon, 15 Jun 2026 00:00:00 GMT

MiMo Code is Xiaomi’s AI coding tool with a free quota — but only usable inside MiMo Code. Let’s break it open.

Reverse-Engineering the Auth

The free API needs no login. Auth is done via a bootstrap endpoint:

POST https://api.xiaomimimo.com/api/free-ai/bootstrap
Body: {"client": "<device fingerprint>"}
Response: {"jwt": "eyJhbG..."}

Just sniff the traffic. No OAuth, no API key, no session — one POST gets you a JWT for the chat API.

Device Fingerprint

The client param is a locally generated fingerprint:

import hashlib, platform, os

def get_fingerprint() -> str:
    raw = "|".join([
        platform.node(),                        # hostname
        platform.system().lower(),              # darwin / linux / windows
        platform.machine(),                     # arm64 / x86_64
        platform.processor() or "unknown-cpu",  # CPU model
        os.environ.get("USER") or "unknown",    # username
    ])
    return hashlib.sha256(raw.encode()).hexdigest()

It’s persisted to ~/.local/share/mimocode/mimo-free-client so the same machine always bootstraps to the same token:

from pathlib import Path

FINGERPRINT_FILE = Path.home() / ".local/share/mimocode/mimo-free-client"

def get_fingerprint() -> str:
    if FINGERPRINT_FILE.exists():
        return FINGERPRINT_FILE.read_text().strip()
    fp = hashlib.sha256(...).hexdigest()
    FINGERPRINT_FILE.parent.mkdir(parents=True, exist_ok=True)
    FINGERPRINT_FILE.write_text(fp)
    FINGERPRINT_FILE.chmod(0o600)
    return fp

Parsing the JWT

The JWT’s exp field tells you when it expires:

def _parse_jwt_exp(jwt: str) -> float:
    # JWT payload is base64url-encoded JSON
    parts = jwt.split(".")
    pad = 4 - len(parts[1]) % 4
    payload = json.loads(base64.urlsafe_b64decode(parts[1] + "=" * pad))
    return payload.get("exp", time.time() + 3600) * 1000  # milliseconds

The proxy auto-refreshes 5 minutes before expiry:

async def get_token(self) -> str:
    if self._jwt and self._exp - time.time() * 1000 > 300_000:  # 5 min left
        return self._jwt
    # ... bootstrap for a new token

Concurrency Safety

When multiple requests notice expiry at once, only one bootstrap should fire:

async def get_token(self) -> str:
    if self._bootstrapping:  # another request is already bootstrapping
        return (await self._bootstrapping)[0]  # wait and reuse
    self._bootstrapping = asyncio.ensure_future(self._bootstrap())
    try:
        self._jwt, self._exp = await self._bootstrapping
        return self._jwt
    finally:
        self._bootstrapping = None

Request Forwarding

With the token, forward to the chat endpoint:

POST https://api.xiaomimimo.com/api/free-ai/openai/chat
Headers:
  Authorization: Bearer <jwt>
  X-Mimo-Source: mimocode-cli-free
  User-Agent: mimocode/0.1.0 ai-sdk/provider-utils/4.0.23 runtime/bun/1.3.14
Body: <OpenAI-format JSON>

But you can’t just pass through — the client format differs from standard OpenAI.

Body Rewriting

def _prepare_body(body: bytes) -> bytes:
    payload = json.loads(body)

    messages = payload.get("messages", [])
    normalized = []
    has_system_prompt = False

    for msg in messages:
        item = dict(msg)

        # MiMo Code uses developer role; standard is system
        if item.get("role") == "developer":
            item["role"] = "system"

        # Check for existing system prompt
        if item.get("role") == "system" and isinstance(item.get("content"), str):
            if item["content"].startswith("You are MiMoCode"):
                has_system_prompt = True

        normalized.append(item)

    # Inject default prompt if none present
    if not has_system_prompt:
        normalized.insert(0, {
            "role": "system",
            "content": "You are MiMoCode, an interactive CLI tool..."
        })

    payload["messages"] = normalized

    # MiMo requires stream_options for streaming
    if payload.get("stream"):
        payload.setdefault("stream_options", {"include_usage": True})

    return json.dumps(payload, separators=(",", ":"), ensure_ascii=False).encode()

Retry on Expiry

Auto re-bootstrap on 401/403:

resp = await client.send(req)
if resp.status_code in (401, 403):
    await jwt_mgr.invalidate()           # discard old token
    token = await jwt_mgr.get_token()    # bootstrap anew
    resp = await client.send(req)        # retry

Streaming Passthrough

SSE is piped directly without decoding:

async def _send_streaming(body: bytes):
    token = await jwt_mgr.get_token()
    client = httpx.AsyncClient(timeout=120)
    resp = await client.send(
        client.build_request("POST", CHAT_URL, headers=_build_headers(token), content=body),
        stream=True,
    )

    async def stream():
        try:
            async for chunk in resp.aiter_bytes():
                yield chunk
        finally:
            await resp.aclose()
            await client.aclose()

    return StreamingResponse(stream(), media_type="text/event-stream")

MiMo’s stream is already standard SSE — just pipe it through.

Pi Toolchain

Mon, 15 Jun 2026 00:00:00 GMT

Months with Pi, and only these stayed.

Extensions

ponytail: lazy senior mode. Cures GPT’s compulsive over-engineering. Currently on.

npm:pi-mcp-adapter: MCP adapter — both mcpScript and MCP tools run through it.

npm:pi-cache-optimizer: prompt and KV cache hit-rate optimization.

~/.pi/agent/extensions/rpiv-local: my local extension. Packs i18n, ask_user_question, and todo — that’s it.

MCPs

exa: web search.

fast-context: semantic code search.

playwright: browser automation.

Tacit Knowledge

Sun, 10 May 2026 00:00:00 GMT

Michael Polanyi put it bluntly: we know more than we can tell.

Your body knows how to balance a bicycle, yet you cannot write a manual that teaches someone to ride instantly. You look at a code snippet and know it stinks, but if asked to cite the exact violated rule, words fail.

That is tacit knowledge: judgment you actively practice but can never fully formalize.

Longer Style Guides, Worse Code

Anyone who has mentored junior devs knows this agony.

You write down clean rules: use camelCase, keep functions under 50 lines, do one thing per function. The PR comes back ticking every checkbox, yet the architecture is an absolute mess.

Good taste lives between the rules. Where abstraction stops, structural rhythm, and when to pragmatically bend the rules cannot be codified into rigid statutes.

Style guides grow thicker and thicker until nobody reads them, yet bad code keeps slipping through.

Prompting by Rules Is a Dead End

When prompting LLMs, many act like strict school principals: you must do this, you must never do that, format must match step 1, 2, 3.

The more rules you stack, the stiffer the output becomes. Where rules leave a gap, the model defaults to bland corporate filler.

Only three approaches actually work:

Provide examples, not abstract definitions: saying “keep the tone concise and natural” achieves nothing; pasting three actual sentences you like lets the model extract the pattern directly
Show negative examples: “don’t sound like this” sets hard boundaries faster than describing the ideal state
Admit when you can’t define it: if the draft feels off, tell it: “this feels fake, rewrite with a raw conversational voice”. Keep judgment in your hands instead of expecting one prompt to solve everything forever

Instead of exhausting yourself translating intuitive taste into rigid rules, pass concrete samples. You lose far less signal in the process.

Polymarket Weather Markets — Field Notes

Thu, 23 Apr 2026 00:00:00 GMT

Polymarket’s daily high-temperature bucket markets: bet which temperature interval a city’s daily high will land in — Hong Kong, Seoul, Tokyo and more. Multi-outcome buckets, decent liquidity.

I ran them for a while. Here’s what hurt and what actually works.

Cheap YES Lottery

Buy YES at 0.1–2¢ in narrow or extreme buckets where your model shows a small edge, then size up. One hit pays 50–5000x, enough to cover a long losing streak.

The most promising line. Capital-efficient: little money covers 20–30 cities at once. Ants moving house.

But win rate is brutal — dozens of losers in a row is normal. Forecast models update slowly; you often trade on stale data and the edge evaporates. Low-price buckets are illiquid — you can’t stop out mid-flight, you hold to settlement.

Expensive NO Grind

The idea: buy NO at 80–99¢ in extreme buckets, near-certain small profit.

You simply can’t buy it. It shows 85¢, you lift and slippage takes you to 99¢ — no one sells a near-certain winner cheap. Edge rounds to zero, capital efficiency dies. Abandoned.

Forecast vs. Market Edge

Compare professional forecasts — JMA, ECMWF, AccuWeather — against the market’s implied probabilities. Only fire when mispricing exceeds 5–8%, buying 5–30¢ mid-to-cheap buckets.

Painful in practice.

Forecasts lag. JMA and ECMWF refresh far slower than the market; by the time you get the latest run, the price has been arbed away. The market gets more efficient every week — bots and real-time data shops abound, and manually beating them on speed is a losing game.

Scanning 20+ cities by hand, comparing, deciding, executing — one to two hours gone. Fatiguing. Emotion creeps in, and after missing a few edges you start revenge-trading.

One person caps at 10–20 concurrent positions. With dozens of weather markets running daily, you bleed opportunity.

Doing edge-hunting by hand is racing pro automation on foot. Not how small capital survives.

Open-Source Starting Points

A few repos I found useful when exploring automation:

suislanchez/polymarket-kalshi-weather-bot: dual-platform, 31-member GFS ensemble, scans every 5 minutes
alteregoeth-ai/weatherbot: Polymarket-focused, 20+ cities, Kelly + EV filter, simulation mode
yangyuan-zhen/PolyWeather: web dashboard + Telegram alerts

And on Twitter, @AlterEgo_eth, @0xMovez, @woody_research share solid live data and code notes.

Risk Management

Manual or automated, rule one for small accounts: don’t donate the bankroll.

Model Orchestration

Mon, 13 Apr 2026 00:00:00 GMT

Max Tokens, Max Thinking

Just bought ChatGPT Pro at $200/month — felt like I had to max it out to get my money’s worth. Plus everyone knows gpt-5.4 xhigh is the strongest coding model. So I cranked everything to max. More thinking must be better, right?

What Broke

After a stretch at high intensity — 500M tokens a day, 2–4 windows, each with 0–3 subagents — the cracks showed.

Slow. xhigh is genuinely stronger, but it’s also genuinely slow. For everyday coding, the idea has already gone cold while the model is still deep in thought.

Premature optimization. Most obvious in glue code: it invents compatibility for legacy logic you don’t need, and plans for contingencies that aren’t on the roadmap. Progress drags, code doesn’t get better.

Wait forever, get a worse result.

Thinking via OMO

I’d brushed past oh-my-opencode before without getting why model orchestration matters.

The point of subagents isn’t more thinking — it’s division of labor. Right agent for the right job.

OMO lets you assign different models to different roles:

Role	Responsibility	Model
Sisyphus	overall coordination, task breakdown	gpt-5.4 high
Hephaestus	hands-on coding	gpt-5.4 high
Oracle	architecture decisions	gpt-5.4 high
Explore	fast codebase search	gpt-5.4-mini-fast medium
Prometheus + Metis	upfront planning	gpt-5.4-mini-fast high
Momus	rigorous review, nitpicking	gpt-5.4 xhigh
visual-engineering	frontend visuals	gemini-3.1-flash-lite-preview high
Librarian	knowledge retrieval	gpt-5.4-mini-fast high
Atlas	deploy & ops	gpt-5.4-mini-fast high

Simple logic: reserve xhigh only where deep thinking matters.

Momus on xhigh: review demands depth.
ultrabrain on xhigh: architecture planning demands depth.
Execution, search, everyday tasks drop to high or medium.

Speed returns, flow stays intact. And where depth is needed, it’s still deep.

Linear vs Compounding

Sat, 28 Mar 2026 10:00:00 GMT

Many read Sam Altman’s How To Be Successful as motivational fluff with a dozen bullet points.

Filter out the filler, and only two core ideas remain.

Never Trade Your Life for Linear Growth

The first filter for any pursuit is whether it compounds.

Ask what separates someone 10 years in from someone 2 years in. If it is just 20% more efficiency, it is a linear career. Don’t get stuck there.

Linear work sells time by the hour, capped at 24 hours in a day.

Real leverage comes in four forms: code, capital, brand, and network effects. Code runs for millions while you sleep; equity rides market tides. Without leverage, hard work just makes you a hamster running faster on a wheel.

Every Role Is Sales

Many technical people hold a quiet snobbery: build it and they will come, looking down on marketing and sales.

Reality crushes that fantasy.

Products must be sold to users, ideas sold to teammates, and vision sold to investors. If you can’t bring yourself to sell what you built, you don’t actually believe in it yourself.

Engineering is just execution; distribution is the only bridge that turns value into reality.

Mental Operating System

Fri, 20 Mar 2026 00:00:00 GMT

There are countless frameworks out there, but only two are worth using as an OS foundation.

First Principles: Stop Copying Homework

First principles has been hyped into mythology, but the core is simple: reject analogy.

Looking at how others do it or what “best practice” dictates is just copying homework. It feels fast, but when they step into a trap, you follow right behind.

Strip an issue down to bare physical facts, then build upward from zero. It takes longer, but the conclusion belongs to you, and when something breaks, you know exactly which brick came loose.

KISS: Beware Intellectual Vanity

Everyone quotes KISS, yet few actually practice it.

Engineers have intellectual vanity. Writing a tiny tool and wrapping it in three layers of design patterns, or building a personal blog on microservices and Kubernetes. That complexity never serves users; it just strokes the developer’s ego.

Complex systems create exponentially more surface area for bugs and maintenance headaches.

If a shell script works, don’t build a project. If SQLite handles the load, don’t spin up a distributed cluster. Deleting code feels better than writing it, and only simple things survive reality.

We Bought a Coin and Never Worked Again

Thu, 05 Mar 2026 16:00:00 GMT

There’s a meme coin called NEET. Its slogan: “We bought a coin and never worked again.”

Line one of the whitepaper: no intrinsic value or expectation of financial return.

Community mantras: “Reject the wagie cage” and “DO NOTHING. GET PAID.”

Inside lives a cohort called NEET Contractors — people who quit work and try to live off crypto gains. Some got rekt, some are still hanging on, some truly never went back.

It’s a meme. But some memes spread because they say out loud what many have wanted to say and never dared:

“We bought a coin and never worked again” — absurd? Absolutely. But on second thought, maybe not so absurd at all.

Clash Fake IP Breaks TLS Handshake

Sun, 18 Jan 2026 00:00:00 GMT

Installing an AUR package with paru failed with TLS connect error: error:0A000126:SSL routines::unexpected eof while reading — even with TUN and global proxy on. Turned out to be Clash’s Fake IP.

How I Found It

First, confirm the proxy itself is fine:

curl ipinfo.io
# US IP — proxy works

Then check DNS, and the culprit shows up:

nslookup dl.google.com
# Address: 198.18.0.15  ← Fake IP

198.18.0.0/16 is Clash’s Fake-IP range. Inspect the handshake with curl -v:

curl -v https://dl.google.com/linux/chrome/deb/pool/main/g/google-chrome-canary/google-chrome-canary_146.0.7637.0-1_amd64.deb -o /tmp/test.deb
# * Trying 198.18.0.15:443...
# * TLSv1.3 (OUT), TLS handshake, Client hello (1):
# * TLS connect error: error:0A000126:SSL routines::unexpected eof while reading

After resolving to a Fake IP, Mihomo (Clash Meta) should transparently proxy to the real server, but its handling of TLS handshakes for certain domains under Fake-IP has compatibility issues — likely SNI-related. Google’s CDN sees a malformed handshake and drops the connection.

Fix

The cleanest fix is to exclude dl.google.com from Fake IP. Add a fake-ip-filter to your Clash config (~/.config/clash/config.yaml or ~/.config/mihomo/config.yaml):

dns:
  fake-ip-filter:
    - "dl.google.com"
    - "*.dl.google.com"

Restart Clash and it will resolve with the real IP — handshake succeeds.

If you don’t want to touch the config, downloading the .deb in a browser also works. Browsers use a different TLS stack and don’t hit this bug:

cd ~/Downloads
ar x google-chrome-canary_*.deb
tar xf data.tar.xz
sudo cp -r opt/google/chrome-canary /opt/
sudo cp -r usr/* /usr/

Fixing npm Global Install Permission Errors

Thu, 11 Dec 2025 00:00:00 GMT

npm install -g throws EACCES: permission denied because npm tries to write global packages to system directories like /usr/lib/node_modules, where a normal user has no write access.

It looks like this:

npm error code EACCES
npm error syscall rename
npm error path /usr/lib/node_modules/npm/node_modules/env-paths
npm error errno -13
npm error Error: EACCES: permission denied

Don’t brute-force it with sudo — that just chowns a bunch of files to root and makes things worse. Move the global prefix into your home directory instead:

mkdir ~/.npm-global
npm config set prefix '~/.npm-global'

Then add its bin to your PATH in your shell config (~/.bashrc for bash, ~/.zshrc for zsh):

export PATH=~/.npm-global/bin:$PATH

Source it, and npm install -g works without sudo:

source ~/.bashrc
npm install -g @musistudio/claude-code-router

Fixing IME on Wayland

Sat, 30 Aug 2025 00:00:00 GMT

On Wayland, typing Chinese fast in Electron apps (like Cherry Studio) scrambles the characters — they shuffle and reorder. Type slowly and it’s fine. Happens across multiple Electron apps, so it’s clearly Electron’s input path on Wayland/XWayland, not the IME itself.

Others hit the same issue: Cherry Studio #104

Fix

Enable native Wayland IME and Ozone for Electron. Edit ~/.config/electron-flags.conf:

--enable-wayland-ime
--ozone-platform-hint=auto
--ozone-platform=wayland
--enable-features=UseOzonePlatform,WaylandWindowDecorations

Save, then fully quit the target app and reopen (not just close the window — kill the process). Most Electron apps read this file automatically and switch to the native input path. The scrambling stops.

Two gotchas:

If the app still runs as XWayland, check its launcher for a forced --ozone-platform=x11 and remove it
Works for both Fcitx5 and IBus, on Hyprland, Sway, or KDE Wayland

Fixing the Web3 "Replacement Transaction Underpriced" Error

Sat, 25 Jan 2025 00:00:00 GMT

Binance Web3 Wallet throws replacement transaction underpriced.

Ethereum lets you replace a pending transaction with a new one using the same nonce, but the new gas price must be at least 10% higher — otherwise nodes reject it outright. So this error almost always means one thing: you didn’t bump gas enough to override the previous tx.

Options:

Bump gas by 10%+ and resubmit
Wait for the pending tx to confirm if you’re not in a hurry
To cancel a stuck tx: send a 0 ETH self-transfer with the same nonce and a higher gas price — an empty tx that squeezes out the old one

Removing pycache from Git

Sat, 18 Jan 2025 00:00:00 GMT

__pycache__ is Python’s bytecode cache (those .pyc files). It doesn’t belong in Git.

Ignore it first. Add to .gitignore:

**/__pycache__/

If you’ve already committed it, remove it from the index but keep local files:

git rm -r --cached __pycache__
git commit -m "Remove __pycache__ from version control"
git push

That stops tracking going forward. But if it’s deep in history, it still lives there. To purge history, rewrite it with BFG Repo-Cleaner (on Arch: yay -S bfg-repo-cleaner, otherwise grab the jar from the releases page):

bfg --delete-folders '__pycache__' --no-blob-protection
git reflog expire --expire=now --all
git gc --prune=now --aggressive
git push --force

--force rewrites remote history. If others collaborate on the repo, warn them first — don’t nuke their branches.

Hard Truths About Trading

Fri, 29 Nov 2024 00:00:00 GMT

Textbooks talk about position sizing, moving averages, and sentiment cycles. It all makes sense until real money is on the line.

Win Rate Is a Trap

Beginners obsess over high win rates.

An 80% win rate sounds great, but in reality you take ten small wins and wipe them all out holding one losing bag.

Trading is never about win rate; it is about risk-to-reward. Cut mistakes at a few hundred bucks, and when you are right, have the stomach to sit tight and let profits run.

Position Size Controls Your Brain

Forget indicators. Once size gets too big, psychology falls apart.

With heavy leverage, a tiny 5-minute wick spikes your heart rate to 120. In that state, rational thinking is gone, replaced entirely by prayer and panic.

Risk only fixed capital per trade. Withdraw profits, never double down to revenge-trade. If a zero on this position won’t ruin your sleep, your size is right.

Most Time Is Garbage Time

Real trending moves happen across maybe two months out of a whole year.

The other ten months are choppy, boring ranges designed to grind your mental capital down.

Trading out of boredom just feeds fees to the exchange. Closing charts and playing games beats any technical analysis during flat markets.

The Enemy of Stop-Losses Is Hope

The second price breaks your stop level, the first thought that pops into your head is always: maybe the next candle bounces.

That hope kills accounts every single time.

Even if it bounces, it is no longer your trade. When the stop triggers, cut it immediately without hesitation.

Neovim Clipboard on Wayland

Thu, 14 Nov 2024 00:00:00 GMT

You d-delete a block in Neovim, then try to paste what you yanked earlier — but what comes out is what you just deleted.

At first I thought Neovim wasn’t talking to wl-clipboard:

vim.opt.clipboard = "unnamedplus"

That wasn’t it. unnamedplus syncs every d to the system clipboard, so the delete overwrites what you had yanked.

Vim’s logic is: delete is cut — deleted text goes to a register by default. To make d delete without yanking, route it to the black-hole register _ in ~/.config/nvim/init.lua:

vim.api.nvim_set_keymap('n', 'd', '"_d', { noremap = true })
vim.api.nvim_set_keymap('n', 'D', '"_D', { noremap = true })
vim.api.nvim_set_keymap('n', 'dd', '"_dd', { noremap = true })

Python OCR Automation on Hyprland

Wed, 16 Oct 2024 00:00:00 GMT

Couldn’t find an OCR tool I liked on Hyprland, so I wrote one.

You need four pieces: Tesseract (OCR engine), Grim (Wayland screenshots), Slurp (region selection), and wl-clipboard (clipboard).

sudo pacman -S tesseract grim slurp wl-clipboard

Three steps: Slurp selects a region for Grim to capture, Tesseract reads it, result goes to the clipboard:

#!/bin/bash
grim -g "$(slurp)" /tmp/screenshot.png
tesseract /tmp/screenshot.png - -l chi_sim+eng | wl-copy
rm /tmp/screenshot.png

-l chi_sim+eng does Chinese + English. Swap in whatever language packs you need.

Save it somewhere on your PATH and make it executable:

chmod +x ocr_screenshot.sh
sudo mv ocr_screenshot.sh /usr/local/bin/

Bind it in ~/.config/hypr/hyprland.conf — Super+O to OCR anything on screen:

bind = SUPER, O, exec, ocr_screenshot.sh

ENS Is an Identity, Not a Speculation Tool

Fri, 02 Aug 2024 00:00:00 GMT

Most people who hoarded 3-digit and 4-digit ENS domains during the hype are now holding bags, reluctant to even pay annual renewal fees.

It Is an Identity, Not an Investment

The real value of ENS is never secondary market flips. It is turning unreadable 0x hex addresses into human language.

Sending funds without verifying the first and last four characters, immune to clipboard hijacker malware, is where the utility actually lives.

Practical Takeaways

Register for 5 to 10 years upfront: domain fees are predictable, but mainnet gas spikes hurt. Renewing yearly just bleeds fees to validators; locking a long window is far cheaper
Always set the Primary Name: without reverse resolution, dApps and wallets still show a garbled hex string, rendering the purchase useless
Don’t overcomplicate site hosting: mapping IPFS static sites to ENS sounds cool, but public gateways load painfully slow. A basic redirect or simple profile page is plenty

Neovim Search and Replace

Sat, 22 Jun 2024 00:00:00 GMT

Batch replace across multiple files — load them with :args, then run :argdo:

:args file1.txt file2.txt file3.txt
:argdo %s/pattern/replacement/g

If that’s too much ceremony, use nvim-spectre. Visual search and replace — you see exactly what will change, at a glance.

Minimalism

Tue, 24 Oct 2023 00:00:00 GMT

Minimalism isn’t a contest of who throws away more. First figure out what truly matters to you — the rest becomes easy to let go.

Once you’ve subtracted, what remains is what you actually care about.

The Essence of Text

Tue, 24 Oct 2023 00:00:00 GMT

The early internet looked like this: a black screen, a blinking cursor, and nothing but text.

This blog is the same — no thumbnails, no sidebar, just text and you.

Images feed you the picture directly. Text forces you to build it in your head. That participation is something no high-res image can replace. As a bonus, pure-text pages load absurdly fast — even the oldest device handles them fine.

Web Design Means Getting Out of the Way

Tue, 24 Oct 2023 00:00:00 GMT

Modern websites have become bloated beyond reason.

Click into a tech blog and you are greeted by a 5MB JavaScript bundle, a cookie consent banner, a newsletter modal, and a slick entry transition.

Your phone heats up before you even see the first paragraph.

The Best UI Doesn’t Compete for Attention

The purpose of a website is carrying information, not acting as a developer’s animation playground.

Brutalism and HTML-first aesthetics are returning because people are exhausted by decorative clutter.

Clear typographic hierarchy, decent line height, high contrast, and clean HTML do 90% of the design work.

Doing Less Beats Doing More

Ditch the crowded sidebar, ditch the floating widgets, ditch the skeleton screens built just to show off.

Instant load, readable text, close the tab when done.

Hitting those three basics puts a site ahead of almost everything modern frontend culture churns out.

Xeron

Trading Is a Practice

Robinhood Is Plugging Stocks Into the Casino

Stocks just became the underlying for memes

This is not a small experiment anymore

What actually matters is the on-ramp changed

Why this meta is more interesting than animal memes

Crazier still: memes are now feeding back into stock tokens

What Robinhood looks like now

What I’m watching next

Closing

My Kitty + DMS Theme and Font

Font: Maple Mono NF CN

Theme: Tokyo Night

Skills I Use

Just a Tool

The Funny Debate About Tools Themselves

What AI Is

AI Is Your Anywhere Door

Reverse-Engineering Coinglass's Encrypted API

Encryption Scheme

Key Constants

How It Was Reversed

Implementation

Scale

Disclaimer

MiMo Code Free Model Proxy

Reverse-Engineering the Auth

Device Fingerprint

Parsing the JWT

Concurrency Safety

Request Forwarding

Body Rewriting

Retry on Expiry

Streaming Passthrough

Pi Toolchain

Extensions

MCPs

Tacit Knowledge

Longer Style Guides, Worse Code

Prompting by Rules Is a Dead End

Polymarket Weather Markets — Field Notes

Cheap YES Lottery

Expensive NO Grind

Forecast vs. Market Edge

Open-Source Starting Points

Risk Management

Model Orchestration

Max Tokens, Max Thinking

What Broke

Thinking via OMO

Linear vs Compounding

Never Trade Your Life for Linear Growth

Every Role Is Sales

Mental Operating System

First Principles: Stop Copying Homework

KISS: Beware Intellectual Vanity

We Bought a Coin and Never Worked Again

Clash Fake IP Breaks TLS Handshake

How I Found It

Fix

Fixing npm Global Install Permission Errors

Fixing IME on Wayland

Fix

Fixing the Web3 "Replacement Transaction Underpriced" Error

Removing __pycache__ from Git

Hard Truths About Trading

Win Rate Is a Trap

Position Size Controls Your Brain

Most Time Is Garbage Time

The Enemy of Stop-Losses Is Hope

Neovim Clipboard on Wayland

Python OCR Automation on Hyprland

ENS Is an Identity, Not a Speculation Tool

It Is an Identity, Not an Investment

Practical Takeaways

Neovim Search and Replace

Minimalism

The Essence of Text

Web Design Means Getting Out of the Way

Removing pycache from Git