Hongjiang Bao's Blog

Standing in 2026 — The Next Stage of How I Use AI

Thu, 23 Apr 2026 00:00:00 +0000

Foreword

Around this time last year I wrote Standing in 2025 — Looking Back at AI, and Looking Forward. My take back then was: AI is an amplifier — own the framework, hand the details to AI.

A year on, that conclusion isn’t wrong. It’s just no longer enough.

Because “have AI handle the details” has itself splintered into multiple wildly different layers. The productivity gap between people stuck on different layers is widening fast.

And I’ve personally hit a new bottleneck. This post is me writing down how I see that bottleneck and what I think the next stage is.

My five stages of using AI

A quick recap of how my own usage has evolved:

Stage	Form	Representative	What I do
L1	Web chat	ChatGPT web	Paste question in, paste answer out
L2	IDE plugin	GitHub Copilot	AI completes alongside me; I’m in the driver’s seat
L3	AI-native IDE	Cursor	AI edits multiple files; I review
L4	Terminal-native agent	Claude Code	AI can touch my whole machine; I confirm via dialogue
L5	?	?	?

The throughline is one thing: AI’s operating boundary keeps expanding, and humans are progressively freed from layer after layer of concrete operation.

Each leap is an order-of-magnitude jump.

The bottleneck: top experts can’t get enough out of three Max 20x’s; I can’t even use up one Pro

I just bought Claude’s Max 5x. The result: I can’t even fully use it.

Meanwhile, some top developers publicly say they can’t get enough capacity out of running three Max 20x accounts at the same time.

That contrast made me stop and think — same tools, why can they burn through ten times the compute? Experts this strong, even they don’t have enough? Where’s the actual gap? How do I close it?

Thinking it through, the answer is clear:

I’m the bottleneck.

For every task I’m still going back and forth with Claude Code:

“Search for related code first before changing anything”
“That approach isn’t right, try a different angle”
“Run the tests first”
“Confirm before committing”

I’m running 3–5 Agents in parallel and my brain is already taxed. Human context-switching has a cost. Tops, you can manage 5–7.

It’s a strange feeling — I’m holding a rocket but I’m still shifting gears one at a time.

The next stage: from “operator” to “legislator”

How do you break this bottleneck?

After working through Anthropic’s public docs, the workflow notes from Boris Cherny (the creator of Claude Code), and a bunch of heavy-user practices, my conclusion is:

The next stage isn’t “manage more Agents.” It’s that you stop personally managing Agents at all.

That sounds abstract, but unpack it and it’s very concrete:

	L4 (where I am)	L5 (next stage)
Am I in the loop?	Yes	No
What do I do?	Talk, confirm, correct	Write rules, define acceptance, arbitrate
When does AI stop?	When I say stop	When the rule says it’s done
If I leave the keyboard for 8 hours	The system halts, waiting for me	The system has been making progress for 8 hours

The single test for L5: when you walk away from the keyboard for 8 hours and come back, has the system stopped waiting for you, or has it already finished its run?

In L5, the focus of your work fundamentally changes:

Write specs, not prompts
Define acceptance criteria (tests, lint, human-review checkpoints), don’t review every step
Design hooks and guardrails, not confirmation buttons
Build a feedback loop (failures auto-feed back to the AI to keep iterating), don’t manually retry

You open your laptop in the morning, and what you see is no longer “Claude is waiting on me to approve something.” It’s: “Out of last night’s 12 PRs, 9 already passed automated acceptance, 3 are flagged red for me to judge.”

The only thing you do: look at those 3 reds, and patch the rule that let them turn red.

I’m already crawling toward it: what L4.5 actually feels like

L5 sounds far off, but my L4 has actually been transitioning into L4.5.

The feeling is already different. Claude Code can run remotely, run in the background; I’m not staring at every line it writes. Most of my day is spent looking at the reports it hands me, then doing a few things:

Judge whether the direction is right
Decide: keep going, switch approach, or send it back to redo
Make calls and decisions at key checkpoints
Handle whatever it can’t crack and gets stuck on

Honestly, I’m now more like a remote-control manager than a programmer.

I didn’t write the code, but I set the direction, I drew the boundaries, I judged the quality. It’s a strange state — the rhythm has changed completely. I get a noticeably larger amount done in a day, but every individual decision carries far more weight. One bad direction can torch hours of downstream output.

This still isn’t L5. L5 is when even the “look at the reports” step is partly handed off — the rules auto-filter 80% of the content, and I only look at the remaining 20%. But this transition state, L4.5, is already enough to make me feel it: managing AI feels nothing like writing code yourself. They are two completely different jobs.

The productivity gap is widening

This is the thing I most want to call out: the productivity gap between people stuck on different stages is widening at an order-of-magnitude rate.

L1 people use AI to answer questions and look stuff up. Limited gains, but real.
L2 / L3 people fold AI into their code-editing flow. Multiple times more efficient than L1.
L4 people get AI to run and complete a whole task autonomously. Multiple times more efficient again.
L5 people have a dozen tasks running in parallel and only do arbitration and legislation. Another order of magnitude on top.

The thresholds between these layers aren’t linear. L1 → L2 is easy: install a plugin. L4 → L5 is very hard — it requires you to redesign the entire shape of your work. You stop being “the person using the tool” and become “the person designing the rules for using the tool.”

What it asks of you: both knowledge density and total knowledge

Here’s the most counter-intuitive part.

A lot of people assume the AI era lowers the bar — “AI handles details, I just need a sketch.”

Wrong. The exact opposite.

The AI era raises the bar — and on two axes at once:

Total knowledge — you need to know more. Judging direction, drawing boundaries, arbitrating: every one of those decisions stands on actually understanding the domain. If you only know a tech stack at a surface level, you literally cannot tell that the code AI wrote is bad.

Knowledge density — your judgments per unit time must be higher and sharper. In L5, your day looks like:

10 minutes reading a PR summary, decide whether to merge
5 minutes reading a failure report, decide whether to fix code or fix the rule
20 minutes writing a spec that defines a feature’s acceptance edges
30 minutes reviewing a new rule, judging whether it’ll friendly-fire other tasks

Every action is a decision; nothing is “execution.”

In less time you have to make more decisions, more accurately: see at a glance where the AI will derail; while writing the spec, predict where the boundary will explode; the moment you see a new rule, know what it’ll friendly-fire.

These are exactly the abilities AI cannot replace. Because at their core they’re experience + taste + judgment, not information processing.

My read: second half of this year through the first half of next year, the first genuinely native L5 product will land — possibly Anthropic itself, possibly a third party on top of the Claude API. By that point, the gap between people will be wider still.

