DEV Community: Andy Stewart

Tired of Manual Movie Hunting? I Built an AI Agent Skill to Automate My NAS Downloads

Andy Stewart — Fri, 15 May 2026 08:11:49 +0000

The Backstory: Engineering "Domestic Bliss"
As an OS developer and hardware entrepreneur with over 20 years in the game, my life is usually defined by "Walking & Coding." However, even the most robust system architecture can’t solve a simple domestic pain point: "Honey, can you find this movie for me?"

The old workflow was tedious: Get the request -> Manual search for magnets -> Log into the NAS -> Paste the link -> Monitor the download. It felt like a waste of cycles.

Since I'm currently building Hermes (an AI Agent) and the LCMD private cloud hardware, I decided to close the loop. I wrote a Skill that allows the Agent to handle the entire "Search-to-Download" pipeline via natural language.

The Stack: AI Agent + NAS + VueTorrent
The architecture is built on a "Surgical Logic" approach—precise, deterministic, and efficient:

The Brain (Agent): Processes natural language intent (e.g., "Find the Pirates of the Caribbean series").

The Nerve (Skill): My custom LazyCat Movie Search Skill queries resource sites and filters metadata.

The Muscle (Downloader): Interfaces with the VueTorrent API on the NAS to execute the task.

Why It’s "Smooth as Silk":
Smart Recognition: It doesn't just find one file; it can identify entire series or specific sequels based on context.

Quality Control: Supports filtering by resolution—720P, 1080P, or 4K.

Traffic Management: I implemented a logic to automatically set the Seeding Ratio to 1.0. This ensures you contribute back to the swarm without choking your NAS upload bandwidth indefinitely.

The "Popcorn" Experience: Once the file hits the NAS, tools like NetEase Popcorn automatically scrape the metadata, creating a beautiful poster wall for the family to watch on any device.

Quick Setup
If you’re running a NAS (optimized for Lazy Cat, but adaptable for others), here’s the drill:

Prepare your Agent: Ensure your assistant (like Hermes) supports external Skill loading.

Install the Skill: Load the "LazyCat Movie Search" Skill.

Link the Downloader: Input your VueTorrent WebUI address and credentials.

Talk is cheap. Show me the code.

I’ve fully open-sourced this Skill. The logic is clean, and you can easily adapt it to other BT clients by tweaking the API calls.

🔗 GitHub Repository: https://github.com/whoamihappyhacking/lazycat-movie-search-skill

Final Thoughts
Now, when my wife wants to watch something, I don't even have to look up from my keyboard. A single voice command to the Agent handles it all.

To me, AI shouldn't just be a chatbot; it should be the "universal interface" between human intent and hardware execution. This project is a small example of how we can use AI to reclaim our time from repetitive digital chores.

If you’re into AI Agents, private clouds, or just want to chat about NAS optimization, feel free to drop a comment or open a PR on GitHub.

Happy Hacking!

Stop Relying on Prompts: A 3-Step Architect’s Guide to Building Bulletproof AI Skills

Andy Stewart — Tue, 12 May 2026 09:21:22 +0000

I’ve spent 20 years in the Linux ecosystem, from founding Deepin to architecting private AI hardware. If there’s one thing I’ve learned, it’s this: A well-designed Tool is worth ten "perfect" prompts.

Lately, people have been asking me why my LCMD Assistant is so reliable at complex tasks like resource hunting and automated media management. The secret isn't in a magic prompt; it’s in the engineering framework I use to build Skills with DeepSeek V4.

Here is my 3-step blueprint for building AI Skills that actually work:

Step 1: Define the Path (Not just the Goal)
Most people tell an AI: "Find me this movie." Architects don't do that.
You must analyze the target environment. If you’re targeting a specific site, you need to map the path: From opening the URL, to parsing the list, to extracting the final magnet link. You need a mental flowchart of the logic before you write a single instruction.

Step 2: Scripting as Your "Super Tool"
Script = Tool.
If you let an AI "hallucinate" its way through a website, your success rate is a coin flip. I prioritize scripting core actions (like searching or filtering) and exposing them as a Tool. The AI’s job isn't to "guess" how to interact—its job is to act as the "Brain" that executes these scripts.
This ensures deterministic results, regardless of which model you are using.

Step 3: Edge Case Deduction (Defensive Programming)
This is the boundary between a toy and a professional tool. You must architect for the "What ifs":

Conflict Resolution: If the search returns 720p, 1080p, and 4K, how should the AI present these choices to the user?

Environment Gaps: What if the user doesn't have a download client installed? How should the AI guide them instead of just failing?
By defining these output formats and error-handling logics within the Skill, your AI starts acting like a "Senior Engineer" rather than a confused intern.

Challenge: Build Your Own
I’ve already used this framework to build a "TV Series Automator" that tracks and fetches new episodes.

Now it's your turn. Pick up DeepSeek V4, follow these three steps (Map Path -> Script Core -> Define Edge Cases), and build a Skill that solves a real pain point in your life.

Stop making Demos. Start building Tools. I'm looking forward to seeing what you build in the comments.

