The author built an "EQ plugin" with Claude Opus 5.5 and used UUMit to turn a local service into a team link

In this piece, my friends and I are cutting straight to the essentials. The whole article covers three core things: how to take my "Nonviolent Communication" AI Skill that got 180+ Stars on GitHub and use AI to hand-build a zero-dependency web tool called "Emotional Intelligence Cheat" that specifically cures WeChat blowups and comes with 7 interpersonal rules → how to take a tool running locally on your own computer at 127.0.0.1 and, without buying a cloud server, configuring a domain, or waiting for ICP filing, turn it into a fixed HTTPS link with one click via UUMit that you can send to colleagues and clients to use directly? → how to do API rate limiting to prevent blowing up your wallet, and issue keys per person that can be revoked at any time? 2 GitHub repository source codes + the core System Prompt are all open source, copy them directly!

Full code and open-source project: github.com/ayi-ai/qingshang-waigua

In the workplace and in everyday communication, what frustrates people most is often not that the matter itself is hard to handle, but that even when your intentions are right, the moment anger rises, you fire off one sentence onto the screen and the other person blows up the moment they read it.

Many times, in the second your finger is on the send button, reason simply cannot hold back emotion. Only in hindsight do you realize that the reason a sentence pisses someone off is often not that the meaning is wrong, but that it is stuffed with too much judgment, dredging up old grievances, shifting blame, or a commanding tone.

To fix this problem, I had Cursor help me use Claude Opus 5.5 to build a small local tool that cools things down and rewrites before sending — the Emotional Intelligence Cheat. Throw an emotional draft into it, choose who the other person is and what tone you want, and it first flags the most jarring words in the original wording, then gives you a sentence you can send directly; where you should be firm, it never softens.

Once the tool was done it worked smoothly, but I soon ran into the old problem — a good thing only lived inside my own 127.0.0.1. If I wanted colleagues and friends to use it too, either they had to configure the environment and install dependencies themselves (90% of people get stuck at the first step), or I had to rent a server, configure a domain, and wait for ICP filing. Spinning up a whole infrastructure stack for a small tool is simply too heavy.

This time I tried an extremely lightweight path: the tool still runs on my own laptop, and with one click in the UUMit client to connect it, it directly generates a fixed public link that I send to them. They open it in a browser and can use it, while permissions and keys stay in my hands, and I can revoke them whenever I don't want to give access anymore.

I ran through the whole process myself, from writing code from scratch to distributing the link to colleagues and getting it working, and it took about 2 hours in total. Below is the fully open-source, copy-and-paste, hand-holding full workflow.

In this article we discuss:

▸ Part 1 · Why we tend to say the wrong thing the moment we get anxious on WeChat

▸ Part 2 · Packaging "Nonviolent Communication" into a small local web tool

▸ Part 3 · Without buying a cloud server, how to turn a local tool into a link and send it to colleagues

▸ Part 4 · Cost, anti-sleep, and permission boundaries: think these through before you start

▸ Part 5 · Clients, superiors, partners... real rewrite tests across seven scenarios

▸ Part 6 · More than rewriting messages: what other local assets this approach can put to work for you

▸ Part 7 · A few of the most frequently asked practical details

Before you start: what you need to prepare

Who it suits: people who have AI-made Prompts, Skills, or small scripts that work well for their own use and want their team and friends to be able to open and use them anytime; or friends who simply want to casually build an emotional-intelligence rewriting tool and pick up the trick of exposing local services along the way.

Who it doesn't suit: commercial-grade production systems facing tens of thousands of concurrent users and requiring absolutely uninterrupted 7x24 operation. The core of this approach is using your own computer as the server; it suits small-team collaboration, internal tools, client demo validation, and small-scale sharing. At larger scale, formal cloud deployment is still recommended.

Preparation checklist:

A computer that is on every day (macOS or Windows both work; I use a MacBook Pro M5)

A Python 3 runtime (macOS basically has it built in; on Windows just install it from the official site)

A large-model API key (any platform compatible with the OpenAI format works, such as DeepSeek, AIsa, Alibaba Cloud Bailian, Kimi, etc.)

A UUMit account (go to uumit.com to register and download the client)

A real colleague or friend willing to help you test it (to complete the final external-access loop; they also need to register a UUMit account)

Part 1: First understand what this tool is doing