Standing in 2025 — Looking Back at AI, and Looking Forward

Wed, 12 Mar 2025 00:00:00 +0000

Foreword: It’s now 2025, and AI is white-hot. In this post I want to share my personal take on AI — what I understand, what I expect, and how it’s helping my career and life.

Looking at the present from the past, and predicting the future from now.

An article from January 2015 that predicted today’s AI

On January 27, 2015, an article was published that completely upended my view of AI. Here’s the (Chinese-translated) link: Artificial Intelligence may very well lead to humanity’s immortality or extinction — and it’s quite possible all of this will happen within our lifetimes (in Chinese) If you’re interested, please read the whole thing! I strongly recommend it! In this post I’ll just lift two of its conclusions:

Human technological progress is exponential!
AI’s growth could leap past human cognition in an instant!

At the time, most people would have called this nonsense. After all, in January 2015 OpenAI didn’t even exist. Look at the timeline:

1
2
3
4
5
6
7
8


2015 — OpenAI founded, focused on AGI.
2016 — AlphaGo beats Lee Sedol; AI surpasses humans at Go.
2017 — Transformers (Google) ignite the NLP revolution and become the foundation for GPT, BERT, etc.
2019 — GPT-2 (OpenAI) released, showing strong text generation.
2020 — GPT-3 (175B parameters) released, kicking off the AIGC craze.
2022 — ChatGPT (GPT-3.5) released and instantly explodes.
2023 — GPT-4 released, far more capable, multimodal (text + images).
2023 onward — AI products everywhere.

If you read that article, you should be a little stunned right now. Its predictions are almost spot on — incredibly forward-looking! Ten years ago, when the internet had only just gone mainstream and most people had only just gotten a smartphone, the author already predicted, accurately, where AI would be a decade later. Once again, I strongly recommend everyone who hasn’t read it go read it.

History has confirmed the article’s accuracy. So let’s see what that 2015 article predicted for after 2025. The article splits AI into three stages: Artificial Narrow Intelligence (ANI), Artificial General Intelligence (AGI), and Artificial Super Intelligence (ASI). I think we’d all agree that as humans, we’ve now reached AGI.

My personal take:

The moment ASI arrives, its intelligence will, in an instant, dwarf the sum of all human intelligence — growing at unbelievable, absurd exponential rates. Humanity is therefore extinguished, or made immortal.
The most optimistic estimate: ASI in 2030. Conservative: 2050. Pessimistic: 2080, or never.

All of today’s AI is essentially modeled on the human brain. Look at this from a compute angle:

1
2


As of 2024, the world's fastest supercomputer (e.g. Frontier) has reached 1.2 EFLOPS (1.2 × 10¹⁸ FLOPS).
Because the human brain doesn't run like a computer, direct comparisons are hard, but typical estimates put it at 1 EFLOPS to 100 EFLOPS (10¹⁸ to 10²⁰ FLOPS).

You can see, today’s strongest compute is approaching the brain. I’ve always believed: when computer compute exceeds the brain, intelligence will get very close to the brain too. And right now something like o3 (whose compute is still nowhere near a brain) is already far past the vast majority of humans. So what about the future? What happens as compute keeps growing?

In short: I think AI intelligence will continue to compound exponentially, just as that article predicted, possibly all the way to AGI and beyond.

An article I wrote in December 2023 about how I understand and use AI

Back in the GPT-3 era I’d already started using AI heavily. GPT-4’s arrival especially gave my technical chops, vision, and thinking a quantum leap. Original: How I Use AI — Notes from the Field Now, with even more, even stronger AI products around, my hands-on ability has grown massively, and I’m even more convinced that what I wrote then was correct. That’s exactly what the next section is about.

How AI completely flips the way I solve problems and think about them.

Let me re-quote my own conclusion: Human life is finite. We can’t master that much knowledge or that many skills. AI overturns the traditional learn-then-execute pipeline: master the framework, leave the details to AI, and your efficiency and ceiling go way up.

Some specific points:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


### AI completely changes how we learn knowledge and master skills
The traditional model demands you internalize a full system; AI fills in the specific details and dramatically speeds up learning.
You only need to grasp the "trunks" of the knowledge tree; AI fills in the "leaves."

### AI accelerates execution — going from learning to shipping is way faster
Projects that previously required full mastery before you could start can now be moved forward as long as you know it's broadly feasible — AI handles the rest.
Examples: building a blog, an AI WeChat public account, an AI chat website — all started as a concept, then AI fleshed out the details and got it shipped.

### AI is an efficient executor, but the ceiling is still set by you
AI helps with problems that already have mature solutions, but on frontier exploratory problems it still struggles.
Your own ability and depth of thought decide the final outcome — AI is just an amplifier.

### Practice is everything; the best way to use AI is "do it with your hands"
Real growth comes from actually doing it. The tricks come naturally as you go.
"Use it if you can, just dive in" — far more important than talking about technique.

For me personally, AI now touches 80%+ of what I do, work and dev included. DeepSeek R1’s reasoning ability can attack a problem from every angle. Its breadth and knowledge far exceed mine. If one day I genuinely learn that kind of structured thinking, I can’t even imagine the result. As I said: practice is everything. Use it deeply, you’ll get it. Without using it, talk is moonlight on water — useless.

Roundup of AI products as of today

As of writing, March 12, 2025, here’s my summary of the popular AIs out there, including ones I’ve personally used. Their characteristics, pros and cons. Includes more than just LLMs. For your reference:

LLMs
- GPT family
  - o3, o1 — currently the strongest and the most expensive reasoning models. Massive context (o1 = 200K), the strongest reasoning and logic right now. Especially good at code analysis and logic. I only call this big brother in when its little siblings can’t solve a problem.
  - o1-mini, o3-mini, o3-mini-high — mini versions with better speed and price/performance trade-offs. For hard code problems, I usually try them first.
  - 4o — the multimodal one. Well-rounded, fast. Reads images directly, parses audio. Speed and price are excellent. My most-used model right now.
  - 4.5 — newest GPT, way better creativity and “humanness,” but seriously expensive. I save it for creative work and copy.
  - Other GPT models — all weaker siblings; the only upside is a slightly cheaper price. Not worth discussing.