Why Most AI Agents Fail: If You Can’t Bypass Cloudflare, Your Agent is Blind

Andy Stewart — Tue, 12 May 2026 08:53:34 +0000

I’ve been building operating systems for over 20 years. From founding Deepin to architecting private AI hardware, I’ve learned one thing: Architecture beats hype.

Lately, everyone is talking about "AI Agents." But as an old-school C/C++ developer and Linuxer, I see a glaring issue that most "AI experts" are ignoring.

The Elephant in the Room: The "Cloudflare Wall"
The biggest pain point of running an Agent isn't its reasoning capability—it’s its reach.

The web’s most valuable resources are increasingly hidden behind Cloudflare and advanced bot protection. If your Agent gets stuck on a "Verify you are human" checkbox, it becomes useless. It can't fetch data, it can't analyze trends, and it can't solve real problems.

You can pay for expensive third-party proxy services, but why? As a veteran programmer, I believe we should solve this at the system level, not with a credit card.

The Foundation: Full-Auto Browser Proxy
While developing LCMD Assistant(小龙猫), I focused on solving the "Access" problem before the "Thinking" problem.

Whether you are using Skills or the MCP (Model Context Protocol), the foundation is a headless browser that can navigate the real web without restrictions. We’ve developed a kernel-level logic that handles Cloudflare verification automatically.

Without this, your Agent is just a toy. With it, it’s a professional researcher.

What a Real "AI OS" Looks Like
A true AI OS shouldn't just chat; it should work.

Real Retrieval: It goes to the web, bypasses the gates, and gets the raw data.

Information Arbitrage: It summarizes what you can’t find through a standard search.

Private Integration: It fetches those resources and delivers them directly to your Private Cloud Storage.

That is the closed-loop ecosystem we’ve built. It’s ready.

Join the Beta (For Free)
If you have a DeepSeek V4 API key, you can run the LCMD Assistant and our suite of Skill/MCP scenarios fluently right now.

I want to share this with developers who are tired of "demo-only" AI and want something that works in the trenches.

Want free access to LCMD Assistant+ our Skill/MCP library?

Comment "1" below, and I’ll send the documentation and access link to your inbox.

DeepSeek V4 + Claude Code: Building a "Surgical" Development Workflow with China's Strongest Open-Source Model

Andy Stewart — Tue, 12 May 2026 07:44:11 +0000

The "Vibe Coding" era has evolved. With the release of DeepSeek V4, we finally have an open-source reasoning engine from China that can truly compete with closed-source giants like GPT-4o and Claude 3.5.

As a system architect (founder of deepin and Lazy Cat), I have always pursued determinism and architectural sovereignty. By combining DeepSeek’s logical reasoning with Claude Code’s CLI automation, we can build an AI-native development loop that is extremely low-cost and offers high control.

In just 5 minutes, you can configure this "Terminal Arsenal."

1. The Engine: Installing Claude Code
Claude Code is more than just a chat box; it is an agent running in your terminal that can directly manipulate local files, run tests, and manage Git workflows. It is a true engineering tool.

Microsoft Windows 10:

（1）Press Win+R, type cmd, and open the Command Prompt.

（2）Paste the following code and hit Enter (Note: It must be CMD; PowerShell will not work)：
curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd
（3）After installation, verify it by running:

claude --version

If the version number appears correctly as shown in the screenshots, the installation is successful.

Note: Pay attention to the small grey text regarding adding environment variables.

Unix (macOS and Linux):

（1）Open your terminal emulator. (macOS users: Search for "Terminal" in Spotlight. Linux users: You know the drill.)
（2）Paste and execute the following code (ensure your network can access global services):
curl -fsSL https://claude.ai/install.sh | bash

（3）Verify the installation:
claude --version

2. The Soul: DeepSeek V4 API

DeepSeek is currently the "smartest brain" with the highest cost-performance ratio globally.

（1） Visit the DeepSeek Open Platform to register.
（2）I recommend an initial top-up (using the flash model is incredibly cheap and perfect for high-frequency iterations).
（3）Generate your API Key.
Safety Tip: I personally store my keys in Bitwarden on my local LCMD private cloud; I refuse to let my data sovereignty go "streaking" on the public cloud.

3. Launch Command: Driving Claude Code with DeepSeek

（1）Using the Anthropic-compatible interface provided by DeepSeek, we can seamlessly swap the underlying model.

（2）Enter the following code in your terminal (replace with your actual Key):

ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic ANTHROPIC_AUTH_TOKEN=sk-你的访问密码 ANTHROPIC_MODEL=deepseek-v4-flash claude

Note: There are spaces in the command—do not miss them. Even a single wrong character will cause it to fail. It is best to copy this into a text editor first, edit it, and then paste it.

4. Real-World Demo: Building a High-Tech Product Page
Once launched, try giving the Agent instructions (using my LC03 project as an example):

"Create an introduction page for LC03. Requirements: White theme, minimalist high-tech aesthetic (Surgical Logic style), optimized for desktop experience. Once written, automatically open the HTML in my browser."

