2026-01-31

The past few days have been quite packed, so I didn’t keep a record. But it’s not acceptable to stop recording, so I’m picking it up now and recording everything together.

Besides being busy, why didn’t I record?

1. Because I feared that recording would require sitting down and spending at least 30 minutes just to document a day. This actually stems from some fear and burden associated with recording daily life, which is not advisable.
2. I usually only start recording a day after it truly ends. But thinking about it carefully, this is somewhat counterintuitive, because now when it’s time to sleep, I quickly dive into bed, not because I’ve actually finished everything I wanted to do (does that ever really happen?). This means that when I have free time, I don’t record, and when it’s actually time to record, I have to jump into bed quickly, compounded by issue #1.

The combination of the two leads to a growing backlog.

1. What did I do today:

   Correction: what I did in the past few days

   1. Started using Neovim after being persuaded by SC. Why? I saw that nvim-orgmode has truly become a viable org-mode, and I’ve grown tired of Emacs:

      • Endless update failures
      • Confusing debugging and error messages
      • Unnecessary flexibility that only adds burden for me
      • I don’t understand Emacs Lisp and have no desire to

      For years, I’ve endured all of the above just to use org-mode, but there was no other place where I could properly use org-mode. Now that the Neovim camp seems to have an alternative, why not try it?

      Since I’ve been a long-time Vim user and have used evil-mode (Vim mode) in Emacs, I’ve never felt that using Vim is a burden. In VS Code and IntelliJ, I can’t survive without Vim, so switching to Neovim is no problem at all.

      With no obstacles left, I examined the Neovim ecosystem. Neovim doesn’t carry the historical baggage of Vimscript; it directly uses Lua as its configuration and plugin language, so it can be lightweight, and the community is very active. Now, the Neovim plugin system seems to be unified by a system called lazy.vim. Neovim’s design for its plugin and configuration system appears to have been bold and organized in addressing Vim’s original pain points. Within Vim & Emacs, there have been countless similar attempts to unify, but due to community fragmentation, none have truly succeeded.

      So I tried lazyVim directly. Wow, I suddenly felt like I had a VS Code that runs in the terminal. Do you know how great that feels?

      Now I have a powerful ancient overlord based on a new infrastructure, and configuring it is extremely simple. Flexibility and convenience are perfectly balanced, and most of my old pain points are resolved.

      I almost effortlessly switched a significant portion of my workflow to this setup. Now I use tmux with 5 windows, each window opens Neovim under a folder. In Neovim, the left side is the directory tree, the center is the code, and the right side is opencode and the terminal.

   2. Updated a version of Legion. I significantly reduced the text volume of the Legionmind skill (by about 4k lines). So far, it feels like it requires less oversight from me, but I’m not sure if it’s because I’ve been using smarter models recently or if this version of Legionmind has genuinely become smarter.

   3. Set up an OpenClaw. Minimax 2.1 is still a bit dumb, but as a personal assistant, I think OpenClaw is quite decent, because it’s essentially a ChatGPT with memory plus hands and feet (can operate my computer).

   4. Added HTTP-proxy functionality to Yuan, including metrics and such.

2. Any thoughts?

   Sometimes I feel that writing with AI is a bit like debugging code whose principles I don’t fully understand—constantly testing its behavior or printing logs to assist debugging, tweaking a bit here, adding a bit there, until I get a satisfactory result. Let me explore the origin of this feeling:

   The process of using AI to write code is that a human inputs a prompt containing specific instructions, hoping that the AI will understand the implicit instructions and information behind these instructions and correctly complete the task.

   The instructions intended for the AI can be stratified: the top layer is the instruction for the current task. Below that are some technical decisions made for this software project, best practices derived from trade-offs that apply locally to this project. The next layer is background information about the problem domain that the project aims to solve. The next layer is the professional background knowledge of the software engineering discipline using AI, including personal preferences, technical preferences, stylistic preferences, historical experience, and accumulated mindset. The bottom layer is the background knowledge of the world.

   In a conversation with AI, the only thing that can be clearly conveyed is the instruction for the current task, hoping that the AI has sufficient world background knowledge and background information needed to solve the problem.

   Therefore, it can be inferred that if the context of a task is small enough, the instructions are crystal clear, and there is no historical baggage, the AI should easily complete the task with high quality. If there is a lot of implicit background information, it can easily produce odd results.

   What Legionmind aims to do is to let the AI accumulate background knowledge and best practices about the project itself and the problem domain. This requires the AI to either have good logical thinking ability and memory (context capacity) or have abundant world background knowledge. Beyond these two, there is no way to salvage it.

   —

   Then I feel that Neovim is something I wish I had discovered much earlier.

3. What to do tomorrow?

   Tomorrow, I’m going to visit SC’s new home, play board games together, and also show snow gear to SY.