- DeepSeek family
  - R1 — currently the strongest Chinese-language reasoning model and a price/performance monster. You’ve all seen how strong it is. Cheap, especially good at very Chinese-flavored reasoning problems. Heads up: its coding ability is weaker than other models — really, don’t use it for code. I use it for problems with strong Chinese-language texture. Very grounded.
  - V3 — non-reasoning version. I rarely use it.
  - Other parameter sizes — DeepSeek’s strength is hitting GPT-4o-class performance with the lowest compute and hardware. A lot of websites sneakily pass off 32B / 70B versions as the full 671B. I’m calling it out because R1 32B 4-bit quantized is the best model you can run locally on a 4090 24G consumer GPU. From experience, useful for things involving confidentiality.
- Claude family
  - Claude 3.7 — multiple variants; the everyday one is Sonnet. Currently the second-best after GPT. Very humane to use; many heavy users say its coding ability beats GPT-4o. Great UX — they pioneered Canvas, and GitHub Copilot put it in their membership, which says a lot about its code price/performance. I use it to cross-check GPT’s code.
- Grok family
  - Grok 3 — Musk’s AI. Reportedly uses the most reasoning compute of anyone right now. In code it doesn’t have an obvious edge over the others. Worth noting: its content moderation is extremely loose.
- Gemini family
  - Gemini 2.0 — Google’s. Thanks to Google’s infrastructure muscle, very fast. Natively multimodal. Search ability clearly beats other models. (Of course — Google!) I don’t use it much; intelligence-wise it’s not clearly ahead.
- Other / local models
  - On Hugging Face there’s a flood of models, plus QwQ from China and others — each with their own strengths. Most are smaller, specialized for a specific domain. With limited bandwidth, I generally don’t bother.
- Manus
  - From all the noise, this is hype and a scam. Once people actually use it, we’ll see if it’s gold.
AI image generation
- Stable Diffusion — the famous SD. Open source, deeply customizable. Different base models = different styles. Tons of plugins. Easy to deploy and run on a home PC. Downsides: output is fully tied to the base model, and the learning curve is steep.
- Midjourney — also famous (MJ). Very strong, only available as a service. Wide range of styles. Downsides: little customization, expensive. The polar opposite of SD.
- DALL·E 3 — way behind the above two. The only upside is integration into the native ChatGPT web. Not really useful.
TTS (text-to-speech)
- VITS family
  - VITS was originally released by a Chinese developer; lots of forks and downstream work. Currently the strongest open-source one is GPT-SoVITS. With just a few minutes of source audio, it can produce highly similar multilingual speech. A home PC is enough to fine-tune and infer. Some “do it with your hands” results from me: Inferred version of my own voice WW2 commentary, original voice WW2 commentary, AI-synthesized
- Other vendors — Microsoft TTS, Google TTS, Douyin, all closed-source. Custom fine-tuning is expensive; otherwise you’re stuck with their pretrained voices. That said, the out-of-the-box quality is already excellent!
STT (speech-to-text)
- Whisper — OpenAI’s open-source model, supports 100+ languages. Currently the strongest open-source STT. Runs locally on a home PC.
- Others — Microsoft, Google, iFlytek, etc., all have plenty of APIs.
Other
- Suno — AI music generation, sounds good, but practical use is still weak. Future looks promising.
- Sora — video synthesis is everywhere now, but most output looks weird. Another path is heavily customized SD with image stitching for video. Both are being explored.
Combo / tooling
- GitHub Copilot — strongly recommended. Microsoft’s flagship. Deeply integrated into IDEs, especially VS Code and Visual Studio. Free tier exists, paid is $10/month. Wraps GPT, Claude, and Gemini. Once it sees your IDE context, it’s incredibly convenient.
- Cursor — an AI-first IDE built on VS Code, neck-and-neck with Copilot. Also very convenient. But because it’s an IDE rather than a plugin, you give up some flexibility.
- Poe — an aggregator over multiple AIs; basically a wrapper frontend that calls each vendor’s API. Pros: one-stop access, some free quota. Cons: API calls usually fall short of native vendor sites in features and quality.

My personal outlook on the future of AI

I think AI has already permanently changed how I think and how I solve problems. ~~Of course, if ASI shows up and humanity gets wiped out, none of this matters. So our default assumption has to be that AI carries us up the next tech tier.~~ In this era you have to keep up, keep leveling up, keep absorbing new knowledge. The only constant in the world is change itself. After watching the inflated boom in the China market, I’ve concluded: AI on its own doesn’t generate huge value the way some prior technologies did. It only produces magic when combined with another field. Like internet dev, traditional retail, traditional manufacturing, literature & film, education, etc.

Either way, we should all think like founders. Letting AI fill in the details and do the grunt work for you is the right move. Build out your own knowledge framework, stop sweating the details. Grab the essence of the problem and the main contradiction. In the future, I’ll go even deeper with AI in everything I do. I also hope to lift my whole team’s AI fluency and improve the workflow. Here are a few practical AI deployments I’ve distilled from work — some already shipped, some that I want my team to ship later:

Code dev
- Heavy use of GitHub Copilot to dramatically speed up coding and to auto-catch errors. Especially good for structured code. For unfamiliar libraries and APIs, it’s totally possible to be in a state of “I don’t remember it, but somehow I can use it” / “I haven’t read the docs, but once I get the framework I can write code right away.”
- Use git hooks to AI-review every commit. Keeps quality up and obvious mistakes out.
- Standardize project layout. Use the tree command (Windows) plus AI to keep directory structure clean.
- Reasoning about new requirements. When you face something you’ve never built, your first plan often misses corners. Ask AI to analyze: what’s the solution path, what should you watch for?
Game design / config
- Use AI to name variables. Few people pull off “faithful, expressive, elegant” naming. Things get confusing fast — AI helps a lot.
- Use AI for localization, even one-click scripts. High-quality, low-cost passable multi-language.
- Use AI for Excel formulas and number-crunching. Heavy Excel formulas are insane — just ask AI.
- Use AI to debug error messages. Designers usually aren’t from a code background and are stumped by errors. Paste the error, ask AI; most of the time you get something actionable. (This applies to anyone touching a project!)
- Use AI to write designer-side tools. Spot pain points in your own task and quickly write a tool to remove them.
- Idea collection. AI can quickly throw out a lot of ideas; you still have to filter and synthesize.
Art
- Reference and inspiration. Set up SD and Midjourney pipelines. Anything you can’t Google up in the right “vibe,” ask AI to draw. Quickly confirm direction with the requesting team. Build a curated prompt library by style — you can rapidly produce on-brief mockups, and unimportant cutscenes / scene art can ship as-is.
- Item icons, character concept art — already shipped successfully in the past. Tons of icons, even character concepts. AI does the first pass, art polishes — huge efficiency gain.
Other
- Voiceover. If you need it, GPT-SoVITS does customized VO well.