The Workflow: Claude Code will automatically plan the file structure, write the code, and handle permissions. You are only responsible for high-level architectural decisions.

5. Why is this the ultimate solution for the "One-Person Company" (OPC)?
During the development of LightOS (the AI Development All-in-One), I realized that leadership is essentially the quality of the nervous system under pressure. The same applies to tools.

By using Chinese open-source models like DeepSeek, we not only reduce costs but, more importantly, reduce dependency on "external black boxes," keeping the core business logic pure and controlled.

Join the Community
The OPC is no longer a myth. We are deploying AI-generated software directly onto decentralized private hardware, reclaiming digital sovereignty.

Are you ready to move from "writing prompts" to "building systems"? Let's discuss the future of AI infrastructure together.

Breaking the "Desk-Lock": A Linux Veteran’s Blueprint for Walking Programming and Productivity Reconstruction

Andy Stewart — Wed, 06 May 2026 08:55:02 +0000

People call me a "Involution King" (卷王).

They see me managing a company, writing core infrastructure code, and handling a mountain of "miscellaneous" tasks—all while maintaining a relentless release schedule. They’re curious: "Andy, how do you actually ship that much code?"

The answer is simple: I stopped anchoring myself to a desk. I code while walking, while thinking, and while moving. Whether I'm shopping with my wife, walking the dog, or waiting at the school gate, I am in development mode.

For me, this isn't just about efficiency; it's about a seamless transition of roles:

While writing logic, I am the Programmer.

While walking and ideating, I am the Product Manager.

While pushing a release, I am the Project Manager.

I don’t need to be tethered to a physical coordinate. What I need is a systematic architecture—a "plumbing" system that lets me dispatch tasks to AI as digital agents, rather than just staring at a dry chat interface on a smartphone.

The 4 "Hardcore" Pain Points of Mobile Programming
While walking by East Lake or waiting for my daughter after school, I’ve stress-tested nearly every mobile AI coding solution on the market. I’ve realized that true "Programming Freedom" requires overcoming four technical hurdles:

1. Seamless Workflow "Drift" (Context Handoff)
I cannot accept fragmented environments. When I leave my office and head outdoors, my entire coding environment and debugging context must "drift" instantly to my mobile device. The phone isn't a crippled backup; it must share the exact same underlying logic as my workstation.

2. Breaking the "Geofence"
True mobile programming isn't just sitting on your couch. It’s in the car, at the grocery store, or by the BBQ grill. Inspiration is fleeting. You must have the ability to turn a thought into a Commit within 60 seconds of it hitting your brain.

3. Closed-Loop Real-Time Rendering
Programming is fundamentally a loop of "Execute & Verify." Writing code without seeing the result is flying blind. Whether I’m tweaking a UI pixel or refactoring an Agent’s scheduling logic, I demand an instant, live preview of the execution on my actual device.

4. The "Bare Metal" Debugging Advantage
This is the Achilles' heel of most cloud IDEs and web-based AI tools. When you are both the developer and the user, your phone is both your dev machine and your real-world testbed. Validating functions on actual hardware in real-time provides a level of "dev-euphoria" that only hardcore engineers truly understand.

*Field Report: My "Fluid Laboratory" *
Shopping with my wife: Fixing a bug in the Hermes Agent. I’ve already mapped out the logic while walking; during the gaps in our conversation, I whip out my phone, "chat" with the system, modify the code, and verify the fix on the spot.

BBQ by East Lake: Refactoring code amidst the smoke and fire.

Waiting for school pickup: A 15-minute window is more than enough to ship a new version.

The Core Gear: LCMD Micro-Server
The backbone of this entire operation is my LCMD Micro-Server, running 24/7 at my home.

It’s not just a NAS; it’s my Productivity Command Center. You can dispatch heavy-lifting tasks—computational power, environment isolation, and version control—to it at any time, leaving you free to focus on decision-making and high-level planning.

In the past, individuals couldn't handle complex projects because they were trapped by expensive cloud costs and fixed workstations. Now, with a Micro-Server and AI, you can fit an entire development studio in your pocket.

Stop "welding" yourself to your desk. Go walk, go think, and code as naturally as you breathe.

20-Year Linux Veteran Gets "Kernel Panicked"? Hardcore Fix for Random Desktop Freezes on AMD GPUs

Andy Stewart — Thu, 30 Apr 2026 09:22:00 +0000

After 20 years of hacking away in the open-source world and the Linux community, I’ve realized I might actually be a Bug Magnet.

On my previous laptop, a Dell G16, the power-saving mode of the Intel AX201 Wi-Fi card caused pacman updates to crawl at snail speeds. I finally solved that by surgically disabling the power-saving logic. Last year, I switched to this ThinkPad P14s, specifically choosing the AMD integrated graphics version. I thought, "No NVIDIA proprietary drivers to mess with—surely this will be stable, right?"

As it turns out, if you have a mind for "tinkering," bugs will find you with pinpoint accuracy.

