I built a to-do mini program in Cursor with one sentence. Never opened WeChat DevTools, never opened the CloudBase console.
First, some background, so you can judge whether this post concerns you.
There's a clear trend in the 2026 dev-tool world: big companies are all "opening their capabilities to AI agents". GitHub shipped Copilot Extensions, Vercel and Supabase opened MCP in turn, and even databases are competing to be the "hands and feet" of agents. This month, WeChat DevTools joined in — and what it gives agents isn't just code completion, it's the whole "cockpit" of mini programs.
This post takes about 6 minutes. If you build mini programs, or plan to, read to the last section.
One: if you build mini programs, recall yesterday's dev rhythm
AI writes a chunk of code → you switch to WeChat DevTools → click compile → check the simulator → copy the error → switch back to AI → paste → AI fixes it → switch back again…
One feature, twenty or thirty window switches.
The problem isn't that AI is dumb. Your agent can read/write code and run commands, but it can't see the "world" inside DevTools: whether compilation succeeded, what the page renders like, what errors the Console reports, whether the cloud function actually deployed.
It's like a top chef who has recipes memorized cold but can't see the pot, smell the food, or taste the seasoning — cooking from imagination while you taste-test for it over and over. This is "blindfolded programming."
All the efficiency is wasted on switching, not on writing code.
Two: WeChat DevTools handed the "cockpit" to agents
Recently WeChat DevTools did something: it opened a set of operable, debuggable, verifiable mini program Skills to developers' coding agents.
Translation: your agent can now complete the entire dev flow inside DevTools by itself — open a project, read status, adjust config, compile, operate the simulator, read logs, locate problems, preview/upload, manage cloud development resources.
Before, AI could only write code for you. Now it can verify whether the code is correct on its own. That difference is the premise for everything that follows.
A side-by-side makes it clear:
| Before, only | Now |
|---|---|
| Read/write code | Auto-compile, verify compilation results |
| Run commands | Operate the simulator, screenshot to verify layout |
| Guess at errors | Read Console/Network logs, locate root causes |
| Hard-coded | Auto-deploy cloud functions, verify reads/writes |
| Armchair planning | Push real-device preview, see it on your phone |
Three: scenario one — one sentence, the agent builds the DB, deploys functions, previews on device
I tried the plainest scenario: typed "build a to-do mini program, store data in CloudBase, previewable on a real device" in Cursor.
Then I watched it run the whole thing on its own: create database collections, write cloud functions, deploy via CloudBase, summon the simulator to screenshot-verify, and finally push a real-device preview to the phone.
My only involvement mid-way — clicking "Allow" in a popup.
The point isn't "AI wrote code", but "AI verified the code actually landed". Build the DB, deploy, verify, preview — this chain used to require clicking five or six places manually; now it ran end to end in your familiar editor.
It's also here that CloudBase naturally entered the story: cloud function deployment, cloud database reads/writes, permission rules — all done by the agent through CloudBase's capabilities. Without the CloudBase half, the agent could at most write your front-end code, and you'd have to take over manually afterward.
Four: scenario two — stop hand-carrying errors, AI reads the logs itself
The second scenario is even better.
A cloud function errors. Before, you'd hand-carry the error from the console to AI, and it would guess. Now the agent digs through CloudBase logs (CLS) directly, locates the root cause itself, fixes it itself, redeploys itself.
This is the real "closed loop". The old "copy error — paste — AI guesses — you verify" round trip collapsed into a single sentence.
Five: CloudBase — the other half that closes the agent's loop
Looking at WeChat DevTools Skills alone, the agent can compile, screenshot and drive the simulator. But to truly go "from idea to launch", the cloud half is still missing: database, cloud functions, storage, permissions, logs.
That half is CloudBase.
Let's be concrete — this is also why I dare recommend you try it. For individual developers, CloudBase's free quota is generous:
- Cloud database: 50,000 reads / day, 30,000 writes / day (official base-tier free quota)
- Cloud functions: free monthly call quota; the Personal plan is enough to run a practice project
- Cloud storage / static hosting: free within the base quota
- Monthly cost: for a personal practice project, the dev/test phase is basically ¥0
The 2026 indie developer recipe = AI Agent × WeChat DevTools Skills × CloudBase One person. Three tools. From idea to store.
(You can screenshot this section and post it to Moments.)
One honest line: free is phased, not permanent. Once traffic grows, you pay as you go — that's the norm for all cloud services. But taking an idea from 0 to a presentable prototype — the free quota is more than enough. I've confirmed that for you.
Six: the safety brakes
Some will definitely worry: the agent can deploy and publish — won't it run wild?
Three safeguards:
- Dangerous operations (deploying cloud functions, publishing trial versions) pop an explicit confirmation — you authorize before execution;
- Fetching sensitive info like AppID and cloud environment requires your explicit authorization;
- All Skill calls run locally inside DevTools; code and logs aren't uploaded to the cloud.
In other words, it can work fast, but the steering wheel stays in your hands.
Seven: two steps to get in
If you want to try, two steps:
Step 1: download the new WeChat DevTools. Get Nightly Electron Build 2.02.2607032 or above from the DevTools download page.
Step 2: install the Skill — two ways.
Method one (geek's choice): after installing, run wechatide in the terminal, copy the Skill path it outputs, and paste it to your agent.
Method two (beginner-friendly): DevTools menu → "Export DevTools Skill" → export → import into your AI agent.
The CloudBase half needs no separate setup — the agent authorizes on demand when it's needed.
My total bill for all this was ¥0. Not because I'm cheap — the free quota genuinely lets an indie developer take an idea end to end.
If you already use CloudBase, this combo just saves you window-switching; if you haven't — this post is to let you know that opening an environment and running a mini program now has a far lower barrier than when I wrote similar tutorials last year.
Think I'm wrong? Call me out in the comments. Find it useful? Share it with that friend who always complains "mini program dev is too fragmented."
I'm A Shu. Next up: how one person grows a mini program until it makes money.