Two reference videos for understanding AI’s origins: 【Computer History】 NLP from “Past” to “Present” Why the Feynman Technique is called the ultimate learning method

Palworld Co-op Guide for the Pirated Build

Tue, 30 Jan 2024 00:00:00 +0000

Palworld is hot right now, so of course me and my friends had to jump in.

Disclaimer

I’ve always supported genuine copies — I have an Xbox Game Pass subscription so I can play Palworld for free, and I own close to a thousand games across Steam, Epic, etc. It’s just that some of my friends haven’t tried it, and with mortgages and car loans they’re frugal. I’ll get them on the train first; later I’ll talk them into actually paying for a copy.

When you do something, the most important thing is knowing whether it can actually work. Let me just tell you up front: The pirated build of Palworld can absolutely be played in co-op. No issues at all.

Step 1: Download the pirated build of Palworld and install the co-op patch

Figure this out yourself; if you can’t get past this you can stop reading — even reading on, you wouldn’t be able to follow. For the co-op patch, set it to LAN co-op mode.

Step 2: On the host, install steamCmd, download the Palworld dedicated server files, and bring up the server.

Official server-hosting guide Follow the guide to install steamcmd, download the Palworld server files, and start the server. After it’s up, you’ll see a string of English output showing the AppID.

Step 3: Co-op and acceleration

If you’re hosting on a cloud server, you can skip the steps below — just open port 8211 in the cloud security group.

Option 1: Port-forwarding so other players can reach the host directly. Only works if you have a public IP. Configure port forwarding for port 8211 on your router and modem.

Option 2: LAN acceleration (recommended) LAN acceleration deploy Use a virtual LAN to play and accelerate. Because the relay server is right next door, latency drops to under 20ms. When connecting, use the LAN IP.

Those are the core steps. If you don’t want to mess around, just buy the game.

How I Use AI — Notes from the Field

Tue, 26 Dec 2023 00:00:00 +0000

GPT — the greatest invention in history

Personal opinion. At least, as of right now. My programming and CS chops have leveled up massively, and I really owe that to GPT, especially GPT-4. Yes, it’s gone through many iterations and is far from where it started.

The mainstream AIs

A quick rundown of the popular conversational LLMs right now, ordered by my recommendation:

GPT-4 — strongest and most useful
Claude 2 — up to 100k context
New Bing — built on GPT-4, free to use, good for search
GPT-3.5 — cheap, mostly used for high-volume API calls
Bard — Google’s offering, so-so. Upside: free
iFlytek Spark (讯飞星火) — decent. Upside: convenient if you’re in China
Baidu ERNIE Bot (百度文心一言) — no comment
Other miscellaneous ones — with so many better options, why use junk?
Local LLMs — can be deployed locally, can be fine-tuned. Compared with using someone else’s product, you have far more creative possibilities.

In actual use, GPT-4 is the most helpful for both work and life, and the best one to use. The downsides are that registration and subscription are annoying, and $20/month is pricey. But I can tell you with full confidence: it is absolutely worth every cent. Truly insane. From here on, I’ll only talk about GPT-4. Other products aren’t worth discussing.

What GPT-4 changed for me

There are a million articles online about how amazing GPT-4 is and how to use it. I’m not going to repeat any of that. I’ll just talk about the biggest shifts for me personally.

A complete overhaul of how I learn and how I get things done

Traditionally, to write code or learn a new skill, you have to study the whole thing front-to-back, and only after enough projects, enough hitting walls, can you confidently say “yeah, I can handle this kind of problem.” The world’s knowledge is an ocean — the more you learn, the more you realize you don’t know. In one limited human life you can only ever master a tiny sliver. Especially in tech, innovation outpaces your ability to keep up. Picture all knowledge and skills as a giant tree. Each module is a trunk — say, Python is one trunk; Python’s syntax and libraries are the leaves on that trunk. Normally, to write decent Python software, you have to internalize the trunk and most of the leaves. Now here’s the problem: Python, Go, C#, Java, JS, TS, C++, etc. — that’s already a long list. Then there’s everything Linux: nginx, ufw, vim, OpenVPN, and on and on. .NET land has another whole stack. That’s before you get to algorithms, frameworks, design patterns, Docker, jump servers, and so on. With this much, even a whole life only gets you mastery of one or two. Everything else, you have to pretend you didn’t see.

Human life is finite. We can’t master that much.

GPT-4 totally upends this. It can answer questions and crank out tons of code on demand. (Of course, your professional level still caps the ceiling.)

GPT-4 massively speeds up learning, especially looking things up and debugging.
GPT-4 acts like a junior who completes the work you direct. Your own ability sets the upper bound.
Plus a huge amount of miscellaneous work.

GPT-4 is an extension of my ability — it handles the details.

To stick with the tree metaphor: I learn the trunks and the big-picture frame myself. The leaves and details, GPT-4 fills in. Walking every trunk and every leaf is too much for me. But touring all the trunks is easy. When I need a specific leaf, I tap GPT-4 to flesh it out.

Cover as many trunks as possible. When a problem hits, lean on GPT-4 for the leaves.

This completely overturns my old “learn it all first, then do it” methodology. Now, as long as I have a sense of all the trunks, I can ship something that’s theoretically possible but whose details I don’t yet know — and ship it fast.

A few examples:

Building this blog. In theory, set up a website, get a server. The details are massive — see The Tech Behind My Blog. That much technical detail, even though I’d never done it before, was tractable because I knew the trunks; the leaves I learned from GPT-4.
Building an AI WeChat public account. From an idea, starting with one official OpenAI API example, then a secondary WeChat account driven by simulated PC WeChat clicks, step by step it grew. I really was clueless at the start. Eventually it had Midjourney, Stable Diffusion, GPT-3.5/4, New Bing, voice-recognition chat, a membership system, and more. Tons of system and technical details. I knew it was theoretically doable and had a vague plan; GPT-4 filled in the rest. By the way, the account was called Xiao Hui Hen Zhi Hui (小慧很智慧). At its peak it had 4k+ subscribers. Costs got too high and I had limited bandwidth, so I stopped maintaining it.
Building an AI chat website. Started by forking an open-source vue3+express site from GitHub. Later I rewrote the backend in Python (FastAPI), with a database, account auth, etc. Eventually added WeChat Pay, SMS phone verification, and more. WeChat Pay especially is a beast — you also need an ICP-filed mainland China server and domain. But I knew it was possible, and I made it work in the end!
Building a giant LAN over OpenVPN tunnels

There are many similar cases in everyday work and life. I’ll stop listing.