The Symptom: The Unavoidable "Frozen Frame"
Recently, my desktop environment started freezing multiple times a day. That feeling of the entire GUI suddenly solidifying is incredibly frustrating. It even made me wonder if I had broken the system by messing with some underlying plumbing.

After work, I decided to cut the Gordian knot and reinstalled EndeavourOS. The freezes persisted. But I noticed a crucial clue: While the GUI was dead, the TTY was still functional. This classic "pseudo-hang" usually means the system hasn't crashed; rather, there’s a communication breakdown between the kernel driver and the hardware.

I fired up dmesg for a deep-dive log review and finally caught the culprit.

[ 4.392040] amdgpu 0000:c4:00.0: amdgpu: [drm] PSR support 1, DC PSR ver 0, sink PSR ver 3 DPCD caps 0x7b su_y_granularity 4 [ 4.392173] amdgpu 0000:c4:00.0: amdgpu: [drm] PSR support 0, DC PSR ver -1, sink PSR ver 0 DPCD caps 0x0 su_y_granularity 0 [ 4.392327] amdgpu 0000:c4:00.0: amdgpu: [drm] PSR support 0, DC PSR ver -1, sink PSR ver 0 DPCD caps 0x0 su_y_granularity 0 [ 4.392453] amdgpu 0000:c4:00.0: amdgpu: [drm] PSR support 0, DC PSR ver -1, sink PSR ver 0 DPCD caps 0x0 su_y_granularity 0 [ 4.392587] amdgpu 0000:c4:00.0: amdgpu: [drm] PSR support 0, DC PSR ver -1, sink PSR ver 0 DPCD caps 0x0 su_y_granularity 0 [ 4.392641] amdgpu 0000:c4:00.0: amdgpu: [drm] PSR support 0, DC PSR ver -1, sink PSR ver 0 DPCD caps 0x0 su_y_granularity 0 [ 4.392703] amdgpu 0000:c4:00.0: amdgpu: [drm] PSR support 0, DC PSR ver -1, sink PSR ver 0 DPCD caps 0x0 su_y_granularity 0 [ 4.392774] amdgpu 0000:c4:00.0: amdgpu: [drm] PSR support 0, DC PSR ver -1, sink PSR ver 0 DPCD caps 0x0 su_y_granularity 0 [ 4.392842] amdgpu 0000:c4:00.0: amdgpu: [drm] PSR support 0, DC PSR ver -1, sink PSR ver 0 DPCD caps 0x0 su_y_granularity 0
The Root Cause: AMD Driver's PSR Feature
After a technical post-mortem, I discovered the freezes were caused by the Panel Self Refresh (PSR) feature of the AMD Radeon 890M.

This is a known driver bug, particularly prone to triggering on the Ryzen AI 9 HX PRO 370 (Strix Point) platform + amdgpu driver + Plasma desktop combo. PSR is intended to save power by allowing the panel to refresh itself when the image is static, but in practice, it becomes a "chokehold" that causes the GPU driver to hang.

The Surgical Solution: Manually Disabling PSR
For programmers and veterans, the logic for solving problems isn't "reinstalling everything"—it's precise excision. Since the power-saving logic is buggy, we manually disable the feature.

Here is the fix:

1.sudo nano /etc/kernel/cmdline , add the parameter amdgpu.dcdebugmask=0x10 to the end of the line.

2.sudo reinstall-kernels , to regenerate the kernel entries and initrd. This will automatically update all .conf files under /efi/loader/entries/, applying the new parameter to current and future kernels.

3.sudo reboot , restart the system.

Verifying the Kernel Parameters:

Use the command cat /proc/cmdline to check if amdgpu.dcdebugmask=0x10 is present at the end.

You can also run cat /sys/module/amdgpu/parameters/dcdebugmask. If the output is 16 (the decimal equivalent of 0x10), PSR is successfully disabled.

Finally, run dmesg | grep -i psr. You should no longer see any PSR-related logs in the kernel.

After this bit of tinkering, the laptop is now rock-solid. I haven't encountered a single desktop freeze since.

20 Years of Linux Input Method Tweaking: From Kernel Drivers to AI Models—The Ultimate Form of Input Experience

Andy Stewart — Thu, 30 Apr 2026 07:46:34 +0000

Having spent 20 years navigating the open-source world and the Linux community—from building Deepin OS to developing EAF—I’ve always held one conviction: A programmer’s sense of achievement comes half from changing the world, and half from the ultimate refinement of their tools. Many ask me why I still spend so much energy on RIME configurations in the age of AI. It's because an input method is an extension of one's thoughts. Every missed character or mistyped toggle between Chinese and English is a profanity against the "Flow State."

I’ve tested Rime-Ice, Rime-Frost, and Wanxiang, but ultimately returned to Rime-Ice. Wanxiang’s pinyin mode was simply too frustrating due to frequent accidental triggers. Today, I’m organizing all my Fcitx configuration practices into this post. This isn't just a tutorial; it’s a tribute to the open-source community’s spirit of "standing on the shoulders of giants." Since I’ve benefited from the wheels others built, I must contribute my polished solutions back.

