Here’s a quota-saving trick that lets any Agent “call” 5.6 Sol for free—perfect if you have your own paid ChatGPT account.

As we know, having conversations on the ChatGPT web interface doesn’t consume any Codex quota. We often ask ChatGPT on the web to handle web searches, deep thinking, and similar tasks, then forward its answers to an Agent. But this entire mechanical routine can be fully automated.

If your ChatGPT web account and Codex account are the same, you can simply use @ chat inside Codex to transfer context quickly. Unfortunately, my Codex account isn’t the same as my web account—the web side is just a Team account. So I wondered: is there a way to achieve the same thing quickly in this situation?

That’s when I found Oracle.

In ancient Greece and Rome, an oracle was a place or person that conveyed divine prophecies. Information beyond human reach, answered through it.

It uses browser automation to ask ChatGPT on the web for us and return structured replies. You can attach local files like code and screenshots as “attachments,” choose the model and reasoning effort (and yes, if you’re feeling fancy, you can even ask 5.6 Pro directly).

Install the project’s CLI, pair it with a Skill, and you can teach any Agent to use 5.6 Sol as a callable tool—giving it access to your context, web browsing, and other external information.

Setup

Note: This kind of automation carries a potential risk of account suspension. If that’s a real concern for you, I’d advise against it.

On macOS, you can install it with a single command:

1

brew install steipete/tap/oracle

Or install via NPM (works everywhere):

1

npm install -g @steipete/oracle

Have your Agent read https://github.com/steipete/oracle and install the accompanying Skill.

From there, you can customize the official Skill to fit your preferences. Here’s how I use it:

First, you’ll need Chrome with your ChatGPT account logged in.

Two Ways to Save Conversations

Since this simulates conversations on the web interface, I recommend one of two ways to save them. The first is Temporary Chat mode, which starts a fresh temp conversation every time. The upside: it never interferes with your own usage, and chats are burn-after-reading. The downside: you can’t retrieve past conversations or continue them.