GPT-4 completely flips the old “learn-it-all-then-start” model. Now, if it’s theoretically possible, I can move on it immediately and finish at terrifying speed.

Of course, for highly complex, exploratory work, both GPT-4 and I are stuck. Like research-grade new algorithms, or a distributed system that handles tens of millions of concurrent connections. But for most tasks someone has already solved before, with GPT-4 in the loop, I can do them fairly well.

As for specific tips and tricks — there’s already a flood of those online, and a few sentences won’t cover it. If you actually care, just go bang on it. If you can use it, the tricks come naturally as you go. If you can’t, no amount of talk will help.

Building a Dynamic Multi-Server LAN over OpenVPN Tunnels

Thu, 14 Dec 2023 00:00:00 +0000

Disclaimer

This post is strictly about OpenVPN tunneling/forwarding. The use cases are LAN-style co-op acceleration and remote-office intranets. Nothing else.

Background

Lately I’ve been playing co-op with friends — Raft, Stardew Valley, Overcooked, etc. Mainland Chinese ISPs use NAT extensively (especially China Mobile), so even when players are geographically close, P2P co-op is laggy, high-latency, and packet-lossy. Often you can’t even join the lobby. I have an earlier post about using UsbEAm LAN Party to build a LAN — once everyone’s on a virtual LAN, you can play locally. Even when going through Steam’s API for relays, most games will switch to LAN co-op. So building a LAN gives a great speed-up to most P2P games! (This is also useful for remote-office intranets — fundamentally you’re simulating a virtual LAN; whatever LAN-only feature you need, you have it.)

Going deeper

Building a virtual LAN over OpenVPN is easy. If you need a primer, see my other post One-click LAN deploy. But I wanted to push it further. The LAN setups in that post all use a single server. Suppose you now need to play with friends in Hong Kong or Macau. Because cross-border routes differ, those friends might struggle to even reach your single server, and latency / loss will be brutal. That made me ask: can I deploy multiple servers? One in mainland China for domestic users. One in Hong Kong for cross-border users. The two servers connected over a GIA premium line, both stitched into the same LAN.

Implementation

Building a shared LAN across two-or-more servers is significantly harder than one. Good news: I figured it out. Approach: Server A in Hangzhou (mainland): all users connecting to it get IPs in 10.251.0.0/16 and 10.250.0.0/16. Server B in Hong Kong: all users connecting to it get IPs in 10.249.0.0/16 and 10.248.0.0/16.

Server B runs OpenVPN as a client and connects to Server A, getting the address 10.251.0.2. IP forwarding has to be enabled on both servers.

Routes on Server A: Outbound: 10.249.0.0/16, 10.248.0.0/16 → route via 10.251.0.2.

Routes on Server B: Outbound: 10.251.0.0/16, 10.250.0.0/16 → route via 10.251.0.1 (Server A’s intranet address).

The middle wiring is fiddly; you have to debug it piece by piece. Some Linux commands you’ll use a lot:

route — view the current routing table
ip a — view all network interfaces
netstat -an — view current network connections

Don’t forget to push the route table to clients on both A and B’s server configs.

End result: whether you connect to A or B, you’re inside the same big 10.0.0.0/8. Both sides can ping each other freely, and if clients use TUN mode you can even go further at L2 / link layer. I’ll stop here.

Notes

What if we make the problem harder — say, hundreds of servers building one giant intranet? How would you architect that? The above only had Server B talking to Server A as a client. If we add Servers C, D, E… how do they talk?

Two basic options. Option 1: pick one server as primary, the rest as secondary. All secondaries only talk to the primary, which forwards traffic between secondaries. This is easy to configure but if the primary goes down everyone loses connection. Secondaries can’t talk to each other directly; everything has to go through the primary, dramatically reducing network utilization. The cluster’s network is bottlenecked on the primary’s max throughput. Also, you’ll see packets taking the long way round. So… Option 2: every server talks pairwise with every other server, maintaining routing tables to form one giant mesh. That has its own problem: each server has to keep connections open with every other server. As the count grows, this resource cost balloons. And the configuration is a nightmare — every server’s route table is unique, every one has to be maintained. (You can script it, of course.)

Each has trade-offs; in real-world deployments you mix them. Within a region, one primary with several secondaries underneath. Across regions worldwide, primaries talk to each other and cascade. The “secondary” of an upper layer becomes the “primary” of the lower layer — recursive nesting. I’ve never operated a cluster that big; my mental model is probably very primitive. But the core idea should be 80–90% on track. The real production setup is probably way more complex.

That said — for game devs, you usually shard by country anyway. Even ultra-high-concurrency Redis lives inside the data center’s intranet. There may be the occasional cross-country sync, but most of the time you don’t need this. From things like Cloudflare Tunnel though, you can see this kind of architecture is used in the wild.

I’ll write a separate post sometime on ultra-high-concurrency Redis in games.

The Tech Behind My Blog

Wed, 13 Dec 2023 00:00:00 +0000

Problems I needed the blog to solve

Before building the blog, I had a few requirements:

Pick a simple, general-purpose blog framework — and one that looks good.
Full feature set: comments, etc.
Bullet-proof against attacks, especially DDoS.
Optimized for mainland-China network conditions — fast access from inside China too.
No ICP filing — even though there’s no problematic content, I just don’t want the hassle.

Full breakdown of the tech

The blog framework is Hugo (Go), with a sharp-looking theme. The site is fully hosted on GitHub Pages; the backend is a GitHub Codespace where I write remotely with VS Code. GitHub Actions auto-deploys on push, so a new post is live in about 10 seconds. On Cloudflare I bought 10 years of baohongjiang.com and pointed it at GitHub Pages. Visit baohongjiang.com and you’re at the blog. Everything is HTTPS-encrypted end to end. Traffic analytics use Google Analytics and Cloudflare in parallel, so I have accurate visitor metrics. Comments are managed via Disqus — for well-known reasons, comments are not visible or postable from inside mainland China.

At this point the blog is full-featured and fast. The site is essentially static, so backend attacks aren’t a thing. And because the site is hosted on GitHub Pages and proxied through Cloudflare, a DDoS attack would have to first break Cloudflare and then take down GitHub before it could even touch my blog. Roughly speaking, you’d need tens of terabits per second to be able to hurt me. I kind of wish my blog were big enough to be worth that kind of attack. Haha.

Now, for well-known reasons, although mainland China can reach the site fine and the speed is OK, latency is over 200ms and packet loss is bad. So I had to specifically optimize for mainland China. Cloudflare does have geo load-balancing, but it’s enterprise-only and expensive. So I bought baohongjiang.cn, ran a bunch of tests, and picked the best Hong Kong GIA-line VPS I could find for nginx reverse-proxying. When you visit baohongjiang.cn, you’re really hitting the GIA-line VPS, which then fetches my site. Latency from mainland Chinese ISPs drops to around 30ms with very low packet loss. It flies.