If you are an Arch Linux user, congratulations—you don't need to mess with the command lines below. You can simply use my tool, rime-ice-installer, which automatically installs and applies all the configurations mentioned here.

yay -S rime-ice-installer rime-ice-installer

Features of rime-ice-installer:

1.Installs Fcitx and Rime-Ice (Wusong).
2.Automatically configures X11/Wayland environments.
3.Automatically configures the Wanxiang AI Large Model.
4.Configures convenient habits, such as using commas and periods for paging by default.
5.Includes a dark-theme-friendly skin.
6.Most importantly: It maps the Shift key to switch the system's English layout rather than entering Fcitx's internal "English Mode." Once Fcitx's English mode is triggered accidentally, it's notoriously difficult to switch back via the keyboard, often requiring a mouse click on the system tray.

Installing Fcitx5
Install the Fcitx5 packages:

sudo pacman -S fcitx5 fcitx5-gtk fcitx5-qt fcitx5-configtool fcitx5-rime librime

fcitx5: Core input method framework.
fcitx5-gtk: Support for GTK applications. Essential for fixing missing characters during fast typing.
fcitx5-qt: Support for QT5 applications. Essential for fixing missing characters during fast typing.
fcitx5-configtool: GUI configuration tool.
fcitx5-rime: RIME input method engine.
fcitx5-im: Input method setup tool.
librime: RIME libraries, required by emacs-rime below.

Wayland Environment Setup
After installing the packages, in a KDE environment, simply go to KDE Settings -> Virtual Keyboard, select Fcitx5, and log out/in.

For specific apps like WeChat that fail to support Chinese input, you need to create the configuration file ~/.config/plasma-workspace/env/ime.sh and add:

export GTK_IM_MODULE=fcitx export QT_IM_MODULE=fcitx export XMODIFIERS="@im=fcitx"

After logging out and back in, you should be able to type Chinese in WeChat under Wayland.

Notes:
You must install fcitx5-gtk and fcitx5-qt and set the IM variables above, otherwise, typing too fast will result in "character leaking," where the pinyin is inserted directly into the input box instead of converting to Hanzi.

Add-ons: Remove the shortcuts for the clipboard and quick input modules to avoid conflicts with Emacs keybindings.

X11 Environment Setup
For X11, write the following to ~/.xprofile:

export GTK_IM_MODULE=fcitx export QT_IM_MODULE=fcitx export XMODIFIERS="@im=fcitx"

Notes:
Same as Wayland, ensure fcitx5-gtk and fcitx5-qt are installed to prevent character leaking.

Disable clipboard/quick input shortcuts to avoid Emacs conflicts.

Installing Fcitx5 Skins
yay -S fcitx5-skin-adwaita-dark

Then modify the config file ~/.config/fcitx5/conf/classicui.conf:
`Horizontal candidate list
Vertical Candidate List=False

Prevent font scaling with DPI to avoid oversized interface
PerScreenDPI=False

Font and size (check options with fc-list)
Font="Noto Sans Mono 13"

Gnome3-style theme
Theme=adwaita-dark`

Note: I personally prefer "TsangerJinKai03," so you can replace the Font with TsangerJinKai03-6763 15.

Installing Rime-Ice (Wusong Pinyin)
The steps above set up the core and skin, but the default Fcitx dictionary is quite poor. For a fluid experience, you need Rime-Ice.
Copy all rime-ice configurations to the fcitx rime directory:

git clone https://github.com/iDvel/rime-ice --depth=1

Modifying Default Configurations
Switch to the rime-ice directory and perform these three operations:
1.grep all- { when: paging, accept: comma, send: Page_Up } 和 - { when: has_menu, accept: period, send: Page_Down } ，Remove the annotations
2.grep page_size, change 5 to 9.

`sed -i 's/# (- { when: (paging|has_menu), accept: (comma|period), send: Page_(Up|Down) })/\1/' default.yaml

sed -i 's/page_size: 5/page_size: 9/' default.yaml`

he first two enable paging with commas and periods; the third increases the number of candidate words.

Adding Large Language Models
While Rime-Ice is already quite smart, we can enhance context-based suggestions by installing a Wanxiang language model.

The specific operation method is as follows:
Download rime-lmdg. I downloaded the amz-v2n3m1-zh-hans.gram file.

Move the file amz-v2n3m1-zh-hans.gram to the rime-ice directory.

Create a new rime-ice.custom.yaml file in the rime-ice directory with the following contents:

patch: grammar: language: amz-v2n3m1-zh-hans collocation_max_length: 5 collocation_min_length: 2 translator/contextual_suggestions: true translator/max_homophones: 7 translator/max_homographs: 7

Updating the Fcitx Directory
After adjusting the configs, perform the copy. Backup and clear ~/.config/fcitx/rime/ and ~/.local/share/fcitx5/rime first to avoid conflicts.