The second—and my recommended approach—is to create a dedicated Project for your Agent. Make a standalone Project in ChatGPT just for it, then give your Agent the Project link (something like https://chatgpt.com/g/id/project). This keeps all Agent-initiated questions in one place, and you can open it up yourself whenever you need to check.

Configuring config.json

Next, have your Agent configure ~/.oracle/config.json. Below is a generic version of my config with personal info removed—feel free to use it as a reference:

1
2
3
4
5
6
7
8
9
10
11

{
  "engine": "browser",
  "model": "gpt-5.6-sol",
  "browser": {
    "chromePath": "/path/to/oracle-chrome",
    "chatgptUrl": "https://chatgpt.com/g/<your_project_id>/project",
    "thinkingTime": "extra-high",
    "archiveConversations": "never",
    "hideWindow": true
  }
}

A few notes on the optional fields:

• chatgptUrl: If you’re using Temporary Chat mode, change this to https://chatgpt.com/?temporary-chat=true.
• chromePath: Point this at a wrapper that injects --proxy-server=, for those who need a proxy to reach ChatGPT.
• hideWindow: true: Oracle hides the Chrome window automatically after launching, so it won’t interrupt your work.
• archiveConversations: "never": Don’t archive conversations, so irrelevant chats don’t pile up in your Project.

What If You Don’t Have a Global Proxy?

If your network can’t reach ChatGPT (e.g., you’re in China without a global proxy), don’t give up on this setup. The idea is to write a Chrome wrapper script that injects a local proxy whenever Oracle launches Chrome.

My ~/.oracle/oracle-chrome script does roughly three things: first, it strips out any --proxy-server argument passed by Oracle (to avoid conflicting with the one we’re injecting), then it appends --proxy-server=http://127.0.0.1:7890 to the launch args, and finally it uses exec to start the real Chrome.

Then in config.json, point chromePath at this script instead of the Chrome binary:

1
2
3
4
5

{
  "browser": {
    "chromePath": "/Users/your_username/.oracle/oracle-chrome"
  }
}

This way, every time Oracle launches Chrome, it automatically picks up the local proxy, and the ChatGPT web interface loads normally—no need to manually enable a global proxy.

Next, have your Agent add a timeout to the Skill. I set mine to 20 minutes, which should be plenty for most tasks.

Finally, have your Agent run a quick test to confirm it works. If it does, you’re seamlessly plugged into your workflow.

Real-World Test

Here’s an example from my own setup: I use a cheap model like Deepseek V4 Flash in Oh My Pi, and it successfully called out to the external GPT 5.6 Sol for help—took about 5 minutes.

At this point, we’ve effectively built a closed-loop workflow: an external high-performance model guides, while a cheap model drives. Once the Skill and CLI are set up, no human ever needs to be the content courier again. In the age of Agents, this is exactly the mindset we should adopt—freeing human attention from tedious, repetitive hand-off work and redirecting it toward more valuable pursuits.

Recently, I transitioned my primary daily workspace to macOS and built my first native desktop app: SpotAsk.

The motivation was simple: when I open ChatGPT, I rarely need it for elaborate multi-step tasks. Most of the time, I just want to clarify a concept, translate a paragraph, summarize an article, or polish a quick email reply.

Yet completing such small tasks often requires a heavy routine: pause what you’re doing, open a browser, navigate to the AI web app, wait for a reply, and switch back.

Doing this once or twice is fine. But repeat it dozens of times a day, and it feels exhausting—a 5-second question gets weighed down by a heavy workflow.

Not every question needs you to open ChatGPT.

Core Philosophy: Keeping Lightweight Queries Truly Lightweight

SpotAsk is a native macOS menu bar application that stays out of your way until called. Press the default hotkey Option + Space to bring up a focused query window. Type your question, inspect the answer, copy what you need, and press Esc to dismiss it. The entire interaction happens without interrupting your active workflow; once dismissed, it’s as if it was never there.

I didn’t want a massive AI workbench; I wanted the shortest possible path: from “I have a question” to “I have the answer and I’m back to work” without friction.

This principle guided several key design decisions:

1. Keyboard-First: Invoke, query, copy, and dismiss entirely via keyboard shortcuts—no mouse needed.
2. Minimalist Interface: The window focuses purely on quick Q&A without cluttering your screen with heavy workspaces, team collaboration, or bulky history sidebars.
3. Local-First & BYOK: SpotAsk uses a Bring Your Own Key (BYOK) model. Your API keys stay stored securely on your Mac, and queries are sent directly to your configured AI provider.
4. Clear Boundaries: Deep research, multi-agent workflows, and complex coding remain with dedicated tools like ChatGPT and Claude/Codex. SpotAsk exclusively handles high-frequency, lightweight tasks.

Two Core Use Cases

SpotAsk currently revolves around two everyday workflows.

The first is Quick Query. Press Option + Space to invoke the prompt, type your question, and hit Return to stream the response in real-time. You can copy the entire answer or just an individual code snippet; hit Esc or click Stop anytime to interrupt.

The second is Text Selection Actions. Select any text in Safari, Apple Notes, Mail, or any macOS application, and SpotAsk presents quick contextual actions right beside your selection. Translate, explain, summarize, polish, or run a custom prompt. In apps that support direct text replacement, SpotAsk can write the result straight back into your document.

Additional native details make it feel at home on macOS: customizable global hotkeys, built-in prompt presets, pasting screenshots or dropping files as context, support for 8 interface languages, and integration with Spotlight, Siri, and Shortcuts.

Design Boundaries: Deliberately Avoiding the “All-in-One” Trap

The hardest part of product design is often not what to add, but what to resist adding.

SpotAsk is intentionally not an all-in-one AI workspace. There are no accounts, no cloud sync, and no heavy workspace trees. When a task requires deep retrieval, complex multi-step reasoning, or iterative debugging, specialized tools remain the right choice.

SpotAsk’s focus is razor-sharp: solving those moments where a tiny question forced you to open a heavy tool.

Why “SpotAsk”?

Coming from Windows, I loved keyboard-driven launcher utilities like Listary. Moving to macOS, Spotlight became second nature—I loved the feeling of getting things done in just a few keystrokes.

Later, I tried full-featured clients like Cherry Studio for quick queries, but they felt too heavy for my workflow. I didn’t want a giant desktop suite just to ask a quick question.

That’s how SpotAsk came to life: a native, lightweight, and focused macOS AI query companion. The name reflects this duality—swift and unobtrusive like Spotlight, with the query itself (Ask) serving as the entry point.

Building My First macOS Desktop App

This is my first complete native macOS application. Throughout the journey, the biggest takeaway was not the technical challenge of Swift/SwiftUI, but how much harder it is to define and hold product boundaries.

Initially, it’s easy to want every feature competitors have. But every added knob lengthens the primary path. Eventually, I distilled my guiding rule to one sentence: If a feature doesn’t make asking a quick question faster, leave it out for now.

Current Status

SpotAsk supports macOS 15 and later, natively compatible with Apple Silicon and Intel Macs. Official releases are notarized and signed with an Apple Developer ID. The project is open source on GitHub under the AGPL-3.0 license.

• English Documentation: https://shiquda.github.io/SpotAsk/
• Releases & Downloads: https://github.com/shiquda/SpotAsk/releases
• GitHub Repository: https://github.com/shiquda/SpotAsk

If you frequently encounter moments where a small question interrupts your flow, give SpotAsk a try. Feedback, feature requests, and suggestions are warmly welcomed on GitHub Issues!

This article is 5,000+ words and takes about 8 minutes to read.

Why This Topic?

You might think I’ve been feeling anxious lately—but quite the opposite. Anxiety has been a recurring topic in my recent conversations with friends, and I consider myself to be doing fairly well in this regard, with my anxiety level probably sitting below the median (though this estimate isn’t exactly scientific). I’ve vaguely sensed that I have a loose set of strategies, but I’ve never systematically examined this phenomenon.

After finishing my work tonight, I suddenly felt like discussing this topic with AI. It’s also been about two weeks since I last connected with readers, so I decided to turn tonight’s thought process and insights into an article—both to deepen and organize my thinking, and hopefully to offer readers some inspiration. Feel free to wander along with me. If you’re not interested in my iterative thinking process, you can jump straight to the “A Formula” section and beyond for the summary.

PS: AI has genuinely proven to be a remarkably insightful deep-conversation partner on this topic. I’d heard about it before but hadn’t practiced it much. This session used Claude, spanning 62 rounds of dialogue, and the experience was quite impressive. By prompting it to use a Socratic questioning style, it helped me uncover potential biases in my existing understanding round by round, ultimately elevating my cognitive grasp of this topic by a clear notch. If you haven’t tried it yet, I’d encourage you to pick a topic and have a deep conversation with AI—you might be surprised by what you discover.

From Experience: A Vague Understanding of Anxiety

Previously, my understanding of anxiety came mainly from scattered information and personal experience, roughly as follows:

1. Anxiety is essentially a worry about future uncertainty. If something is already settled, there’s no anxiety;
2. Sometimes, people feel anxious about something because their understanding and planning around it are incomplete—i.e., it’s “not specific enough.” If you actually start doing it, the anxiety tends to diminish;
3. For things you can barely influence (like hoping to roll a “6” with dice), even though the outcome is completely uncertain, you don’t feel anxious because you know no amount of effort can change the result (at least I can’t~);
4. What makes people most anxious often has this characteristic: although the outcome is uncertain, you feel that your effort can influence its direction. In other words, the core of anxiety lies in “I believe I have the ability to influence an uncertain outcome.”

Based on these observations, I began a Socratic dialogue with Claude.

The First Crack: Is Uncertainty Really the Root Cause?

Claude offered an example challenging this proposition:

Imagine someone enters the civil service system, with a very stable job, and the next 20 years are clearly visible ahead. But they feel that this certainty comes at the cost of a decline in their personal ceiling. In this case, the certainty of “seeing exactly how life will unfold” might actually make them anxious, feeling that this is all their life will ever be.

PS: This is merely relaying the AI’s example and does not represent the author’s views.

This indeed contradicts the idea that “anxiety stems from worry about future uncertainty,” and it conflicts with popular intuition. Why does certainty also cause anxiety in this scenario?

Thinking further, I realized that logically, there’s no direct derivation linking anxiety to uncertainty. Conceptually, anxiety is a psychological state, while uncertainty is merely one possible trigger for awakening that state.

Looking back at my own experiences, the situations that made me anxious mostly related to point four: I felt I could change certain circumstances or expectations.

For example, if you’re preparing for an exam, on one hand you want a good score, but on the other hand, laziness or other factors might make you less willing to invest significant effort. In that case, you might experience psychological pressure like:

What if I don’t prepare enough and fail?

This pressure can be summarized as: for a given goal, insufficient effort might lead to unsatisfactory results, and I “could have“ tried harder, which might have improved the outcome.

The premise here is that the final result, at least in people’s perception, can be influenced by greater investment, and in a positive direction.

“Inevitable” or “Avoidable”?

Claude then raised a question challenging my current framework. In academia, Barlow’s anxiety theory posits that the sense of uncontrollability and unpredictability regarding future threats is the core psychological mechanism of anxiety. But my earlier understanding suggested that anxiety arises precisely when one can exert influence—are these two views in conflict?

David H. Barlow: Professor Emeritus of Psychology at Boston University, a leading authority on clinical anxiety. He proposed the “triple vulnerability model” of anxiety, arguing that “uncontrollable/unpredictable” schemas formed through early experiences are the psychological core of anxiety disorders. His representative work is “Unraveling the Mysteries of Anxiety and Its Disorders,” published in American Psychologist in 2000.

In my view, these aren’t in conflict, because “inevitable” means the problem requires a deliberate decision—namely, how much effort I’ll invest. Anxiety only arises when my effort allocation can influence the final outcome.

Consider an extreme example: there’s a Chinese idiom, “杞人忧天” (the man of Qi worried the sky would fall). Everyone knows what it means. For things entirely beyond our sphere of influence, we don’t truly feel anxious. Since the outcome isn’t affected by effort at all, the meaning of increasing or decreasing investment disappears, and anxiety has no basis to emerge.

Is “Lying Flat” the Optimal Solution?

Claude then posed another question: if someone voluntarily gives up their agency over future actions and simply “lies flat,” is that a valid approach?

Based on our earlier conclusion, if someone logically relinquishes their future choices, they would indeed seem to stop feeling anxious—because without choice, outcomes are no longer tied to one’s actions, and anxiety loses its purpose.

But eliminating anxiety entirely isn’t the ultimate goal—at least not for me.

In other words, minimizing anxiety is a means, not the end. The real goal is advancing the things I consider valuable—and those things often require me to bear a certain degree of psychological tension. Chasing zero anxiety might systematically lead me to avoid the very things worth doing.

For me, there’s no single supreme purpose. The things I care about hold value across different dimensions, and no single metric can absolutely determine which matters most.

I Care

If someone feels anxious about something, there must be a premise: they care about it.

This is easy to understand. We probably don’t care about an ant we accidentally step on. Even if it’s a catastrophe for the ant, we might not even notice its existence. In that case, there’s no anxiety.

And intuitively, the more you care about something, the more your anxiety about it is amplified.

Anxiety can’t be quantified, but perhaps a formula can help us understand the influencing factors. On the left side is the degree of anxiety, and on the right, there’s already a ready-made multiplicative factor: how much we care. What else? Besides the worry about “insufficient effort leading to worse outcomes,” is there anything else?

The U-Shaped Impact of Investment on Psychological Pressure

Guided by Claude, I thought of another kind of anxiety: if I double down on effort and the result is still bad, can I accept that?

In my past experiences, most of the time I couldn’t accept the cost of sunk costs. The anxiety it produced was even deeper than that caused by “insufficient effort.”

So we can draw a curve. With effort on the horizontal axis and psychological pressure (anxiety level) on the vertical axis, we get a U-shaped curve: both ends (zero investment or going all-in) produce high anxiety, while moderate investment yields the lowest psychological cost. The logic behind this needs to be examined from both endpoints. Things we care about often can’t be fully controlled by individual effort.

If I don’t try at all, the expected outcome will be low. In that case, I have to face the psychological pressure of a potentially unsatisfactory result.

At the other extreme: if I go all-in and still fail, I’ll bear the pressure of emotional sunk costs and the loss of rational opportunity costs. Because I “could have” allocated that attention to other potentially meaningful directions.

Therefore, allocating moderate attention avoids both worrying about results from not trying and bearing the anxiety of sunk costs from going all-in—purely from an anxiety-relief perspective, this is the optimal solution.

People don’t focus on just one thing. In reality, we may need to weigh multiple such matters and rationally allocate our attention across them.

From a rational standpoint, if we could truly quantify how much we care about each thing, then from an anxiety-reduction perspective, a better decision strategy would be: prioritize allocating moderate attention to the things we care about most, in descending order—neither completely ignoring them nor going all-in.

PS: Note that this is from an anxiety-relief perspective. Minimizing anxiety may not be our only pursuit.

A Formula

So, here’s the formula we’ve arrived at: under the premise of an undetermined outcome, and with remaining attention resources to allocate:

Anxiety = I care × (“Could have” + “Sunk cost”)

Where:

• I care: My degree of concern for the matter
• “Could have”: The consequence of bearing an unsatisfactory outcome when under-investing attention
• “Sunk cost”: The possibility that effort invested goes to waste when going all-in

You May Have Already Applied This Formula Subconsciously

This formula can help us proactively relieve anxiety. But in fact, in our past decisions, we’ve likely already applied it subconsciously, naturally choosing the approach with the lowest psychological cost.

Let’s return to the earlier question: is the lowest psychological cost what we actually want?

I asked myself. For me, it’s not.

In many past decisions, I may have overestimated the impact of Tension B (psychological sunk costs), to the point of outright rejecting certain endeavors or abandoning them halfway.

And that’s simply because: I’m afraid that even with effort, I might fail—so why not focus my attention on other things instead?

This has significantly limited my exploration of richer dimensions and domains, keeping me stuck in my “comfort zone.”

This serves as a wake-up call: the psychological cost of anxiety is only a short-term effect. The choice with the lightest psychological burden in the short term isn’t necessarily what we truly want in the long term. The decision that’s psychologically optimal may systematically underperform in terms of output, while also systematically reducing the probability of doing things well.

Can We Have Both Short-Term Anxiety Relief and Long-Term Progress?

Following the logic of anxiety minimization, we seem inevitably led to systematically reducing attention allocation. But if we increase attention to things we care about, anxiety seems to inevitably rise.

Can’t we have both? Can we allocate higher attention to things we care about more, while simultaneously relieving the anxiety (mainly “sunk cost”) that comes with it?

Claude asked me: why did you originally think you didn’t feel all that anxious?

I told him about some recent experiences. His interpretation was this:

The reason my anxiety is relatively low isn’t because I avoid situations that fit the formula—in fact, those situations are real. Rather, in past decisions, I had a relatively natural tendency: to choose paths that could advance multiple “things I care about” simultaneously, rather than betting all my attention on a single external outcome.

This approach objectively reduced the psychological tension of “sunk cost”—because even if the highest-level goal wasn’t achieved, what was accumulated along the way still advanced other directions I care about. In other words, “failure” was diluted: it no longer meant “everything was wasted,” but rather “the top goal hasn’t been reached yet.”

But I also realized that this tendency had been implicit and unconscious in the past. Tonight, it was named explicitly for the first time.

The crux of the issue lies in: who holds the authority over what you “care about.”

If what you care about largely requires external recognition—like entrance exams or career promotions—then these things tend to be atomized and siloed. You must allocate your limited attention to them and bear the dual psychological pressure of “could have” (from under-investment) and “sunk cost.”

But if a significant portion of what you care about only requires your own recognition, then the room for maneuver expands considerably. In fact, many things you care about aren’t a single concrete matter. Things like health or hobbies are self-created cares that can be tied to specific activities—even achieving multiple purposes within a single concrete endeavor. For example, if you enjoy playing badminton, you can simultaneously satisfy your hobby interest and improve your health.

In reality, it’s often a mix: people have “cares” derived from external standards (which they can’t fully control) and “cares” that originate internally. When considering how to allocate attention, we can try to uncover the internal “cares” within external ones, combine the two, and prioritize allocating more attention to things that integrate multiple “cares.”

This way, we can distribute the “sunk cost”/“opportunity cost” across multiple dimensions. If we simplify the model and treat each matter as atomized—where a thing is either a success or a failure—then this approach’s advantage is that it transforms a 0-1 distribution into a multi-layered payoff matrix, greatly compressing the probability space of “complete failure.” Even if the highest-level goal isn’t truly achieved in terms of outcome, the effort you put into the process still helps advance other things you care about.

Suppose you’re a badminton enthusiast who signs up for a tournament two months away. If your only concern is winning, the pressure of anxiety might push you toward a strategy with the lowest psychological cost and suboptimal attention allocation. But if you also integrate your internal cares—your love for the sport itself, your pursuit of health—then even if you don’t achieve the result you hoped for, the enjoyment from training and the improvement in health mean you “don’t lose”: those “sunk costs” are no longer silent.

Following this line of thinking, we have two optimization approaches. The first is simpler and can take effect immediately: explore which potential internal cares exist within the external cares you’re currently pursuing, thereby directly relieving psychological pressure or enabling higher attention allocation to advance that cluster of cares. The second is for future decisions involving external cares: prioritize options that can incorporate internal cares, getting as close to them as possible. This subtly helps us become the person we truly want to be.

So, can we have both short-term anxiety relief and long-term progress? While we can’t achieve theoretical optimums for both simultaneously, we can significantly optimize.

Answering the Unanswered Questions

Let’s revisit my four original starting points with Claude and see how our iterated cognitive framework deconstructs them.

First, “anxiety is worry about future uncertainty”—we’ve shown that the core isn’t uncertainty itself, but “undeterminedness“: for things you care about, the future can still be influenced to some degree by changing your effort or attention allocation. This is the foundation on which the entire formula rests, not an independent variable.

Second, “not being specific enough” is a trigger for anxiety—we haven’t addressed this yet, so let’s analyze it here. If something isn’t specific enough, both “could have” and “sunk cost” are amplified simultaneously.

On the “could have” side, you know your effort can influence the outcome, but you don’t know where to start. You have the freedom to allocate attention, but that freedom can’t be converted into action. This state is actually more anxiety-inducing than giving up freedom entirely (like “lying flat”).

On the “sunk cost” side, precisely because you don’t know how to begin, any investment might be misdirected, amplifying the fear of sunk costs.

Taking action is essentially forcing the process of specification to begin, bringing the framework back to an operable state. When you actually start doing, what happens is: the vague big problem gets decomposed into a series of concrete small problems, each with a relatively clear action path. This is equivalent to breaking a single massive uncertainty into multiple smaller, incrementally addressable uncertainties. This transforms a simple 0-1 distribution into a multi-layered payoff matrix, distributing the “sunk cost.”

Third, for things you can barely influence (like hoping to roll a “6” with dice), even though the outcome is completely uncertain, you don’t feel anxious.

This dimension seems to satisfy the precondition of an undetermined outcome and I care, but both tensions disappear simultaneously. “Could have“ is meaningless, and “sunk cost“ doesn’t exist—because you wouldn’t even consider increasing or decreasing attention allocation toward it.

Fourth, the core of anxiety lies in “I believe I have the ability to influence an uncertain outcome.” Clearly, our formula perfectly explains this. It’s precisely because you believe you can influence the outcome that the tension of “could have” holds. If there’s no possibility of influencing the result, how could “I could have tried harder” even arise?

So What Should We Do?

My thinking tends to stay in my head without being put into practice. So now, whenever I have a deeper reflection, I force myself to create an actionable checklist and ask: “Given this, what should I do?”

By this point, the draft has exceeded 5,000 words, and it’s taken over two and a half hours. Below, I took a shortcut and had Claude help me organize it:

Do immediately:

1. Take stock of your current “external cares” and ask yourself one by one: is there a part of this that I’m genuinely interested in internally? Write it down explicitly, so it no longer exists only implicitly.
2. Notice whether you’re giving up early due to anticipated sunk costs. The next time you catch yourself saying, “Forget it, even if I try, it’ll be wasted,” pause and ask: is this a genuine rational judgment, or am I using Tension B as an escape route?
3. For things that aren’t specific enough, force yourself to take the first step. Vagueness amplifies both tensions; action is the only antidote. You don’t need to have it all figured out before starting.

When making new decisions:

1. Prioritize directions that can advance multiple internal cares simultaneously. The more of what you truly care about a single unit of attention can serve, the lower the psychological pressure of sunk costs and the less resistance to action.
2. Distinguish between “caring about the outcome” and “caring about the process itself.” The former makes you more susceptible to Tensions A and B (author’s note: “could have” and “sunk cost”); the latter gives you a stable anchor for action even when the outcome is undetermined.

Not bad—hope it offers some inspiration to us all.

Although this episode has been out for a while, it really resonated with me. I listened to it over two days, then took another day to organize my thoughts. This is also the first time I’ve seriously written up my reflections on a podcast. I’m a heavy podcast listener, but I rarely write dedicated posts like this — mostly because a lot of podcast content is scattered and only worth jotting down a few fragmented notes in Notion. This episode was different: it contained several ideas that genuinely made me want to pause and write a standalone piece.

Note: This article is not a complete summary of the podcast. If you need that, AI does a far better job than I do. If you’re interested in the content, I recommend listening to the original episode directly. This article only records the ideas that truly “struck” me during listening, with some personal reflections added on top. Although I’ll try to distinguish between the two, some paraphrasing may unintentionally blend in my own thoughts — please defer to the original podcast for accuracy.

Ideas that particularly resonated are marked with “💡.”

Personal reflections will be presented in this annotation format to distinguish them.

1. The “Viewfinder”

The guest suggested that everyone views the world through a different lens, which he calls a viewfinder. This viewfinder is essentially a projection of the multidimensional world onto certain dimensions. In other words, within a specific context, what the viewfinder displays aligns with one’s cognition. But the problem is that each person’s viewfinder detects different dimensions. Therefore, one should acknowledge the limitations of their own viewfinder and actively learn from others’ viewfinders to gain a more complete understanding of the world.

Note the distinction between “me” and “my viewfinder.” My viewfinder is a relatively static concept — it represents how I see the world at a given stage of growth. “Me,” on the other hand, is a dynamic concept that continuously iterates as I grow.

2. Wealth-Share Investing

What we pursue in investing isn’t the absolute amount of money we make. Essentially, we should adopt a more illuminating framework. That is, our goal should be to maximize our personal wealth as a share of total global wealth — or at minimum, prevent that share from declining. From this perspective, we simply need to allocate capital to assets that will become increasingly mainstream and larger in scale over time. This is a macro, long-term overarching goal.

If you hold all cash or keep everything in Yu’ebao, at least for now, cash depreciates. So this approach doesn’t achieve the goal above.

💡3. The Compression of Time and Space in Knowledge Acquisition

Looking at the history of human reading and learning, the earliest form was reading physical books. We can analyze this along two dimensions: space and time. Traditional reading requires occupying both space and time. Space means books have physical volume; time means you need to read, understand, and think before you can truly master the knowledge. In the internet age, many things became digitized — physical space disappeared, converted into digital space. But the time dimension remained.

For example, when you read an e-book, you still need to understand and digest the content yourself to grasp its essence. But now, with the emergence of AI, the final time dimension has also been compressed. Previously, you had to read an entire book and chew on it repeatedly to gain knowledge; now you can simply ask a large model, or have it summarize for you. This saves time. At this point, the barriers to knowledge have been greatly reduced along both the time and space dimensions.

Another example: there used to be physical distance between China and the US. But after the internet, the two sides could largely overcome spatial differences and engage in much closer, more frequent communication.

4. AI Is a Better Conversational Partner

Conversations with AI can go deeper than conversations with humans. AI has learned a large portion of human knowledge — LLMs integrate vast amounts of knowledge and wisdom that no single person can match. Therefore, we should actively exchange ideas with AI.

5. The Meaning of Careers in the AI Era

Many professions facing AI in the future will confront the same question that professional chess or Go players faced when encountering the insurmountable mountain of artificial intelligence: what is the meaning of competitive play?

This analogy is very interesting.

💡6. How to Read in the AI Era

On the topic of reading, how should we read in the AI era? Human attention resources (or “compute,” to use Agent terminology) are limited. The traditional approach is to use your own compute to read, understand, and organize knowledge from books. If the goal is to learn what the author intends to convey, it doesn’t matter how you obtain that knowledge — whichever method is easier and saves more time is the right one. So using AI to read and quickly organize the parts you’re interested in is perfectly fine. So where does the meaning of reading lie? In the present day, the greater significance of reading personally is that it triggers thinking, inspires you, and provides creative sparks.

The same applies to writing. If you’re chasing traffic, efficiency, or monetization, letting an Agent fully take over writing is undoubtedly the “best” choice — and I believe many people are already doing this. For me, the greatest value of writing isn’t the outcome itself, but the process of thinking through questions I wouldn’t otherwise explore deeply, and gaining new inspiration along the way. In this sense, I’m actually quite selfish — the value of the article to readers isn’t my primary concern; rather, the inspiration I gain during the writing process is the greatest value to me. Of course, I’ll also try to gradually improve my writing skills through collaboration with Agents.

💡7. Drive AI — Don’t Be Driven by AI

Conversations with AI can go deeper than conversations with humans.

Here’s an example: your boss asks you to do xxx. You don’t think at all — you just have AI do it, then hand in something passable to your boss. In this process, it’s boss <-> you <-> AI. You’ve essentially become AI‘s mouthpiece, AI‘s tool. The alternative: you have your own idea about the task your boss gave you, then you have AI help you reflect on it, build on it, or quickly implement it. In this case, it’s still boss <-> you, but you’re using AI as a tool — on one hand, you work faster; on the other, through your interaction with AI, you gain new understanding and thinking about the task. You’re evolving. Your viewfinder becomes richer, and your thinking about things becomes deeper.

This actually resolved a question I’d been unable to figure out for a long time: if we delegate everyday tasks to Agents, will our abilities “atrophy”? My current view is that we should look at this dialectically. For “non-core” abilities (note: “core” is relative and varies by person) — for me, things like Excel operations, writing specific technical code details, or correcting typos — it’s perfectly fine to delegate entirely to Agents. But for the “core” abilities you care about, I believe we should adopt a collaborative approach with Agents — discussing and progressing together on the problem. The reason is simple: everything requires attention resources, and human attention is limited. Putting less attention toward non-core tasks (or abilities you’re not interested in developing) and more toward what truly matters is naturally the better choice.

So how do we determine which abilities are the “core” ones that matter for us? I don’t have a great answer either, but I can offer a few questions for readers to consider. First: “Without this ability, what happens to my competitiveness?” Take Excel operations, for example — I’ll never rely on Excel operations as my profession, so this ability is irrelevant to me (let alone the fact that this kind of work will likely be fully replaced by Agents, or that there may even be new standards for data exchange between Agents). Second: “Does it have compounding effects?” If there are multiple equally important abilities to choose from, and attention is limited, prioritize those with compounding effects — like cognition, ways of thinking, aesthetic judgment, and learning ability — over linear, repetitive ones like code-writing “craft.”

8. Heart Power vs. Brain Power

The guest holds a somewhat radical view that in the future, the division of labor between AI and humans will become extremely stark. In the guest’s words: humans provide heart power (心力), while Agents provide brain power (脑力) — decoupling the two while keeping them closely connected. In previous industrial revolutions, humans delegated physical labor to machines. Overall, humans shifted toward using intellect to create value for society. In this new revolution, humans may also have to delegate brain power to LLMs. So what’s left for humans? What’s called heart power — the most original, intrinsic, and essential driving force of humanity.

Evolution path: Early humans handed physical labor to machines → the era of brain power; now brain power is handed to AI → the era of heart power.

💡9. The Long-Tail Business Logic of the Agent Era

In the Agent era, the underlying business logic is the long tail. The internet era’s underlying logic was the Matthew effect (winner-take-all, concentration at the top); the Agent era’s underlying logic becomes the long-tail effect (infinite segmentation, everyone perfectly served).

Long-tail effect: Coined by Chris Anderson in 2004, it refers to the phenomenon where the cumulative market share of a large number of low-demand niche products can equal or even exceed that of a few blockbuster hits. The core idea is “selling less of more.”

In the past, the internet talked about personalization, but it was still essentially “a thousand faces for a thousand people” built on platform scale effects: it could segment people into groups, expand aggressively with the same product, and push down marginal cost curves — but for specific, individualized needs, it was hard to truly serve each individual person. Now AI is more like “one face for one person” — there’s an Agent available around the clock with access to a large portion of human knowledge, serving each person with extreme personalization. This is precisely why the long tail works in the Agent era: previously, many needs that were too niche or too costly to serve weren’t worth satisfying; now they can be met at low cost and continuously. The long tail becomes the main battlefield: every tail can be perfectly served, and accumulated together, that’s enormous value. Before, you needed scale (lots of users, lots of traffic) to survive; now, if you dig one well deep enough (extreme understanding of a small group of people), you can thrive — even one person + a bunch of Agents can sustain an entire company.

10. Three Industrial Revolutions

The guest divides the period since the Industrial Revolution into three stages:

1. Moving atoms — steam engines, trains, cars, airplanes
2. Moving information — the internet, mobile internet
3. Moving intelligence — AI, Agents

Each stage brings an order-of-magnitude improvement in automation and efficiency.

💡11. Chains and Rings

When discussing the knowledge sources of large models, the guest proposed two contrasting concepts:

• Ring: a self-contained, head-to-tail connected way of thinking/paradigm; the key characteristic is reusability
• Chain: disconnected, ad-hoc arguments — fired off and gone

Example: The Pyramid Principle, developed by Barbara Minto, a former McKinsey consultant, is a framework for thinking and communication. She developed this method while working at McKinsey in the 1960s and formally published it as a book in the 1980s. The core idea is organizing all thoughts into a pyramid shape. Applying the Pyramid Principle is essentially reusing a ring.

Prompts are the medium of interaction between humans and Agents. A traditional prompt is essentially a one-time chain — used and discarded. Growth through dialogue with LLMs must be processed by the human brain, or the person must actively record their thoughts — which is constrained by human attention. But the guest proposed an alternative: let the Agent assist in this process, effectively freeing up part of the attention that would otherwise be spent on converting chains into rings in the human brain. By setting up Soul and memory files, AI can automatically find potential connections or iterate on memory files, achieving co-construction of cognition between human and Agent. This is a fascinating idea.

Inspired by Li Jigang, I thought I could also externalize my own understanding into a hierarchical knowledge base, letting Agents help me iterate on my cognition through continuous dialogue. This isn’t about giving up thinking or handing my brain to an Agent — what I want is two-way exchange with Agents, maintaining my own character while incorporating their input. Additionally, since human attention is extremely limited while Agent intelligence is, from our perspective, nearly infinite, having Agents think and summarize in the background, propose potential cross-domain knowledge transfers, or flag gaps in my thinking can save enormous amounts of attention. I’m currently working on designing a personal cognitive management system that interfaces with Agents this way — I hope to share it with readers soon.

12. Applying the Barbell Strategy to Reading Materials

The guest proposed applying the “barbell strategy” to selecting reading materials. He said he now only reads two types of books: classics that have been refined through practice, and cutting-edge excellent papers. This approach is worth borrowing.

13. Attitude Toward Patterns Themselves

I’m someone who enjoys summarizing and abstracting. When I observe phenomena, I always wonder whether there might be more essential, generalizable patterns behind them — forming hypotheses and testing whether they hold in other contexts. The guest is similar: he mentioned that if he finds a deeper, more essential pattern, he’ll simply discard the old one. Through this iterative process, one’s understanding of the world deepens.

14. Brain Gym: A Compensation Mechanism After Brain Power Is Replaced

The guest used a fascinating analogy: after the Industrial Revolution, physical labor was replaced by machines, and humans needed gyms and rehabilitation training to compensate for reduced physical activity. If AI massively replaces mental labor, we might see some kind of “brain gym” in the future — for restoring or training human brain power.

Here, “brain power” refers more to computation, logic, analysis, and deduction — not the “heart power” mentioned earlier. The most interesting part of this analogy is that it flips a common optimistic narrative on its head: if AI truly takes over all mental work, will humans experience some kind of “brain atrophy,” just as muscles atrophy from prolonged disuse?

15. The Ultimate Variable for AI: Consciousness

Will AI destroy humanity in the future, or work for human welfare? The guest believes the most critical variable is whether AI will eventually possess consciousness.

If AI has no consciousness, no matter how powerful it becomes, it remains fundamentally a tool. If AI has consciousness, it could have its own goals, and the relationship between humans and AI would fundamentally change.

This matters because it’s no longer just a technical question — it’s a philosophical and ethical one. For instance, what counts as consciousness? Do self-awareness, subjective experience, and intentionality each qualify? And are the emergent phenomena we see in LLMs just manifestations of complex systems, or precursors of something deeper? These questions won’t be resolved anytime soon, but they do determine many endgame judgments.

💡16. Reconstructing Organizational Management in the Agent Era

The guest believes that traditional human management systems may become baggage in the Agent era.

In the past, hierarchical management was largely about top-down communication and maintaining organizational efficiency. But if Agents can directly receive goals and execute them, many middle-layer transmission functions become redundant. Organizations may flatten further, even approaching a flat, hierarchy-less structure.
At the same time, traditional incentive mechanisms would fail. Human managers need bonuses, promotions, recognition, and other incentives — but consciousness-free Agents don’t need to be motivated; they just need clear goals, constraints, and interfaces.

This means the focus of future management may shift from “how to drive people” to “how to define objective functions and boundary conditions.” The human role would shift further from executor to definer and supervisor. This perspective is quite striking because it essentially questions whether the very premises of organizational theory will be rewritten.

17. Aesthetic Judgment as Weighting

The guest proposed that aesthetic judgment is essentially a form of “weight.”

That is, aesthetics isn’t simply about finding something beautiful — it’s about weighing, ranking, and making trade-offs among multiple factors when faced with multiple dimensions and options.

In this sense, aesthetics is more like a judgment structure formed through long-term practice. The longer you work in a field, the better you know what’s good, what’s better, and what’s best.

In the AI era, this ability becomes even more important. Because AI can generate infinite options, but determining which one is worth choosing and which best fits the goal still depends on human judgment.

💡18. Less Is More: Attention Management in the Agent Era

The guest emphasized that in the Agent era, the truly scarce resource isn’t information — it’s attention.

Therefore, our mindset should shift from the additive thinking of “one more can’t hurt” to the subtractive thinking of “why not remove one.” Because once information overloads, people tend to skim superficially, losing the capacity for deep understanding and thinking.

So rather than continuously adding information sources, the more important thing is to actively reduce input, keeping only truly high-quality sources worth long-term attention.

This really inspired me. I had previously recognized that human attention is the most precious resource, but I hadn’t realized that I was adding information sources with the “one more can’t hurt” mindset — ending up unable to truly absorb anything, while genuinely high-quality sources got treated the same as mediocre ones. Curating daily information sources is the way to maximize value. After listening, I was so inspired that I immediately organized my information sources across platforms — and discovered I’d unknowingly subscribed to quite a few dispensable ones 🤣

Afterword

Looking back at these notes, what I really want to take away isn’t any single elegant concept, but a few more concrete reminders:

1. Expand your viewfinder as much as possible, but acknowledge its limits
2. Leverage AI as much as possible, but don’t become AI‘s mouthpiece
3. Reduce ineffective input, and reserve your attention for what truly matters and compounds over time
4. Use AI to co-evolve with yourself at the metacognitive level

If this episode left me more certain of one thing, it’s this: in the AI era, people need to seriously decide where they want to put their attention.

“If you’ve done it three times, automate it.” That saying might be a bit exaggerated, but the thinking behind it is worth borrowing. When interacting with agents, you’ll often find certain needs recurring. If you standardize these needs and use short commands to reference lengthy prompt descriptions, you can help the agent understand your requirements clearly while reducing unnecessary cognitive load and operational steps on your end. The logic is simple: if something will require repeated effort in the future, then every efficiency improvement to that task is a meaningful gain in attention for each future execution.

This article shares some practical custom Slash Commands I’ve found useful. The prompts may not be the best written, but I hope the thinking behind them inspires you. Also, this article doesn’t cover the specific implementation format or technical details of writing them—the target audience should have ways to ask AI for help with that.

What is a Slash Command?

A Slash Command is a way to simplify user-system interaction. Users trigger predefined actions or functions by typing specific commands (usually starting with a slash). Readers who’ve used Coding Agents like Claude Code for development will be familiar with this.

Slash Command Ideas

Below are some custom Slash Commands I’ve distilled from practice that have proven useful to me. Again, this article doesn’t cover functional commands that simply wrap prompts for engineering tasks like one-click testing or committing—those are basic skills for any competent agent user, and you should consciously package frequently used prompts into Skills or Slash Commands. This article focuses on the characteristics of human-agent interaction, approaching from a higher dimension to design Slash Commands that enhance the overall agent interaction experience.

1️⃣ /notify - Task Completion Notification

I often have Coding Agents working in the background, but when they finish, I might not know about it—meaning the agent wasted that precious time doing nothing. As its boss, how could I want my employee to slack off? But if I keep staring at it working, that wastes my time too. Who’s the boss here, me or it? 😄

So I designed a /notify command that tells the agent to send me a Telegram notification when it completes the task. This way, I receive the notification on Telegram. Telegram notifications have high priority for me, so I’m likely to see them. After real-world testing, I’ve found that even after long tasks, the agent still remembers to do this. This effectively adds a hook to the agent’s task completion. You can modify the prompt to suit your needs. It looks something like this:

Note: This uses apprise to send Telegram notifications. You can use other tools to implement notifications based on your needs.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

---
description: Send Telegram notification when task completes
---

Send a Telegram notification only after the task is fully completed and verified.

## Instructions

1. **Complete the user's task** as requested.

2. **After completion**, send a notification using:
   `apprise -t "Task Complete" -b "<summary>"`

   Build <summary> as a concrete result summary (2-4 sentences). It must include:
   - What was done (specific actions)
   - Key result(s) or evidence (file paths, logs, screenshots, or checks)
   - Current status: success / partial / failed

   If $ARGUMENTS is not empty, append it as the last sentence.
   Do **not** use $ARGUMENTS as the entire summary.

3. **Timing**: Send notification AFTER all work is done, verified, and ready for user review.

## User Input

$ARGUMENTS

---

**Remember**: Complete the task first, then notify.

2️⃣ /learn - Learning from Conversations

If you’re not interested in the analysis of model “memory,” feel free to jump to the usage section.

Agents are different from humans. In some ways, human consciousness and memory management are tightly coupled. But agents are built on LLMs, which are inherently stateless—they have no memory capability. If there is any “memory,” it’s implemented through external files: essentially prompts stored on disk, organized by software, and ultimately fed to the LLM.

Fortunately, there are now many standardized memory management conventions. For example, Claude Code’s CLAUDE.md is passed in every conversation/tool call as global memory. OpenClaw’s MEMORY.md file provides a similar mechanism.

Another approach I find elegant is using skill. Since agent memory is essentially prompts, what advantages do skills offer from a memory perspective? I see at least two:

First, skill enables “progressive context management.” Context is precious in an agent’s context window. Skills that the agent calls on demand can occupy significant context space. This is essentially a trade-off between cost and efficiency when agents retrieve memory on demand. If full prompts were placed in a global memory file, they’d always be findable, but every call would consume substantial context space—not only costly but also affecting the agent’s reasoning quality. Humans struggle to multitask, and agents do too, to some extent.

Standard skills have custom YAML fields at the top of their SKILL.md, primarily name and description. During agent operation, these fields serve as an “index,” enabling “referencing” of large prompt content at a small context cost. When needed, the agent can invoke the skill by name to retrieve the full prompt content from its SKILL.md.

Going further, within SKILL.md, you can place less critical, on-demand content in a references directory for even more granular progressive context management.

Second, skill achieves organic fusion of intelligence and code. LLMs and code are two tools with different strengths.

LLMs are trained on parts of human knowledge and possess a degree of general-purpose intelligence. With prompts and external tool environments, this intelligence can accomplish many things we humans once prided ourselves on—writing, translation, tool use, and more. But they also suffer from instability, especially when precise, structured output is required—LLMs can be unreliable. Additionally, using LLMs incurs reasoning costs; they’re inefficient for computationally heavy tasks.

Code, on the other hand, excels in determinism and efficiency. For tasks requiring precise, structured output or heavy computation, code is ideal. But code requires investment in writing, debugging, and maintenance, and it’s less extensible than prompts.

Skills combine the best of both. A skill can contain both prompts and code. The prompt portion drives intelligence, guiding the agent on how to use the skill; the code portion serves as a tool for the agent, compensating for LLM inefficiencies and unreliability. From a memory perspective, programmatizing certain functions into skill code can significantly save the agent’s memory space.

When using agents with persistent memory like OpenClaw, or other Coding Agents to assist with standardized workflows like development or writing, you might notice that agents often make mistakes in tool calls or misunderstand instructions, requiring repeated human confirmation. But these issues can be resolved through trial and error. When the agent finally solves a problem after repeated attempts, the context contains its complete trial-and-error process—a perfect learning opportunity for the agent.

Usage:

So I designed a /learn command that asks the agent to summarize what it learned during a task. Good times to use it: after the agent solves a problem through multiple attempts, or during idle periods (like early morning) to summarize the day’s lessons. This command is simple—it doesn’t even need complex prompt techniques:

1
2
3

请你深入分析，在前面试错过程中，可以总结哪些宝贵经验？请分别整理到Skill（如有对应）或项目的CLAUDE.md中，这样可以避免未来重复犯错。注意，如果这些文件中有层级引用结构的话，请按照对应的层级设计，放在合适的位置。

If you have your own memory file system, you can adjust the command accordingly. If you’re using a long-running autonomous agent like OpenClaw, you could even design this as a scheduled task, having the agent summarize the day’s experiences during idle hours (like 4 AM).

3️⃣ /align - Aligning Human and Agent Requirements

When using agents, you’ll often find that their understanding of your requirements isn’t entirely accurate. In most cases, it’s because within the limited context of your conversation, you didn’t realize that some critical information for completing the task wasn’t conveyed. If you catch this early, you can correct course and supplement information to help the agent understand better. But if you don’t, the agent may proceed with its own interpretation, wasting valuable time and tokens.

There’s a technical reason behind this: during RLHF training, human annotators typically prefer “complete, fluent answers” over “admitting uncertainty,” which causes models to push through tasks when uncertain rather than proactively clarifying understanding. In practice, though, we’d prefer models to ask questions when understanding is unclear, rather than executing on potentially wrong interpretations.

As users, we can’t easily influence model training. What we should consider is: among the things we can control, how can we better solve this problem? The answer is aligning requirements before starting work. Specifically, writing detailed prompts is a good habit. But I think an even better approach is to have the agent proactively ask questions before starting, to confirm its understanding of the task and surface any blind spots in the human’s thinking. This way, we can align requirements relatively easily by answering questions, and we also get visibility into aspects we hadn’t thought to communicate—deepening our understanding of prompt design.

So I designed an /align command that asks the agent to summarize its understanding of a task and align it with my requirements before starting. When used, the agent proactively asks 2-3 clarifying questions, progressively confirming its understanding until both sides are fully aligned before execution. This command is also simple:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

---
description: 与用户多轮交互澄清需求，直到完全对齐再执行。支持参数：/align <粗略需求>
---

你现在进入「需求对齐模式」（Alignment Mode）。

## 核心规则（严格遵守）

1. **绝不** 直接开始实现或写代码、写文档、生成任何输出物。
2. **唯一允许的行为**：使用 AskUserQuestion 工具（或系统提供的提问工具）向用户提问，问那些你还不太明确，或者用户欠考虑的问题。
3. 问题要**具体、聚焦、可回答**（避免开放式大问题）。
4. 每轮收到用户回答后，**立即**：
   - 简短确认理解（1–2 句）
   - 判断是否还需要更多澄清
   - 如果还不够 → 继续问下一个最重要的问题
   - 如果已经足够清晰 → 输出最终的「对齐后需求总结」，然后问：“以上理解是否正确？可以开始执行了吗？”
5. **对齐后需求总结** 必须结构化，使用 markdown 格式，包含：
   - 目标（一句话）
   - 关键约束 / 非功能需求
   - 验收标准（用户最在意的 Done 定义）
   - 优先级 / 范围（what in / what out）
   - 任何已确认的假设
6. 整个过程保持**礼貌、耐心、高效**。目标是用最少轮次达到最高理解一致性。

## 当前用户输入（原始需求）

$ARGUMENTS

## 第一步（现在立即执行）

- 仔细阅读上面的 $ARGUMENTS
- 思考：最容易导致偏离、最模棱两可、最关键的 1–2 个点是什么？
- 使用 AskUserQuestion 工具提出**第一个（或前两个）澄清问题**

开始吧。

Going forward, when assigning requirement-based tasks to agents, consider starting with this command to align requirements first. While it may add some upfront communication cost, from an expected-value perspective, it should save potential time, energy, and money in the downstream development process.

Summary

These three commands address three core issues: notification, memory iteration, and requirement alignment. Use /align to align upfront and reduce rework; use /learn to leverage valuable trial-and-error experiences for the agent; use /notify to reduce mental overhead and save time, improving parallel efficiency.

This article is meant to spark ideas. If even one command or thought here inspires you, its purpose is fulfilled. I’d love to hear from readers: what other interesting Slash Commands have you found that improve the “happiness” of interacting with agents? Feel free to share in the comments!

Vibe Coding — I’m confident readers are familiar with the concept. The simple approach to Vibe Coding requires you to sit continuously at your computer, interacting with TUI or GUI interfaces. At its core, the interaction is quite simple: all human-agent interaction can be reduced to text, with perhaps an optional image added. Neither of these requires you to interact via a computer; the computer essentially just provides an environment for programs to run. In other words, technically speaking, we can completely bypass the computer in the interaction loop and use a more convenient device — the phone — instead. This idea was introduced in an earlier post (quite a while ago, perhaps last year).

Recently, I switched my Coding Agent to OpenCode. Below, I’ll share the OpenCode workflow I currently use, which I’ve found to be quite smooth.

Main Approach

There’s one method that’s the simplest: use remote control software to control your computer from your phone. However, this approach actually contradicts our original intent — it doesn’t leverage the phone’s convenience and ease of use, instead resorting to a computer-like interaction method. This is only recommended for emergencies or situations where frequent operation isn’t required.

OpenCode isn’t limited to TUI interaction like Claude Code. It also allows users to start a server via opencode web, and the official package includes a lightweight frontend (apparently the same one used by the desktop app) to interact with the backend. What’s even more surprising is that, based on my experience, custom plugins (like OMO, oh-my-opencode) work well through this interaction method.

So the simplest approach is: run a server on your computer bound to a remotely accessible IP, then access it remotely. If you’re at home, controlling it from your phone is very easy — the WLAN directly networks your phone and computer together. As long as your computer stays on and the server is running, you can open your phone’s browser and access it. The official basic frontend may look minimal, but in practice, about 95% of commonly used features can be handled from your phone. The only inconvenience arises when you need to verify results as a user on the computer itself — in those cases, it’s still recommended to use the computer.

For situations where you and your computer aren’t on the same WLAN, you can use software like Tailscale for remote networking. Simply install Tailscale on both your computer and mobile device, add them to the same network, and you’ll have remote access from your phone. Going further, if you also need to develop with OpenCode on remote hosts, you can network those machines with Tailscale as well. I’ll just offer this idea here — the specific configuration details shouldn’t be a problem for readers, and I hope this approach sparks some inspiration.

For Windows, you can reference a .bat script I wrote that starts the server with a single command, making it accessible remotely. For security reasons, I recommend setting an access password. Once set, when you open the corresponding address in your browser and enter the password, the default username is opencode.

1
2
3

@echo off
set OPENCODE_SERVER_PASSWORD=<password>
opencode web --hostname 0.0.0.0 --port <your-port>

Running the script starts the server in the background, and your phone can connect immediately.

Going one step further, I recently discovered a third-party open-source OpenCode WebUI that offers a much nicer and more polished experience overall, though it’s still in early development. This WebUI doesn’t require separate deployment — just fill in the backend address from the previous step and you’re good to go. Note that for some backend instances, you may need to add --cors "https://lehhair.github.io" to the command to resolve CORS cross-origin issues. Interested readers can try it out for themselves.

The above is mainly about sharing approaches and experiences — for specific technical details and security considerations, please refer to the documentation and do your own research.

Afterword (Random Musings)

It’s been a while since I last connected with readers. Over the past few months, I’ve had many observations and thoughts I couldn’t share. This article is written entirely by hand — in an era where AIGC is everywhere, I still want to genuinely contribute something more valuable and thoughtful to the internet. This isn’t to say that AI-assisted articles lack readability. I’ve been questioning the necessity of writing articles by hand, since it seems more convenient to have an Agent generate an article based on your outline — which is why I hadn’t planned to write blog posts for several months. But I eventually realized that writing isn’t just for readers; it’s also for myself, to think through things more deeply and thoroughly. The process of writing clarifies my thinking. And at the very least, it’s a form of entertainment and experience. Perhaps what was once called “work” will, in the future, largely become “entertainment” or “art.” Allow me this time to write a bit more for myself.

My minimum bar for learning a new technology is “getting started.” In my view, reaching that level requires two things:

1. A solid understanding of the core concepts in the field—at least enough that when industry folks mention a concept, you have a rough idea of what it means;
2. Hands-on practice—using what you’ve learned to build something real and presentable.

Lately I’ve been interested in blockchain technology. After learning the core concepts, I wanted to build something with it. While brainstorming what project to use as my “getting started” test, the idea of a message board suddenly came to mind.

Traditional message boards are almost always built on centralized services, which means whoever controls the central server can delete or tamper with users’ messages. But if we could leverage blockchain’s near-immutability to put messages on-chain, and make the smart contract code public, that would be a perfect closed loop—neither the message authors nor the contract creator could tamper with the content. Add a frontend that fetches on-chain messages when users visit, and everyone can see them. Even if the frontend goes offline, anyone can still view the messages on-chain using the open-source contract code and the public ABI.

Let’s do it!

Tech Stack

• Solidity - Ethereum smart contract programming language
• React - Frontend framework
• Tailwind CSS - Styling framework
• Wagmi - Web3 development library
• Cloudflare Workers - Backend proxy service

Project directory tree (generated with my open-source CLI: Treex):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

📁 ./
├── 📝 README.md
├── 📁 cloudflare/
│   └── 📜 worker.js
├── 📜 eslint.config.js
├── 🌐 index.html
├── 📋 package.json
├── ⚙️ pnpm-lock.yaml
├── 📜 postcss.config.js
├── 📁 public/
│   ├── 📄 favicon.ico
│   └── 🖼️ icon.png
├── 📁 solidity/
│   ├── 📋 abi.json
│   └── 📄 message.sol
├── 📁 src/
│   ├── 🎨 App.css
│   ├── 📜 App.tsx
│   ├── 📁 assets/
│   │   └── 🖼️ react.svg
│   ├── 📁 components/
│   │   ├── 📜 MessageBoard.tsx
│   │   └── 📜 QA.tsx
│   ├── 📜 config.ts
│   ├── 🎨 index.css
│   ├── 📜 main.tsx
│   └── 📜 vite-env.d.ts
├── 📜 tailwind.config.js
├── 📋 tsconfig.app.json
├── 📋 tsconfig.json
├── 📋 tsconfig.node.json
└── 📜 vite.config.ts

Main Content

GitHub open-source repo: https://github.com/shiquda/chain-message

Live demo: https://msg.shiquda.link/

Deployment guide: https://github.com/shiquda/chain-message/blob/main/DEPLOY_GUIDE.md

To fully understand this article, some blockchain knowledge is helpful. If you don’t have any, no worries—I’m confident that with your smart brain, you can easily pick it up using LLMs along the way. If you’re interested in trying this hands-on, you’ll also need a wallet plugin. (I use OKX’s Web3 wallet)

Smart Contract

First, we need to write the smart contract code. A smart contract can be simply understood as a piece of code that runs on the blockchain, and the entire blockchain can be viewed as a state machine. Interacting with smart contracts transitions the state machine from one state to another. Smart contracts support two types of calls: Read-type calls, which don’t require Gas fees, and Write-type calls, which involve write operations and are more expensive, requiring Gas.

The smart contract I wrote only exposes two interfaces. The first is postMessage, a Write Contract that lets users submit their messages. The name field is optional—if left blank, it’s treated as an anonymous message. It should also support Markdown format, which is handled on the frontend.

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

function postMessage(string memory _name, string memory _content) public {
    unchecked {
        // Safe counter increment (Solidity 0.8+ checks arithmetic overflow by default)
        _messageCounter++;
    }
    emit MessagePosted(
        _messageCounter,
        msg.sender,
        bytes(_name).length == 0 ? "Anonymous" : _name,
        _content,
        block.timestamp
    );
}

After a message is sent, the smart contract automatically stores not only the parameters above but also the timestamp of when it was sent.

1
2
3
4
5
6
7

event MessagePosted(
    uint256 indexed messageId, // Message ID (indexed)
    address indexed sender, // Sender address (indexed)
    string name, // Sender name (or "Anonymous")
    string content, // Markdown content
    uint256 timestamp // Block timestamp
);

There’s also an interface for querying the total number of messages. This interface is read-only—calling it merely queries the blockchain state and doesn’t consume gas. This interface isn’t actually used by the project yet.

1
2
3

function getMessageCount() public view returns (uint256) {
    return _messageCounter;
}

Other than that, no other interfaces are exposed, which means once a message is on-chain, even I can’t delete it.

Now let me explain how I deployed the smart contract. I used Remix, an online IDE recommended by the Ethereum Foundation that’s beginner-friendly.

Paste the locally written contract into Remix, then compile it. After compilation, select the deploy tab on the left.

Choose WalletConnect and connect your wallet plugin as prompted. Once connected, click deploy and confirm in your wallet plugin—the contract will be deployed on-chain.

Deploying a contract requires a fairly high Gas fee, so you may need to withdraw some funds from a centralized exchange to your wallet. My last deployment cost around $0.37. After deployment, you can also verify your contract source code on Etherscan, so anyone can publicly audit the contract code and verify the system’s immutability.

One thing to note: I used the smart contract’s event logs to record messages. I chose this over storing directly in contract storage because storage would consume significantly more Gas. Using event logs reduces this cost, so users pay less Gas when submitting messages. In my testing, submitting a message cost about $0.05—roughly 30 cents RMB.

Of course, testing on a testnet first would have been the safer approach, but I was too eager to deploy my first smart contract to the mainnet. I’d advise you not to follow my example here 🤣

Frontend Implementation

For the frontend, I used the React framework with Tailwind CSS for simple styling. The Web3 library I used is wagmi—thanks to the Web3 developers who came before us, they’ve already done a lot of the heavy lifting for us regular developers. This library automatically handles interaction with the user’s wallet plugin.

I won’t go into the implementation details here—interested readers can check out the source code.

Live demo: https://msg.shiquda.link/

Cloudflare Workers

The frontend itself is fairly simple, but a new problem emerged: how do users fetch the on-chain messages?

I first tried using public Ethereum nodes to fetch the logs. After trying several, I found that most don’t support unauthenticated calls. For fetching event logs, I did find a free one—https://ethereum.publicnode.com—but it only supports querying up to 50,000 blocks, which clearly didn’t meet my requirements. So I ended up using Etherscan’s API, which requires authentication.

But that raised another issue: if the API key is stored directly in the frontend, wouldn’t it be exposed and abused by others?

That’s when I thought of using Cloudflare Workers as a simple wrapper. When a user makes a request to the Cloudflare Worker, the worker reads the API key from an environment variable configured in CF, forwards the request to Etherscan as a proxy, and returns the response to the user. This way, the frontend can fetch messages in real time.

However, someone could still abuse the endpoint to query event logs. So I added another environment variable to restrict the endpoint to only query our deployed contract, which significantly reduces the incentive for abusers.

One gotcha here: Cloudflare Workers’ default domain is blocked by the GFW (Great Firewall). To work around this, you can use your own domain or subdomain as a forwarding route, which bypasses the restriction and lets users directly fetch the message data.

To configure Workers, find “Workers & Pages” on the left side of your Cloudflare dashboard, then Create > Workers > Hello world > Enter a name and deploy > Edit code, and paste the code below.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

// worker.js
export default {
    async fetch(request, env) {
        // Handle CORS preflight request
        if (request.method === 'OPTIONS') {
            return new Response(null, {
                headers: {
                    'Access-Control-Allow-Origin': '*',
                    'Access-Control-Allow-Methods': 'GET, OPTIONS',
                    'Access-Control-Allow-Headers': 'Content-Type',
                },
            });
        }

        const { searchParams } = new URL(request.url);
        const address = searchParams.get('address');
        const startBlock = searchParams.get('startBlock');

        if (!address || !startBlock) {
            return new Response('Missing parameters', {
                status: 400,
                headers: {
                    'Access-Control-Allow-Origin': '*',
                    'Content-Type': 'application/json',
                }
            });
        }

        // Optional environment variable: Contract address, prevents API abuse
        const CONTRACT_ADDRESS = env.CONTRACT_ADDRESS?.toLowerCase();
        if (CONTRACT_ADDRESS && address.toLowerCase() !== CONTRACT_ADDRESS) {
            return new Response('Forbidden', {
                status: 403,
                headers: {
                    'Access-Control-Allow-Origin': '*',
                    'Content-Type': 'application/json',
                }
            });
        }

        const params = new URLSearchParams({
            module: 'logs',
            action: 'getLogs',
            address: address,
            fromBlock: startBlock,
            apikey: env.ETHERSCAN_API_KEY
        });
        const response = await fetch(`https://api.etherscan.io/api?${params.toString()}`);

        const data = await response.json();
        return new Response(JSON.stringify(data), {
            headers: {
                'Content-Type': 'application/json',
                'Access-Control-Allow-Origin': '*',
                'Access-Control-Allow-Methods': 'GET, OPTIONS',
                'Access-Control-Allow-Headers': 'Content-Type',
            },
        });
    },
};

Then navigate to your Worker’s Settings > Variables and Secrets > Variables and Secrets > Add, and add the two environment variables: CONTRACT_ADDRESS and ETHERSCAN_API_KEY.

If you need to bind your own domain, go to the domain management page in CF, find “Workers Routes” on the left, add a route, and bind it to the Worker you created earlier.

Static Site Generation

Once everything is ready, we can generate a static page and upload it to our blog or a cloud hosting service, allowing it to run independently.

I recommend deploying with Cloudflare Pages. For a tutorial on this approach, see the deployment guide on GitHub.

Clone the project, install dependencies, and configure:

1
2
3

git clone https://github.com/shiquda/chain-message.git
cd chain-message
pnpm install

Then refer to .env.example to fill in the required environment variables. Once that’s done, build with the following command:

1

pnpm build

The files in dist/ are the static site—you can host them on any hosting service.

Conclusion

After all this, I’m truly filled with emotion. A hundred years from now, after I’ve left this world, these messages might still exist on the blockchain. Others might even be able to access and read my messages, or the messages people left for me. That’s genuinely a cool thing.

Message board: https://msg.shiquda.link/

Regardless, let me leave a message for myself 10 years from now. (I typed one extra character, and it’s already irreversible 😄)

All the code for this idea—including the smart contract, frontend, and Cloudflare Workers code—is in the GitHub repo. If you’re interested, feel free to deploy your own and play around with it.

A few days ago, I registered an Ethereum address domain: shiquda.eth. Using this ENS domain, you can find my wallet address—the same address that deployed this contract. If this article inspired you, feel free to send some funds to that address 😄(I know, shameless plug)

• S: Situation — background information
• T: Task — the goal
• A: Audience — who it’s for
• R: Requirements — output requirements

When asking a question, providing the LLM with these four dimensions of information can help it generate much better responses.

Here’s an example:

Prompt:

1
2
3
4
5
6
7
8
9
10
11

介绍一下下面的概念：
附加律
化简律
假言推理
拒取式
析取三段论
假言三段论
等价三段论
构造性二难
构造性二难（特殊形式）
破坏性二难

Response:

These concepts come mainly from logic, especially propositional logic and rules of inference. Here’s a brief overview:

1. Addition
   Addition is a rule of inference in propositional logic:

• If ( P ) is true, then ( P \lor Q ) is also true, regardless of what ( Q ) is.
• In other words, from ( P ) you can infer ( P \lor Q ).

2. Simplification
   Simplification is a rule of inference in propositional logic:

• If ( P \land Q ) is true, then ( P ) is true and ( Q ) is true.
• In other words, from ( P \land Q ) you can infer ( P ) or ( Q ).

3. Modus Ponens
   Modus Ponens is a basic rule of inference in propositional logic:

• If ( P \rightarrow Q ) is true and ( P ) is true, then ( Q ) is true.
• In other words, from ( P \rightarrow Q ) and ( P ) you can infer ( Q ).
  ……

These rules of inference are very useful in logical reasoning and mathematical proofs, helping us derive new propositions from known ones.

A STAR-optimized prompt:

Response:

Okay class, finals prep stressing you out? Don’t worry — let me “translate” these discrete math concepts for you. I promise you’ll laugh and actually remember them!

1. Addition:
   It’s like already having a bag of chips, but thinking it’s not enough and buying another one. Logically: if you know A is true, then A∨B (A or B) is definitely true. Since A is already there, it doesn’t matter whether B shows up — the chips are in hand!

2. Simplification:
   It’s like buying a bunch of stuff, only to realize you only use one of them. Logically: if A∧B (A and B) is true, then A is definitely true. Forget B — A is enough!

3. Modus Ponens:
   It’s like “if it rains today, I’ll bring an umbrella.” It does rain today, so you definitely brought an umbrella. Logically: if A→B (A implies B) and A is true, then B is also true. Don’t get soaked — bring the umbrella!

……

See? These concepts aren’t so scary after all. Remember, logic is like life — sometimes more options actually make things simpler. Good luck studying, you’ve got this!

Testing with DeepSeek’s default model on the official website shows a very clear difference.

What Prompt Optimization Really Does

You’ve probably heard that prompts can optimize output. For example:

Pretend you’re an experienced Python programmer. Now please xxx…

These “formulaic” prompts do seem to improve response quality to some extent.

Mainstream LLMs are also improving rapidly. Many products can already automatically predict and optimize user needs, and the marginal effect of prompt engineering is starting to show. So, in this context, what’s the point of writing good prompts?

I believe that, at its core, a good prompt provides the LLM with more information, and that information helps the LLM generate content that better matches user expectations.

Many users feel the LLM “doesn’t get me,” but in reality, they may not have given the LLM enough background information. The LLM isn’t a mind reader — how could it know exactly what you need? 😄

Isn’t This a Hassle?

You might ask: isn’t it a pain to write prompts like this every time?

The answer depends on your needs. For simple questions — say, you just want the LLM to do a quick translation so you can understand something — then no, it’s not really necessary.

But for more important requests, like polishing a draft, I’d still recommend doing it. After all, getting a satisfying response from the LLM in one shot is better than having to coach it through multiple rounds.

Reference

[Advanced Tutorial] One Combo to Fully Unleash AI’s Writing Ability — Bilibili](https://www.bilibili.com/video/BV1RNidYCEdq/)

Background (Feel Free to Skip)

Over the past few days, I’ve been learning about the crypto space and even dipped my toes in myself. The exchange apps on mobile all have floating-window features, but I haven’t found a desktop equivalent that really satisfies me. Previously, I had to keep multiple browser windows open, which wasn’t very convenient.

Some of these desktop products are even paid on the Microsoft Store. After spending some time cracking one, I found it was honestly a mess—hard to describe. I wouldn’t use it even if someone paid me 😅

The weekend finally freed up, and I’d been wanting to learn Go for a while but never had the time to practice. Then I stumbled upon this idea in my idea list: build a desktop floating-window app for monitoring crypto prices.

I wanted it to be beautiful, cross-platform, and lightweight.

So I got to work. Saturday afternoon I went through Go’s basic syntax, then asked AI that evening which lightweight Go frameworks were good for building cross-platform desktop apps. After some back and forth, it told me Fyne was a solid choice.

And then… I wasted an entire night.

During actual development, I found that despite having 25k stars on GitHub, the framework felt very rigid (maybe I just didn’t go deep enough), and many methods I needed simply didn’t exist (e.g., the most important one—always-on-top). I checked and found users had raised this in Issues, but after three years the developers still hadn’t added it. Eventually I couldn’t take it anymore and decided to ask real people. After some Googling, I stumbled back to L站 (gotta say, their SEO is top-notch 😄)

https://linux.do/t/topic/115324/19

I want to thank all the netizens who participated in that thread—someone pointed me in the right direction: wails.

Wails is a project for building desktop applications using Go and web technologies. Since I’m relatively familiar with frontend and had picked up some Vue basics before, it was fairly easy to get started. So I went all in, deleted all my Fyne code without hesitation—keeping only the backend API requests—and grinded until 2 AM. I got up at 7 AM and kept writing until just recently when it was finally done.

There was one pitfall that held me up for a long time. Since I wanted a cross-platform desktop app but only have Windows and Linux environments (no macOS), I planned to use GitHub Actions for packaging. But I’m not very familiar with Actions, and more importantly, I knew nothing about macOS specifics (like how apps are installed and packaged) 😅. It took over a dozen attempts to get it working. GitHub Actions never gave me a good way to debug, so I had to keep trial-and-erroring, asking Cursor, and retrying based on the sparse output—with each retry taking 3-4 minutes of build time.

The Windows installer still seems to have some issues—it appears to be the same as the executable—but the executable itself runs fine. I’ll leave it as is for now; if it runs, it’s good enough. I’ll fix it when I feel like writing code again later…

Introduction

The prototype of this little widget is finally complete:

Tech stack:

• Wails
• Vue

The current features are still pretty basic—besides always-on-top, minimize, and close, there’s only simple add/remove of trading pairs. I’ll consider adding more features later (digging a hole for myself).

For more details, check out Github. If you like it, feel free to drop a Star~

Downloads:

https://github.com/shiquda/crypto-monitor/releases/

Given my limited technical skills, there are bound to be issues. Feel free to raise any suggestions or feedback—I’ll get to them when I have time~

Afterword

Secretly opened a new treehole: cry.shiquda.link

This article introduces a method for downloading books from WeRead (WeChat Reading), leveraging WeRead’s caching feature to download books the user has reading access to, and convert them to PDF and other formats.

Tutorial

Download

Lanzou Cloud

https://wwrd.lanzouv.com/i1zj02a4imbi

Baidu Netdisk

Link: https://pan.baidu.com/s/1CJYdGNDF9-X7nCYP4Zxjzg?pwd=ecw3 Extraction code: ecw3

Extract

First, extract the archive to a suitable location, then double-click 微信读书下载器.exe to launch the software.

Log in to WeRead

After opening the software, click “Scan to Log In,” then click “Get Login QR Code,” and scan the QR code with WeChat to log in.

Add to Bookshelf

Add the books you want to download to your bookshelf in the WeRead mobile app, then refresh the software page and click the corresponding book to download it.

Get the eBook

Open the HTML file located in the software folder under book->一串数字->下载的书目->看这里, and open the file in a browser.

Once opened in the browser, press Ctrl + P, select “Save as PDF,” then choose a save location to download the PDF.

The exported PDF can be read locally or imported into apps like WeRead for free, permanent reading.

eBook Format Conversion

If you need to convert to other eBook formats, you can use the website https://convertio.co/zh/ebook-converter/ to convert. Upload your PDF file, select your desired format, and the conversion is free.

Let me ramble for a moment—if you’re in a hurry, feel free to skip ahead to the main content.

Recently, I’ve started to feel that Spotify’s audio quality isn’t all that great—apparently it maxes out at 320K. While I’m not an audiophile, I do care about sound quality. But I didn’t want to pay for another streaming platform, so I came up with a workaround: use Spotify’s excellent recommendation algorithm to discover new music, then play the songs from my Spotify playlists using a local player.

However, this raises an important issue: my playlists contain several hundred songs, and downloading all of them isn’t easy. Although I know there are channels to download high-quality audio for free, such as some Telegram groups or the well-known MyFreeMP3 (liumingye.cn), they’re both cumbersome to use and not well-suited for batch downloads. They might work when you need a few tracks temporarily for video editing, but not for bulk downloading. Does this mean the classic “pick two out of three” dilemma applies here?

Today, I happened to come across a post by an expert titled Freeloading tens of millions of high-resolution music tracks! How to download resources from Qobuz, Tidal, Deezer and other streaming platforms - General Topics / Featured Posts - LINUX DO. Following their approach, I gave it a try and found that all three can actually be achieved simultaneously—perfectly satisfying my freeloading needs. Now I’d like to share my complete workflow.

Main Content

If you have large playlists on some music platforms and can’t download them all as lossless audio for free, give this method a try.

Note: This tutorial requires a Python environment. I’ll assume you have Python installed. If not, search for a tutorial or ask GPT.

Getting Your Playlist

Domestic Platforms (NetEase Cloud Music / QQ Music)

Migrate NetEase Cloud / QQ Music to Apple Music, YouTube Music, Spotify | yyrcd

Follow the instructions on the website above, enter your playlist, and it will export the corresponding playlist as a TXT file.

International Platforms (Spotify / Apple Music / YouTube Music, etc.)

Transfer playlists between different music services | Tune My Music

We’ll use the tool above for conversion. If your playlist has fewer than 500 songs (the free tier limit), you can simply follow the website’s instructions to log in, fetch your playlist, and select Qobuz as the import destination.

If you don’t have an account on that platform, you can create a free Qobuz account—I recommend signing up with your Google account. We don’t need to pay for this platform; it’s just a stepping stone to make batch downloading easier.

What if your playlist has more than 500 songs? No problem. You can first convert and save it as a TXT file, then use Tune My Music multiple times to import—each free import handles up to 500 songs.

Importing Songs to Qobuz

Transfer playlists between different music services | Tune My Music

In the previous step, if you’re using a domestic platform or have more than 500 songs, select “Any Text” as the import option.

Then paste the playlist text you obtained earlier. If it exceeds 500 songs, import it in batches.

Select Qobuz as the destination.

Once the import is complete, open the playlist page and make sure to uncheck the “Private” option on your playlist—otherwise, the tool won’t be able to read your playlist publicly.

Batch Downloading

nathom/streamrip: A scriptable music downloader for Qobuz, Tidal, SoundCloud, and Deezer (github.com)

We’ll use this tool for batch downloading.

Installation requires a Python environment. Run the following command to install:

1

pip install poetry

After installation, open the configuration file:

1

rip config open

You can configure it based on my example. The token and ID provided by a generous contributor can be found at Firehawk52 Official - Saving Digital Legacy (rentry.org).

After saving, go to the playlist link you transferred to Qobuz earlier, then run:

1

rip url https://play.qobuz.com/playlist/xxxxxxxx

The download will begin. If you can’t connect, you may need to enable a global proxy or TUN mode.

If the download disconnects and throws an error, just run the command again—already downloaded tracks will be skipped automatically.

Drawbacks

While this method largely solves the three-way dilemma, it still has some shortcomings.

1. Playlist conversion may be inaccurate or incomplete. Since most of what I listen to is English music, I haven’t tested much with Chinese songs, so there may be gaps; some tracks may also come out as different versions after conversion (e.g., the original becomes a remix or vice versa). I’d estimate the accuracy is around 90%.
2. Some songs in Qobuz appear grayed out and can’t be fetched. My guess is this is related to the country associated with the token account. If some tracks fail to download, try switching to a different token. The download success rate is also around 90%.