The full request path: user → baohongjiang.cn → Hong Kong VPS → baohongjiang.com → Cloudflare → GitHub Pages (origin)

baohongjiang.com is the rock-solid international entry point. baohongjiang.cn is the mainland-China fast lane.

This setup is not the cheapest possible — straight GitHub Pages costs you nothing. But I just wanted to flex.

Why Fictional Meaning Matters in Games

Fri, 01 Dec 2023 00:00:00 +0000

Most of my previous posts have been about tech. Tech is binary — 1 is 1, 2 is 2; it works or it doesn’t, just run it and find out. Game design has plenty of widely-accepted principles, but no absolute test for “right.” It’s like writing a novel: everyone has their own way, good novels share certain qualities, but you can’t copy-paste them like code. After thinking about it for a while, I’m writing a piece on game development from the angle of meaning.

Why does anything mean anything?

To live is to chase some kind of meaning. Maslow’s hierarchy: people first satisfy survival, then reproduction, then higher psychological/spiritual needs. From an evolutionary-psychology angle, every behavior, especially instinctive ones, is engraved in our genes. The ultimate question of what life means is philosophy — too hard, I’m not the one to discuss it. Men like 18-year-olds. Women care about beauty. Kids fear being seen as dumb. Old people fear dying. People have gambling instincts, jealousy, conceit, cravings — money in particular. And so on. Human nature is too complex; I can’t catalog it here.

To be alive is to be moved by your own nature. Games exist to satisfy that nature.

What “fictional meaning” does inside a game

Fictional meaning is what lets players find meaning inside a game. Take Paradox games. Hearts of Iron satisfies the fantasy of conquering the world, ruling over masses, plus other desires that aren’t polite to spell out here. A whole horde of military and history fans love it. Stellaris is heaven for sci-fi nerds — governments and factions, ideologies, science, populations. Underneath it’s a numbers strategy game, but the layered fictional meanings let you genuinely live a second life. (I love watching you all dump a pile of “no” votes in the Galactic Community while being unable to do anything about me. Hehe.) Meaning is also tied to what the player already understands. Most survival games include eating and drinking, because that need is etched into the player’s genes — easy to get, hard to find boring.

A small aside: the traffic-magnet “small adult games” — most are mediocre, even simplistic in mechanics. (There are great ones too; not painting them all with one brush.) Some have basically just animations, no real gameplay. Same for some text-based AVGs. But even those leave a strong impression on players, and even with no marketing they pull serious traffic. No mystery — every guy understands this.

Look at other entertainment forms, especially Chinese web novels. Inside China there’s a flood of “low-IQ power-fantasy” novels. Massive readerships. No mystery — they feel good to read. Web novels and games’ fictional meaning are basically the same thing: satisfying human desire. People have even abstracted the techniques — pull-in topics, work/rest balance, pacing. Open with a flirt scene, then pick up a powerful artifact, then humiliate a villain, etc. All sorts of “feel-good beats” weaved together so the reader can’t put it down. That’s structurally identical to game-level design. Game level design is exactly about weaving elements together so the player feels different emotions across the arc. Tomb Raider is a great example — tense story, then a QTE, then transition to a beautiful environment, then a puzzle, then tense combat, then loot. Repeat with different rhythms, building toward a story climax.

Fundamentally, game level design is laying down feel-good beats so the player keeps “reading.” Of course, you also have to control difficulty, pace progression, factor in player skill, etc. In practice it’s much more complex.

Once a game has meaning, players can step inside and feel the beats.

Only meaning that hits hard makes players remember and love your game

There are too many games now. Why is the player going to click your trailer page, why are they going to play your game? Take post-apocalyptic survival. The genre has always been popular. The moment I open a trailer page I can already imagine: I’m alone (or with a team), end-of-world setting — what would I do? That experience is fantastic. Plenty of games have unclear meaning. I can’t even be bothered to click in.

Cyberpunk 2077, controversies aside, has a phenomenal worldview, drawing inspiration from things like Blade Runner. Full of conflict and what-ifs. Especially the chasm between the corporate elite and the underclass. On the surface Night City is hyper-developed, neon, dripping with high tech — but every alley is packed with the homeless, filth, chaos, against gleaming megatowers. It begs you to imagine. GTA 5: do whatever you want in an open world. So so satisfying. PUBG: 100 players fight to be the last one standing on a small island. Rimworld: stranded on an alien planet, survive and grow. And so on.

Almost every popular game has a one-sentence meaning that pulls players in. Of course, Dota, LoL, Honor of Kings, TFT, Hearthstone etc. mostly run on raw gameplay.

Game ops cares about user numbers, and if you win on meaning before they even start playing — if just seeing the game makes them think it’s interesting — you’re already getting double the bang for your buck. Personally, I’m focused on post-apocalyptic survival games. The genre has long-term player demand and lower user-acquisition cost.

Story and plot

Some say a game is a second life. A great second life is one with rises and falls. Like novels and drama. A great game’s story, retold as a novel, would also be great. Or: a game’s story is a kind of novel.

This includes: Worldview / setting Plenty of room for fan-imagination The in-game experience Highs and lows, emotional pull

My writing isn’t great, so I’ll leave it there.

Standing on giants’ shoulders, plus a flash of inspiration

Most “meanings” aren’t original. They’re absorbed from predecessors and prior works. Take bikini armor — by any sensible standard, how is barely-there clothing supposed to provide protection? But: those who get it, get it. That trope has been going strong for ages.

A huge number of works draw inspiration from other works (not just games), stand on giants’ shoulders, and then walk further.

SSD vs RamDisk

Fri, 17 Nov 2023 00:00:00 +0000

During the 6.18 sale this year I built a beast PC: 13900K + 4090, both CPU and GPU on water. With a beast like this, you naturally want to push every spec. This post is about pushing disk speed to the limit. A small flex first: domestic (China) YMTC NAND really delivers. SSD prices have come down hard.

OK, to the point.

Chasing the ceiling of disk speed

After a lot of research I went with RAID 0 — and conveniently, my motherboard supports it. (The drive is mostly games and code, and code is on GitHub. There’s data-loss risk, but I can live with it. More on that later.) I bought YMTC’s “Fanxiang” SSDs, each rated at up to 7500 MB/s read/write. I put two in a RAID 0. The result:

Sequential reads/writes top out around ~12000 MB/s — that’s 12 GB/s! At that speed everything feels great! Allowing for the typical “1+1<2” overhead of RAID 0, that tracks.

Memory speed is well-known to be very fast — typically tens of GB/s. I’ve got a lot of memory, 32G × 2 at 4800MHz, and on a normal day I don’t even use half. So I had a thought: maybe I should try a RAM disk and benchmark it.

Top-end sequential read/write is very high, but the gap vs. the SSD isn’t huge. Add another SSD to the RAID 0 and 3 SSDs would beat the RAM disk on raw sequential.

But look closer — the RAM disk’s random 4K is way faster than the SSD. At rnd4k Q1T1 it’s 10× faster! Random 4K is the workload that actually shows you everyday speed.

Why is random 4K so much faster? Memory is built for massive addressing; SSD controllers are way slower.

Notice another thing here: memory latency is much lower than the SSD’s. rnd4k Q1T1 vs rnd4k Q32T1 — Q is concurrency. At Q1T1 there’s only one process; the next op can’t proceed until the previous one finishes. We see that the SSD’s latency is high and the RAM disk’s is low. SSD average latency: $$1/(73.22 \times 1000 / 4) \approx 0.054\ \text{ms}$$ RAM disk average latency: $$1/(695 \times 1000 / 4) \approx 0.0057\ \text{ms}$$

These match what hardware fundamentals would tell you. So the RAM disk is genuinely much faster at random 4K, and SSDs are unlikely to ever close that latency floor.

Conclusion

SSD and RAM disk sequential read/write are not far apart. With RAID, the SSD even pulls ahead. The RAM disk’s 4K random read/write is far ahead of any SSD, because RAM latency is an order of magnitude lower than NAND. That makes single-threaded 4K 10× faster on a RAM disk! But at the limits of 4K, the gap with RAID-stacked SSDs gets small enough that adding more SSDs to the RAID can simply close it.

But memory is dramatically more expensive than SSD: a 2T domestic SSD is 500-something RMB; 32G of RAM is 1500+ RMB. Unless you have a workload that’s actually latency-sensitive in a serious way, I just recommend SSDs in RAID across the board.

About other databases and Redis

Database bottlenecks are usually 4K read/write. For a long stretch of history, we used spinning disks where peak sequential was a few tens of MB/s — hundreds of times slower than RAM. Redis basically moves the database into RAM to get extreme 4K performance. That’s why high-concurrency services lean on Redis, syncing to disk databases on a schedule.

But, my friend, times have changed. From my testing, you can see: a RAID of SSDs is also very strong. (Of course, I was testing a RAM disk, not pure RAM. There’s a real multiplicative loss there.) RAID also gives you rich backup arrays with redundancy. Pricing is reasonable. Plus, Redis costs real human time and effort to learn and operate.

Granted, Redis still wins on concurrency over a traditional disk-based DB. But honestly, in our line of work — game development — for normal cases a regular disk DB is plenty. SSDs handle thousands or even tens of thousands of concurrent connections fine. (If you’re hitting hundreds of thousands, your business is making bank and will have a real backend team.) Spend a few thousand RMB, buy several SSDs, build a fast RAID 10 with double redundancy. Combine with periodic cold and hot backups. Low cost, high concurrency.

Also, RAM disks aren’t super useful in everyday life, so RAM-disk software is genuinely hard to find these days. Hhh.

UsbEAm LAN Party — Fast Self-Hosted Server Guide (Ultimate Edition) with One-Click Deploy

Tue, 14 Nov 2023 00:00:00 +0000

CentOS 7.x — one-click foolproof installer: wget -O LAN-party-fast-setup.sh https://baohongjiang.com/downloads/LAN-party-fast-setup/LAN-party-fast-setup.sh && chmod +x LAN-party-fast-setup.sh && ./LAN-party-fast-setup.sh

Ubuntu — one-click foolproof installer: wget -O LAN-party-fast-setup-ubuntu.sh https://baohongjiang.com/downloads/LAN-party-fast-setup/LAN-party-fast-setup-ubuntu.sh && chmod +x LAN-party-fast-setup-ubuntu.sh && ./LAN-party-fast-setup-ubuntu.sh

This post was originally on my Zhihu, but the one-click script needs somewhere to live. Hence this blog post.

Original Zhihu thread (in Chinese)

If you use the one-click script, ignore the rest below

CentOS one-click script download System requirements: CentOS 7.x Open firewall ports: TCP:3075, UDP:3074

Ubuntu one-click script download System requirements: Ubuntu 20.04 & 22.04 Open firewall ports: TCP:3075, UDP:3074

A Go-based Excel-to-CSV Exporter — 60× Faster Than the Python One

Tue, 31 Oct 2023 00:00:00 +0000

License notice

MIT. This post discusses a generic table-export tool used in game development; it’s not tied to any specific project. The trigger was the painfully slow Python exporter we used at work, but I wrote this code in my own time, at home. I gave the tool to my workplace project to use, to lift the team’s efficiency. So this tool is not under any NDA, not tied to any organization. Personally owned. The source is now open so anyone can use it.

Background and approach

Most game studios use Excel as their config data format. Game programs obviously can’t read Excel directly, so there’s usually an “exporter” written by an old-school programmer — typically Python, because the env is convenient and writing CLI tools in Python is nice. Especially for tooling. But as everyone knows, Python has the GIL — no matter how good your code is, you’re stuck on a single core. As game configs grow, even a small tweak can cost minutes to re-export. Just unbearable.

I had a flash of inspiration: writing the exporter in Go would be beautiful. Goroutines give you crazy concurrency on multiple cores, plus Go’s structs are all value types — double speedup! (Yes, C++ would be faster, but it’s hard to write well, especially under heavy concurrency. Hand-rolling it, I’m not even sure I’d beat Go, and Go is safer. Also, I’m not really a C++ guy 😉😉😉.)

End result

TL;DR: nearly 60× faster. From a few minutes down to about 3 seconds. I have reason to suspect the bottleneck now is disk read speed rather than CPU. A faster SSD would help, but 3 seconds is already so fast that further optimization isn’t worth it.

Downloads

Required

Config file Before running, you have to configure the export directory and the English name. Required. Place it in the same directory as the Go binary.

Pick one of the following

Go source You’ll need to set up Go and configure the libraries it depends on.

Standalone .exe (recommended) Double-click and go. But because the tool reads/writes files and uses system libraries, antivirus may flag it. Use your own judgement.

My First Blog Post

Tue, 31 Oct 2023 00:00:00 +0000

Why build a blog?