Speaking is a skill, but most conversations that turn into arguments share a strikingly similar underlying logic.

In his classic book Nonviolent Communication, Marshall Rosenberg dissects this problem thoroughly: the reason a sentence sounds jarring is not the fact itself, but the moral judgment, overgeneralization, shifting of responsibility, or coercive command wrapped inside it. What the other person sees first is not your request but that you are putting a label on them, and the defense and counterattack mechanisms are instantly activated.

The antidote given in the book is to break any communication down into four skeleton elements:

Observation: state only the objective facts that a camera could capture, without emotional labels. For example, "the weekly report was agreed last Friday to be submitted by noon today, and it hasn't been received yet" is an observation; whereas "you're always so slow" is a judgment.

Feelings: express your genuine emotion in the moment, such as anxious, worried, or in a tough spot. Note that "I feel ignored" is not a feeling—that is an accusation about the other person's behavior; change it to "I feel a bit let down" to make it a genuine feeling.

Needs: trace the root behind the feeling back to universal needs, such as predictable progress, information sync, and mutual respect. Stating the need is equivalent to taking responsibility for your own emotions, rather than shifting the blame onto the other person.

Request: propose a positive, specific action that can be responded to right now. "Can you be more responsible" is not a request; "Can you send it to me by two o'clock" is a specific, executable request.

Everyone understands the reasoning, but when people are angry, the brain is basically taken over by the amygdala. When you type "Why are you dragging this out until now again? I have to chase you every time," you have no attention left to run formulas in your head. What the EQ plugin does is exactly this braking job—before you hit Enter, it runs through the four elements for you and pulls out the thorns along the way.

And one point must be clarified: nonviolent communication is absolutely not principled people-pleasing. When chasing progress, be serious when seriousness is called for; when refusing added requirements, be firm when firmness is called for. So this tool has three built-in tones: gentle, firm, and direct. If you choose firm or direct, the rewritten stance will not shrink at all—it merely turns aggressiveness into certainty.

These rules actually come from an open-source project I previously built up: I broke the entire book Nonviolent Communication into an executable AI Skill that can be installed directly in Cursor and Claude Code. The distinction between observation and comment, pseudo-feeling filtering, and jackal-language recognition are all in there, and it already has more than 180 Stars on GitHub. The core Prompt of the EQ plugin is distilled directly from this Skill:

github.com/ayi-ai/ayi-nonviolent-communication

Part Two: Building the Tool

2.1 First, get clear on what the tool looks like

Before writing code, I first laid out the input and output structure:

The output structure was designed with five modules:

First is the risk rating of the original wording (not a big deal, a bit sharp, easy to start a fight); next is the harsh-word diagnosis, clearly pointing out which words in the original wording are likely to anger the other person and the specific reasons; then comes the message that can be sent directly plus a one-sentence condensed version; finally, the four-element breakdown and change notes.

The reason the risk diagnosis is placed in the most prominent position is that just giving the answer treats the symptom but not the root cause. Only by letting users see at a glance that "I have to chase you every time" is highlighted in red, with "sweeping generalization" written next to it—equivalent to directly labeling the person as a procrastinator—can everyone develop muscle memory the next time they type.

2.2 Let AI write the code for you

This does not require any deep programming background at all; the entire code was typed out for me by Cursor.

When giving requirements to AI, just stick to these principles: use only the Python standard library, with zero third-party dependencies; one service file app.py plus a single-page index.html; sensitive API Keys must never be sent back to the frontend; be compatible with all standard OpenAI-format interfaces, and support visual configuration in the interface.

The two files produced by AI are already open-sourced on GitHub and can be downloaded ready-made:

github.com/ayi-ai/qingshang-waigua

2.3 The tool's brain: the prompt

Whether a rewriting tool is good to use depends mainly on the System Prompt. This is the core Prompt running inside the EQ plugin—no reservations, straight to the substance:

Here are two hard-won lessons from painful experience:

First, never apply formulaic sentence patterns. Without constraints, the model keeps spitting out "When I see you... I feel...", and sending that on WeChat is instant social death; second, absolutely do not fabricate facts. The original wording only said the weekly report was not submitted, but the model loves to cleverly add "because the boss wants to see it at three in the afternoon"; if not restricted, it will invent facts, so it must be required to use 【】 placeholders for users to fill in themselves.