cp -r ./rime-ice/* ~/.config/fcitx/rime/ cp -r ./rime-ice/* ~/.local/share/fcitx5/rime

~/.config/fcitx/rime/: Primarily read by the emacs-rime plugin.

~/.local/share/fcitx5/rime: Read by Fcitx for external software.

Deleting Accidental Input
If you accidentally confirm a pinyin string, it might become the first candidate. These are recorded here:

~/.local/share/fcitx5/rime/en_dicts/en.dict.yaml ~/.config/fcitx/rime/en_dicts/en.dict.yaml
Find the errant string, delete it, save, and restart Fcitx.

Installing emacs-rime
This section is about bringing Rime-Ice into Emacs.
First, install posframe, and then download emacs-rime:

git clone https://github.com/DogLooksGood/emacs-rime

Add the directory to your load-path and add the following config:

`(require 'rime)

;;; Code:
(setq rime-user-data-dir "~/.config/fcitx/rime")

(setq rime-posframe-properties
(list :background-color "#333333"
:foreground-color "#dcdccc"
:font "WenQuanYi Micro Hei Mono-14"
:internal-border-width 10))

(setq default-input-method "rime"
rime-show-candidate 'posframe)`

The configurations above respectively set the path for emacs-rime to read RIME configurations, the UI details, and the use of posframe to display candidate words.

After restarting Emacs, invoke the toggle-input-method command to try typing in Chinese.

The Rime-Ice home page provides several input examples. If typing the same pinyin yields the identical Chinese candidate words, it confirms that you have successfully implemented Rime-Ice.

In my personal experience, the fine-tuning of Rime-Ice is exceptional—far more professional than any RIME dictionary I’ve tried to cobble together myself. Chinese input, especially for long sentences, no longer requires flipping through endless pages of candidates.

The combination of emacs-rime and Rime-Ice makes Chinese input in Emacs an absolute joy. I’ve personally sent a small donation to the author of Rime-Ice to show my appreciation for their hard work and contribution to the open-source community！

Farewell to F5: Building a Seamless Writing Workflow with Jekyll LiveReload

Andy Stewart — Wed, 29 Apr 2026 09:07:10 +0000

As a 20-year Linux veteran, I have zero tolerance for mechanical tasks that break my "flow."

When using Jekyll for blogging, many developers fall into a repetitive trap: edit a paragraph -> switch to the browser -> hit manual refresh (F5). It’s a tiny friction, but like a memory leak in your code, it slowly drains your creative energy throughout the day.

The solution has been hiding in the Jekyll documentation all along.

1. The Core Command: Instant Synchronization
Stop using the plain jekyll serve. Instead, fire up your local environment with this:

Bash jekyll serve --livereload

By adding this parameter, Jekyll spins up an internal listener. The moment your Markdown file is modified and saved, the browser updates the view automatically, as if it’s reading your mind.

2. My Hardcore Workflow: Emacs + Hammerspoon + Magit
Configuring LiveReload is just the foundation. Real efficiency comes from automating the entire pipeline. Here is my "zero-friction" loop—designed so that the moment my fingers leave the keys, everything is already in motion:

Drafting in Emacs: Writing fluidly in markdown-mode.

Auto-Save: My auto-save plugin commits the changes to the disk the split-second I stop typing.

Invisible Refresh: Jekyll detects the change immediately. I use Hammerspoon to snap to the browser, where the content is already rendered and waiting for me.

Magit Deployment: Once I'm satisfied with the preview, a few quick Magit keystrokes push the update straight to GitHub Pages.

A developer’s dignity is reflected in the craftsmanship of their toolchain. Achieving this kind of "seamless transition" allows you to pour 100% of your focus into the content itself, rather than acting as a manual bridge between your editor and the browser.

What "manual refresh" or repetitive task in your daily workflow drives you crazy? How did you use scripts or automation to kill it off for good?

Share your efficiency secrets or your Jekyll optimization tips in the comments below.

$400 or $4? Using 'Surgical Logic' for a Hardcore MacBook Keyboard Repair

Andy Stewart — Wed, 29 Apr 2026 06:47:43 +0000

As a long-time Linux enthusiast and a heavy hitter on the keys, I’ve always been fascinated by the underlying architecture of our tools. Recently, my MacBook Pro met its match—I managed to physically break one of the keycaps.

A quick trip to the Apple Store ended with a quote that made my jaw drop: $400 to replace the entire top case assembly. For a hacker used to "building and breaking," this didn't sit right. I decided to embrace the DIY spirit and handle it myself.

I spent about 30RMB ($4) buying a full set of replacement keycaps from Taobao.com. I thought this was going to be a "level 1" repair, but a single mistake quickly turned it into a "boss fight."

The Incident: A Lesson in Chemistry and Adhesives
At first, I thought only the keycap was broken. After a failed attempt to force it back on, I realized the butterfly hinge underneath was damaged. In a moment of misplaced confidence, I grabbed a bottle of Super Glue (502).

The second that drop hit the board, I knew I had messed up. Super glue is fast-acting, low-viscosity, and highly corrosive to certain plastics. It didn't just bond the hinge; it seeped into the base and melted the precision elastic membrane responsible for the key's tactile feedback.

The result: The 'J' key was dead. No travel, no click, just a solid block of plastic. This is what happens when you ignore the physical properties of your materials.

Structural Analysis: The Precision of the Butterfly Design
Since I had already "bricked" the base, I decided to perform a full "autopsy" to understand the mechanics. Despite the frustration, the engineering is remarkably sophisticated:

Logic Board (PCB): The bottom layer, handling circuitry and LED backlighting.

Butterfly Hinge: Two interlocking wings that sit between the PCB and the base.

The Base: The critical component. It snaps into four tiny notches on the PCB, holds the hinge in place, and houses the metal dome for tactile feedback.

Keycap: The outer shell that clips onto the top of the hinge.

The tolerances here are incredibly tight. Even a microscopic amount of excess glue can paralyze the entire movement.

Tooling Up: Finding the Perfect "Surgical Glue"
To fix the melted base, I needed an adhesive that met three hardcore requirements:

Needle-fine Applicator: Total control at the millimeter level to avoid the contact points.

Material Safety: Non-corrosive to delicate plastics.

Slow-Curing: Allowing time for precise alignment and error correction.

I eventually found B7000, a specialized adhesive used in smartphone repairs. Its needle-nose tip allowed for the precision I desperately needed.

The Ultimate $4 Fix (Step-by-Step)
Materials Required:
Replacement Base + Hinge ($2)
New Keycap ($1)
B7000 Adhesive ($1)

The Repair Process:

1.Debridement: I used tweezers to painstakingly peel off the damaged, glue-crusted base from the PCB.

2.Precision Grouting: I applied three tiny dots of B7000 (about 2mm wide) on the PCB, strictly avoiding the center sensor and the top LED.

3.Assembly: I snapped the hinge into the new base first, then aligned the base with the four PCB notches and pressed down.

4.Verification: I tapped the center of the base to ensure the character appeared on the screen with a clean rebound.

5.The "Cure" (Crucial!): Do not snap the keycap on yet. Wait several hours for the glue to fully cure. If you try to snap the keycap on too early, the vertical pull will rip the base right off the board.

6.Final Marriage: Once cured, I snapped the keycap on with a satisfying click.

This experiment taught me that modern hardware is a marvel of integration, where even a tiny key carries immense complexity. While the journey was chaotic, it proved a point: There is no machine that cannot be fixed, provided you understand its logic.

Faced with a $400 repair bill, I chose a $4 fix and a heavy dose of curiosity.

Have you ever had a "minor" repair turn into a major disaster, only to pull off a hardcore recovery in the end? What’s the most "dangerous" thing you’ve ever done to your daily driver?

Stop Backspacing Like a Typist: My "Surgical" Syntax Deletion Tool for Emacs

Andy Stewart — Wed, 29 Apr 2026 03:40:44 +0000

I’ve always believed that a hardcore developer shouldn't waste a single second on low-level chores like "deleting code."

In Emacs, most people delete code by either mashing the Backspace key like they're tapping out Morse code, or using kill-word only to find they’ve overshot and deleted half the expression. While subword-mode fixed navigation for CamelCase, deletion still lacks that critical sense of determinism.

I wanted a tool that combines the raw power of skip-syntax with the granular intelligence of subword-mode. So, I built a plugin for what I call Syntax Block Deletion.

Why "Surgical" Precision Matters
Standard deletion relies on whitespace or generic word boundaries. This tool operates on the logic of your code. By tapping directly into Emacs' internal syntax tables, it achieves a "what you see is what you prune" experience:

Subword Awareness: When it hits FooBarExample, it recognizes Foo, Bar, and Example as distinct entities. You can snip away** Bar** without touching the rest.

Syntax Boundary Intelligence: It automatically senses operators, delimiters, and symbol boundaries. It knows exactly where a logical unit ends, so it won't go charging through your parentheses like a blunt instrument.

Zero-Latency Feedback: Built on low-level syntax skipping, the response is instantaneous. No bloat, just speed.

Arm Your Editor
The implementation is lean and mean. I recommend binding these to your most accessible keys to completely replace your default deletion commands:

delete-block-forward: Instantly prune the next syntax block.

delete-block-backward: Precisely detonate the previous logical unit.

When you're building complex systems like EAF, these micro-efficiencies compound into massive productivity gains. Every keystroke should be deliberate. If you’re still tolerating the uncertainty of "I wonder how much this keypress will delete," your toolchain is overdue for a refactor.

Let's start a discussion:
In a world of highly customizable editors, what other "high-frequency" actions do you think are still fundamentally broken or inefficient? What "secret weapons" have you hidden in your own config to maintain your flow?

See you in the comments, and I'm looking forward to your PRs.

GitHub Repository: [((https://github.com/manateelazycat/delete-block))]

Happy Hacking!

20-Year Linux Veteran: How I Slashed My Emacs Startup Time by 90%

Andy Stewart — Wed, 29 Apr 2026 03:30:17 +0000

As a long-time contributor to the Emacs community and the creator of EAF (Emacs Application Framework), I’ve always maintained one rule: If your development tool takes more than 2 seconds to start, it’s murdering your creativity.

Many developers complain that Emacs is "bloated," but the truth is usually just poorly architected configuration. Today, I’m skipping the fluff and sharing my hard-earned methodology for optimizing startup performance. By following these three steps, you can compress your startup time to 1/10th of what it is now.

1. Stop Guessing: Benchmark Your Config
The first rule of optimization: If you can't measure it, you can't improve it.

Don't blindy disable packages. Insert the following code at the very top of your configuration to use benchmark-init. This recursively analyzes the overhead of every single line in your setup.

`Code snippet
(let (
;; Temporarily set GC threshold to infinity to prevent garbage collection during startup
(gc-cons-threshold most-positive-fixnum)
;; Clear file-name-handler-alist to skip regex matching on every loaded file
(file-name-handler-alist nil))
(require 'benchmark-init-modes)
(require 'benchmark-init)
(benchmark-init/activate)

;; Your core configuration goes here
)After startup, runM-x benchmark-init/show-durations-tree`. This gives you a precise, millisecond-level "hit list" showing exactly which packages are slowing you down.

2. Dynamic Decoupling: Don't Load What You Don't Use
This is a fundamental architectural shift. Many libraries are only needed for specific scenarios—why let them clog your startup path?

Take the noflet library, often used to suppress the "Active processes exist" query when quitting:

The Inefficient Way:

Code snippet (require 'noflet) ;; Loaded at startup, even if you don't quit for days (defadvice save-buffers-kill-emacs (around no-query-kill-emacs activate) (noflet ((process-list ())) ad-do-it))

The Hardcore Way (On-Demand Loading):

Code snippet (defadvice save-buffers-kill-emacs (around no-query-kill-emacs activate) "Only load the library at the moment the exit command is triggered" (require 'noflet) (noflet ((process-list ())) ad-do-it))
By moving require inside the function or using eval-after-loadblocks, you can strip away 50% of unnecessary dependencies from your initial boot.

3. The Ultimate Weapon: Lazy-Loading via Key Triggers
This is my core secret. The logic is simple: Defer the loading of 90% of your plugins until the moment you actually press the key to use them.

The traditional approach is "Load, then Bind." My lazy-load technique flips this: "Bind, then Inject."

At Startup: Only define the keybindings (e.g., Ctrl + c p for project management).

At Runtime: The moment you hit that key, Emacs injects the source code and executes the command instantly.

This reduces your startup process to a list of pure key mappings—the leanest possible configuration.

Top-tier developers demand two things from their tools: determinism and extreme responsiveness.

Optimization isn't about removing features; it's about precise resource allocation. Save your startup time for the work that matters, and keep your "flow" uninterrupted. If you're chasing terminal efficiency, try refactoring your config with these three steps today.

Happy Hacking!

Lightweight Analytics for Jekyll: Why I Chose Hit Kounter Over Google Analytics

Andy Stewart — Tue, 28 Apr 2026 09:31:22 +0000

Privacy and Speed First
As I continue to polish my Jekyll blog on GitHub Pages, I realized I needed one more thing: View Counts. I wanted to know which topics resonate most with my readers, but I had two strict requirements:

No Google Analytics: I don't want my site to be blocked or slowed down by heavy tracking scripts (especially considering accessibility in different regions).

Minimalist Integration: It should be as "plug-and-play" as Jekyll itself.

After searching, I found Hit Kounter. It’s simple, fits perfectly with static sites, and just works.

How to Set It Up in 2 Minutes
1. The Header Injection
First, you need to include the Hit Kounter script in your HTML <head>. Usually, this goes into your_includes/head.htmlfile:

HTML <script src="https://cdn.jsdelivr.net/npm/hit-kounter@0.1.0/dist/hit-kounter.js"></script>

2. Displaying Views on Post Pages
To show the view count for a specific article, just add this tag to your post template (e.g., _layouts/post.html):

HTML <span data-hk-page="current"> - </span> Views

The current attribute automatically detects the current URL.

3. Displaying View Counts on the Homepage
If you want to show the traffic for each post on your homepage index, use this snippet in your index.html loop:

HTML <span data-hk-page="{{ post.url | prepend: site.url | prepend: 'https:' }}"> - </span> Views

Pro Tip: Hit Kounter requires the absolute URL to track accurately. That’s why we use prepend: site.url and ensure https: is explicitly added. Without the full protocol, the counter won't trigger.

That’s All!
Just git push and your analytics are live. No complex dashboards, no privacy concerns, just a clean, simple number that tells you what your audience loves.

It’s another small step toward building the perfect minimalist writing environment.

What are you using to track your static site? Are you a fan of self-hosted analytics or do you prefer these "Zero-Config" tools? Let me know in the comments!

About the Author:
I am Yong Wang, a 20-year Linux veteran and former CTO of Deepin. I’m currently building Little Chinchilla, an AI Agent host designed for private-domain computing. Catch me on GitHub where I spend most of my time hacking Emacs.