1. To organize what I know — and force myself to dig deeper into a few things.

As my horizons and skills grew, I noticed that pretty much every developer I look up to keeps a blog of their own, full of genuinely useful stuff. Liao Xue Feng’s blog (廖雪峰的博客) in particular — half of my Python is owed to that site. Highly recommended. It’s dense, the level is sky-high, even if he sells courses on his WeChat too. I want to record what I learn and what I figure out, because writing it out and organizing it works far better than just “knowing it” in your head.

2. Building the blog is itself an engineering exercise.

I went with the Hugo framework (Go), even though I’m much more fluent in Python. Go is just fast. Haha. Building the blog itself turned out to be a full-on technical exploration, and I picked up a ton along the way. First was hosting via GitHub Pages — I’d heard of it, never tried it. Once I actually used it, I realized how powerful it is, and combined with GitHub Actions for auto-deploy and GitHub Codespaces, it solves a huge pile of pain points. Before, I only knew the words; you only really get something once you’ve done it. I’ll pass that line on to you, dear reader.

What’s coming on the blog

Roughly: my personal life and work, technical articles, game design, my takes on games, that kind of thing. I’ll keep updating.

Who I Am

Tue, 31 Oct 2023 00:00:00 +0000

Whenever I have to introduce myself, I get a little stuck.

On one hand, I have over 40,000 hours of gameplay across an absurd variety of titles — the depth and breadth of my gaming experience are, honestly, what I consider my biggest asset. And it keeps growing every day.

On the other hand, I have a pretty rounded set of game-related skills. I started in art, I’ve written a fair amount of code, and I’d say I’ve got some real instincts for computers. More importantly, I’ve now spent several years actually working in games, shipping a bunch of projects and even leading teams on some of them.

Whenever I tell people I play a lot of games, it sounds cheap. (Even though I’m genuinely proud of it — it’s the biggest fortune of my life.) Because these days even elementary schoolers play games, so what’s special about me, right?

But it’s exactly that pile of gaming experience that made me grow so fast once I joined the games industry.

My first growth spurt happened at Mei Ri Ji Li (每日给力), and I’m still grateful to my direct manager there. When I joined I was honestly a mess — I didn’t even know git. Game data lived in spreadsheets and I didn’t even know what “exporting tables” was. Truly clueless. If I were my own boss, I wouldn’t have hired me. Hahaha. Lucky for me, I had a solid foundation, and using a computer is basically second nature to me. I can pick new things up scary fast. So I quickly turned into a halfway-decent designer.

My second growth spurt I owe entirely to ChatGPT, especially GPT-4. Genuinely the greatest invention of this century!

Two angles:

Unprecedented motivation, plus actual project experience. When the AI wave hit, I started from a single Python snippet calling OpenAI’s API. Step by step, from “an idea in my head” I built out my own WeChat public account, hooked up AI image generation, then a full website with payment and membership. Along the way I had to learn a huge range of computer science: programming languages, multi-core/multi-threaded concurrency, cryptography, Linux, and on and on. From zero I waded through all of it. I genuinely walked through the front door of computer science!!! Without those first compliments from my early users, I honestly can’t imagine I’d have been able to push as far as I did.
The best teacher, period. Thank you, GPT-4. Computer science is a massive, sprawling thing, and a beginner can’t even configure their environment, let alone Google the right question. Most of the time a beginner doesn’t even know what the question is. GPT-4 wrote a ton of code for me, I just kept asking and it kept answering. The $20 a month is the most worthwhile money I’ve ever spent in my life!

Now I want to push further into games. The more I learn, the more I realize I don’t know. I really, really want to get into a multinational game studio and learn how their pipelines and tools work. I want to be the best at this. There’s so much value in it! 👍👍👍

Links

Mon, 01 Jan 0001 00:00:00 +0000

To use this feature, add a links section to the frontmatter.

This page’s frontmatter:

1
2
3
4
5
6
7
8
9


links:
 - title: GitHub
 description: GitHub is the world's largest software development platform.
 website: https://github.com
 image: https://github.githubassets.com/images/modules/logos_page/GitHub-Mark.png
 - title: TypeScript
 description: TypeScript is a typed superset of JavaScript that compiles to plain JavaScript.
 website: https://www.typescriptlang.org
 image: ts-logo-128.jpg

The image field accepts both local and external images.

Search

Mon, 01 Jan 0001 00:00:00 +0000

Hongjiang Bao's Blog

Standing in 2026 — The Next Stage of How I Use AI

Foreword

My five stages of using AI

The bottleneck: top experts can’t get enough out of three Max 20x’s; I can’t even use up one Pro

The next stage: from “operator” to “legislator”

I’m already crawling toward it: what L4.5 actually feels like

The productivity gap is widening

What it asks of you: both knowledge density and total knowledge

Standing in 2025 — Looking Back at AI, and Looking Forward

Looking at the present from the past, and predicting the future from now.

An article from January 2015 that predicted today’s AI

An article I wrote in December 2023 about how I understand and use AI

How AI completely flips the way I solve problems and think about them.

Roundup of AI products as of today

My personal outlook on the future of AI

Palworld Co-op Guide for the Pirated Build

Disclaimer

Step 1: Download the pirated build of Palworld and install the co-op patch

Step 2: On the host, install steamCmd, download the Palworld dedicated server files, and bring up the server.

Step 3: Co-op and acceleration

How I Use AI — Notes from the Field

GPT — the greatest invention in history

The mainstream AIs

What GPT-4 changed for me

A complete overhaul of how I learn and how I get things done

Building a Dynamic Multi-Server LAN over OpenVPN Tunnels

Disclaimer

Background

Going deeper

Implementation

Notes

The Tech Behind My Blog

Problems I needed the blog to solve

Full breakdown of the tech

Why Fictional Meaning Matters in Games

Why does anything mean anything?

What “fictional meaning” does inside a game

Only meaning that hits hard makes players remember and love your game

Story and plot

Standing on giants’ shoulders, plus a flash of inspiration

SSD vs RamDisk

Chasing the ceiling of disk speed

Conclusion

About other databases and Redis

UsbEAm LAN Party — Fast Self-Hosted Server Guide (Ultimate Edition) with One-Click Deploy

If you use the one-click script, ignore the rest below

A Go-based Excel-to-CSV Exporter — 60× Faster Than the Python One

License notice

Background and approach

End result

Downloads

Required

Pick one of the following

My First Blog Post

Why build a blog?

1. To organize what I know — and force myself to dig deeper into a few things.

2. Building the blog is itself an engineering exercise.

What’s coming on the blog

Who I Am

Archives

Links

Search