2.4 Seven types of recipients, seven sets of speaking rules

Communicating with different people involves completely different contexts. The tool has context injection tailored for each type of role:

Boundary definitions for the three tones:

2.5 Install the Python environment

macOS: open the built-in Terminal and type this line to check:

Windows: go to python.org to download the installer, and be sure to check Add Python to PATH during installation, otherwise the command line will not find the command. After installation, enter python --version in PowerShell.

2.6 First run it in example mode (zero-cost self-test)

To prevent spending money on the model right after starting, I wrote a MOCK mode: no API connection, no charges, purely local verification of the service and web link.

First download the code from GitHub (click the green Code → Download ZIP, extract to the desktop, rename the folder to qingshang-waigua), then enter the directory in Terminal and start it:

The terminal shows EQ Plugin started: http://127.0.0.1:8787 Model: I use deepseek, which means it is running locally:

Open http://127.0.0.1:8787 in a browser, and you will see an interface with clay tones and a paper-like texture. Enter a sentence and click "Help me revise"; if it returns the fixed weekly report example, that means the frontend and local service are interacting perfectly:

Press Ctrl + C in the terminal to stop the service.

2.7 Connect the real model

To make it actually do work, there are two ways to connect:

Method 1: Configure through the visual interface (most recommended)

Run python3 app.py directly, and the terminal will print a line: Setup passcode: xxxxxxxxxxxx. Open the web page and click Settings in the upper right corner, enter the passcode to unlock, and then you can directly select a provider in the drawer panel (DeepSeek, OpenAI, Alibaba Cloud Bailian, Kimi, etc.), paste the API Key, and click "Fetch model list from API" to check the models you want to enable.

The API Key is stored only in the local config.json with 0600 permissions, and the frontend displays it masked, so there is no need to worry about key leakage at all.

__XPOSTER_nm7t6_IMAGE_13__

Method 2: Start with environment variables

For model selection, this kind of single-step rewriting task does not need a full-power ultra-large model costing hundreds of yuan at all; the key is cheap, high-throughput, and good at colloquial Chinese. In actual testing, using deepseek-flash, revising one message is basically done within 3-5 seconds, and the cost is almost negligible.

2.8 Test it yourself first

After connecting the model, do not rush to send it out. First test it with several built-in typical irritable original phrases:

Focus on four things: whether harsh words are caught accurately, whether facts are fabricated, whether the tone softens after choosing firm, and whether the length balloons into a mini-essay.

Then try the most headache-inducing emotional scenario: your girlfriend sends the soul-searching question "You don't care about me at all":

2.9 If it won't run, check these places first

There is also a practical detail: shared links are often automatically appended by WeChat or DingTalk with query parameters such as ?from=.... The server-side routing must strip the path with urlsplit; otherwise requests with parameters will directly return 404. I have already fixed this pitfall in the open-source code.

Part 3: Turn the tool into a link with UUMit

The tool runs smoothly locally, but at this point it is still locked inside 127.0.0.1—if others type this address on their own computers, they are accessing their own machines, so naturally they see nothing.

In the past, to let colleagues and friends use it, the usual operation was to buy a cloud server, configure security groups, buy a domain name, apply for an SSL certificate, and in China also wait for the filing process; or mess with intranet penetration and self-host frp. For a lightweight internal tool, this whole chain is like using a sledgehammer to crack a nut, haha.

UUMit client targets exactly this pain point: install the client, and it can automatically recognize the web pages and applications running on your computer. With one click, it directly generates a fixed HTTPS public link—no server purchase, no certificate configuration, no router port opening, send it whenever needed, and revoke it at any time.

However, two underlying premises must be made clear: UUMit is not a cloud hosting platform; computation still runs on your laptop, so the computer must be on and the tool must be running. It is positioned for small-team collaboration, internal tools, demo sharing, and lightweight validation. Commercial products with tens of thousands of concurrent users should still properly go to the cloud.

3.1 Download and install the client

Go to uumit.com to download the desktop client for your system (macOS Apple chip / Intel or Windows):

On Mac, simply drag the icon into the Applications folder to complete installation:

3.2 Register and connect the computer

Open the client, log in to your account, and click Start Connection to bind the current computer:

3.3 Let the client recognize your tool

Make sure python3 app.py is running in the terminal, then return to the applications page of the UUMit client. It will automatically scan out the EQ Plugin on local port 8787:

3.4 Claim a fixed link

Find EQ Plugin and click Connect, and the system will immediately assign a dedicated fixed HTTPS URL:

Open this link on your phone to test it; it opens instantly and smoothly:

This also unlocks another high-frequency scenario: with the tool running on a computer at home or at your workstation, you can open the link on your phone while on the subway or on a business trip and revise messages at any time.

3.5 Write a clear homepage and capability introduction

When colleagues open the link, the last thing they want to see is confusing technical jargon. UUMit provides a capability showcase homepage. It is recommended to write only scenario tasks, not pile up empty titles. Writing "Communication Master Agent" leaves people unsure what it can do; writing "Turn heated words into something the other person can take in" immediately tells everyone when to use it.

3.6 Choose the access scope

After the application is connected, it is by default in the secure locked state of only me. UUMit provides three scope switches:

Note: UUMit is responsible for controlling who can open the entrance. To prevent external users from over-calling and blowing through your model quota, frequency and total limits have already been controlled in the EQ Plugin's own settings panel (see Part 4 for details).

3.7 Invite colleagues/friends

The sharing process is extremely simple, three steps in total:

In the "Members and Invitations" module on the right, click Invite Friends to generate a dedicated invitation link and QR code;

Click Copy Link to send it to a colleague via WeChat or Feishu (scanning the code in person also works);

When the colleague opens the link and logs in to UUMit with their phone number or an existing account, they can go straight into the tool, and once they join they will automatically appear in your member management list.

Throughout the whole process, the colleague does not need to install any development environment or client software on their own computer at all—it opens lightweight in a pure browser. For security, the invitation link is shown only once when generated and is automatically hidden after you leave the page; you can void and regenerate it at any time.

3.8 Let the colleague try it themselves once

Whatever you do, do not do this step for them. Send the link over and leave just one sentence: This is a little message-rewriting tool I put together—try it with something you have been wanting to send lately but have not dared to.

This is the feedback from a colleague who actually rewrote something on their own device:

3.9 Revoking permissions

When a project wraps up, personnel change, or you no longer want it open to others, just click Remove in the member list at any time; permission is revoked in milliseconds, and the other party will be blocked at the door the next time they refresh the link:

Part Four: Security and costs—these are things we absolutely must think through clearly

The computer has to stay running

Because the compute runs on your own device, once the laptop lid is closed and it goes to sleep, external links will be interrupted.

On macOS, you can add an anti-sleep command before the startup command:

This way, as long as the tool is running, the system will not automatically turn off the screen and sleep; after you close the program, the restriction is automatically lifted. If you want to provide service around the clock, the most reliable option is to find an old Mac mini or desktop that is plugged in and always on, and leave it running.

The cost is on you, so set up rate limiting as a fallback

English text is being prepared.

Privacy and desensitizing sensitive information

EQ Plugin itself uses a stateless design, and neither memory nor disk persists any conversation records. But the data does pass through the upstream model service provider after all. When core business secrets, specific quotations, or real names are involved, it is recommended to first use 【】 or aliases as placeholders, and then manually fill them back in after rewriting.

Do not casually expose a complete Agent environment publicly

What this article demonstrates is opening up a small tool with a single function and strictly controlled input and output, where the risk is fully controllable. But if what you are playing with is a persistent Agent environment like DSH, be especially vigilant—a complete desktop-level Agent often comes with high-risk permissions such as terminal execution and local file read/write. When sharing externally, be sure to extract the independent capability into a micro-tool separately, and do not hand over the entire computer's operating context wholesale.

Part Five: Seven scenarios and how to use each one

With this foundation in place, the focus of rewriting shifts to specific communication scenarios. The seven types of roles configured in the tool each solve a different pain point:

With clients: professional, but not servile

When facing payment reminders, requirement changes, or clients comparing prices, the worst things to do are either to snap back with emotion or to give in and apologize without bottom line. Choose a firm tone to hold the line while still giving the other side a graceful way out:

With superiors: state the conclusion and solution first

When facing a dead end where progress cannot be completed, the worst thing in reporting upward is one-way complaining. The tool automatically restructures complaints into a conclusion + feasible alternative plans:

With colleagues: address the matter, not the person

When following up across departments, strip out all sweeping accusatory wording and bring the focus back to the specific blocking point:

With subordinates: make the standard clear and leave enough room

Avoid empty lines like Do you even care, and clearly explain the deviation from the standard while giving actions for collaborative revision:

With a partner: receive the emotion first, never argue logic

In intimate relationships, the great taboo in communication is writing long reasoned arguments in WeChat. The tool forcibly removes workplace tone and prioritizes empathy for the other person's grievance:

With family: speak softly and talk about concrete matters

Between parents, trivial matters most easily trigger opposition; the rewriting strategy focuses on gentle discussion and specific daily-life requests:

With friends: direct and sincere, no sarcasm

For awkward matters like asking for money back, for example, beating around the bush often hurts the relationship more, while laying out the facts frankly is actually the best solution:

Part Six: Where else this method can be used

EQ Plugin is just one entry point I have gotten working myself; the local application distribution logic of UUMit can support far more scenarios than rewriting a sentence.

The criterion is extremely pure: is the thing you want to share currently running on your own computer?

If it is, you can directly apply this paradigm: start locally → client recognizes it → generate link → issue keys with authorization per person.

Here is the most easily understood pain point: taking orders and independent development.

In the past, after you finished a web project for a client and the client said, Can you send it to me first so I can take a look, you often had to first buy a server, configure the environment, buy a domain, and even wait for filing—spending hundreds to thousands of yuan and several days just to let someone take a look at the result.

Now you can just run the project locally from the command line, open the client, click once to generate a link and send it over; what the other party sees is always the latest code; after you change one line, their refresh syncs immediately; before final payment is settled, you can revoke permission at any time, one key per client, with no need to redeploy for every project.

If you also have small AI tools you use smoothly in daily work, swapping them in is equally simple:

The UUMit team previously shared a real case: a finance colleague built a receipt-reimbursement assistant that ran on their office computer, authorized the link for department colleagues, and everyone could simply snap a photo of an invoice, upload it, and automatically extract the amount and generate an itemized table—it ran extremely smoothly within a small internal scope.

To swap in your own logic, you only need to change three core things: the frontend input fields, the system prompt rules, and the expected output format. The framework code can directly reuse the entire structure of the EQ plugin.

Part Seven: Frequently Asked Questions

Do colleagues need to install software to use it?

No. Colleagues or friends can simply open it in a browser; they only need to register a UUMit account to complete identity verification (if the permission is set to the public-for-everyone tier, then not even login is required).

Can others still use it if my computer is turned off?

No. The service runs on your physical machine; if the machine goes to sleep with the screen off or loses network access, external access is immediately cut off.

On security, could this let others penetrate into my computer?

The client uses a pure outbound one-way connection mechanism and does not open any inbound listening ports on your router or local firewall; what the other party can access is strictly limited to the single port or path you explicitly bind.

Why not just send the prompt to a colleague and have them run it in the web version of ChatGPT?

The core value of making it a standalone tool lies in lowering the barrier and accumulating experience: the other party does not need an advanced AI account, does not need to copy and paste long rules every time, does not need to be taught parameter configuration, and after your algorithm or prompt is updated and iterated, the other party gets the latest version with a refresh they do not even notice.

Can this service itself charge per call for external invocations?

At present, the direct paid invocation mechanism for this UUMit pipeline has not yet been officially opened; the current positioning focuses on small-scope sharing, team collaboration, and results demonstrations.

Can it be summoned in place directly in the WeChat or Feishu input box?

WeChat does not support arbitrary injection due to official protocol restrictions. I am currently building a pure local Mac global shortcut version on top of this backend (select text in any input box, press the shortcut to replace and rewrite in place); after debugging is complete, I will organize the standalone solution separately.

I don't know how to write code at all—can I really get it running?

Absolutely. From running Python to the code structure, everything is generated with AI assistance; you only need to follow the directory hierarchy and commands in the article, paste the code into the folder, and it can run directly.

Finally

The complete project source code and usage documentation are all open-sourced:

github.com/ayi-ai/qingshang-waigua

This article was not written to show off technical prowess, but to break a habitual way of thinking: a good tool you have polished to suit yourself does not have to be stuck behind the high wall of cloud operations; it can also enter real collaboration in an extremely lightweight way.

Do you also have a set of AI tools that you use very comfortably in daily life but that have always just lain in your own folder? Why not try connecting it outward and letting the people around you truly use it once.