DEV Community: 张洲诚（Zack.ZHANG）

I Stopped Guessing Which LLM to Use — It's One Command and My Own Numbers Now

张洲诚（Zack.ZHANG） — Fri, 14 Aug 2026 11:41:52 +0000

The freelance gig that stalled on question one

Last month I took on a freelance build: a customer-support bot for a DTC store. Three hard constraints — it must understand photos customers upload, sustain ~50k calls a day, and the budget was thin.

The code wasn't the hard part. Question one was: which model.

I opened the model catalog and stared. The Qwen family alone spans flash/plus/max tiers with dated snapshots; below that, a dozen third-party models. Every one has a spec page and a price sheet. None has a row that says "support bot, image input, cost-sensitive."

Benchmarks didn't help — they measure someone else's scenario (long-context recall, competition math). Free-tier roundups are static snapshots that rot in a quarter, and they tell you who has quota, never what your project should run on. Asking a general-purpose LLM was the worst option: it confidently recommended a model I'd never seen in the catalog. I checked. It doesn't exist. Training memory is the wrong tool for a question whose answer is live data.

Context worth naming: OmniRoute, a free MIT-licensed AI gateway, crossed 47k GitHub stars this month — one endpoint, 330+ providers. People clearly want model selection to stop being their job. But a gateway solves "route me to whatever's cheap and alive," not "which model fits this scenario."

The one command

What closed the ticket was a subcommand in Model Studio's CLI, bl. (My previous post was about an agent reading provider docs locally — that solved lookup; this one hands the decision to the terminal. They stand alone.)

npm install -g bailian-cli
bl auth login

Node.js 18+. API key at login — get one in the console; the CLI install guide covers prerequisites.

Then I wrote the client's constraints as one sentence:

bl advisor recommend --message "E-commerce support bot that reads product screenshots uploaded by customers, ~50k calls/day, cost is the priority"

Ten seconds: intent analysis plus three ranked picks. The top one (trimmed from real output):

{
  "model": "qwen3.7-flash-2026-07-15",
  "category": "Cost-optimized",
  "contextWindow": 1000000,
  "reason": "The model is specifically designed for cost-optimized, high-concurrency scenarios ... ideal for handling 50,000 daily API calls under a low budget.",
  "docUrl": "https://help.aliyun.com/document_detail/3016807.html"
}

Every pick carries a docUrl to the official spec-and-pricing page. Treat the ranking as the starting point, then verify against the doc.

How it thinks: three stages

--dry-run runs the first two stages only — intent analysis and candidate recall — skipping the final LLM ranking (and its cost):

{
  "intent": {
    "scenarioHints": ["high-concurrency", "consumer-facing", "low-latency", "cost-sensitive", "image-input", "text-output"],
    "inputModality": ["Image"],
    "budget": "low",
    "qualityPreference": "cost-optimized"
  },
  "candidateCount": 50,
  "candidates": [{ "model": "qwen3.5-27b", "score": 0.509 }, "...50 total"]
}

Plain language becomes structured constraints: "understands screenshots" → inputModality: Image; "~50k calls/day" → high-concurrency. Candidate recall reads live catalog data — that's the honest difference from asking a chatbot, which will invent a plausible-sounding model that doesn't exist.

Change the scenario, change the answer

My partner's contract-review tooling (legal-tech, precision-first, a few dozen contracts a day) got a completely different result from the same command: budget: medium, qualityPreference: flagship, and a top pick of farui-plus — a legal-domain model I'd never heard of, because leaderboard authors don't test vertical-domain legal models.

That's the dividing line: a leaderboard gives every scenario the same answer; scenario-based selection gives each scenario its own.

Your account's real numbers

One prerequisite that will bite you: the usage/quota commands authenticate against the console, not your API key. Key-only auth gets you exactly this (my real output):

{
  "error": {
    "code": 3,
    "message": "No console access token found.",
    "hint": "Run `bl auth login --console` or set DASHSCOPE_ACCESS_TOKEN."
  }
}

Fix: bl auth login --console (coexists with your key). Then:

bl usage free --expiring 30          # quota expiring within 30 days
bl usage stats --days 30 --workspace-id <id>   # real usage distribution
bl quota check --model qwen3.7-flash-2026-07-15  # RPM/TPM headroom

usage stats requires --workspace-id — bl workspace list finds it, or pin it with bl config set workspace_id <id>.

Free-tier traps (checked against the docs)

Quota expires: 30–90 days depending on model, from activation. Doesn't pause, doesn't renew, doesn't roll over. Hence --expiring 30 in your calendar
Per-model quota: typically 1M tokens each, not mergeable. A dated snapshot and the undated latest are separate models with separate quotas
No failover on exhaustion: calls just start billing (on completed accounts). Pin --model in scripts at your own risk — or use the kill switch: bl usage freetier --model <m> --on returns AllocationQuota.FreeTierOnly instead of charging

What it is not

It recommends within Model Studio's catalog — not a cross-vendor comparison. It produces a ranked starting point, not a verdict. Gateways (OmniRoute et al.) solve routing and availability; this solves scenario fit. Stack them if you like — someone still has to fill the gateway's fallback list.

The takeaway

Catalogs and prices shift monthly, so model selection is a recurring decision, not a one-time one. Making it a repeatable command beats being told the right answer once. Entry point: the Model Studio console.

All commands verified against bailian-cli 1.4.2; outputs shown are real runs. Free-tier terms checked against official docs at publication time.

One System Prompt, Five Text Jobs: Compliance Screening, Review Tagging and Contract Extraction from the Terminal

张洲诚（Zack.ZHANG） — Wed, 12 Aug 2026 09:12:13 +0000

The backlog

A friend's small Etsy/Shopify shop got its product page rejected twice for over-claiming — and her keyword-blacklist checker had passed it both times, because those tools match strings, not meaning ("quietest" flags, "quiet-operation benchmark" sails through).

Fixing that led to counting everything else her shop publishes or receives and never reads: 300+ negative reviews sitting in the dashboard, hundreds of pre-sale messages, a 20-page supplier agreement. Pasting any of it into a chatbot produces prose — "customers seem unhappy with shipping" — which answers nothing you can act on. Which issue? How many? Enterprise review-analytics SaaS answers that for four figures a year, which a one-person shop won't pay.

Here's what worked instead: Alibaba Cloud Model Studio's CLI (bl), a system prompt that acts as a JSON schema, and a shell loop. Five kinds of text, one pattern. Show and tell below.

Setup

npm install -g bailian-cli
bl auth login

Node 18+. API key from the Model Studio console — free tier included, and bl usage free shows what's left. Install guide here.

The one command everything else is a variation of

bl text chat --model qwen-turbo --quiet --system "You are a review analyzer. Output JSON only, no extra text. Fields: sentiment(positive/negative/neutral), dimension(quality/shipping/support/price/other), severity(high/medium/low), summary(under 12 words). If undeterminable, use 'unknown' — do not guess." --message "Stopped heating after three days and support took a week to reply."

{"sentiment": "negative", "dimension": "quality", "severity": "high", "summary": "failed in three days, slow support"}

Three schema rules I learned the hard way:

"JSON only, no extra text" — otherwise you get a polite "Sure! Here's the analysis:" prefix and your parser dies
Enumerate the allowed values — otherwise "shipping", "delivery" and "logistics" show up as three different dimensions and your group-by is confetti
"Use 'unknown', don't guess" — otherwise a review that just says "fine" gets a confidently invented label

The loop (this is the whole "batch framework")

mkdir -p out
while IFS= read -r line; do
  bl text chat --model qwen-turbo --quiet --system "You are a review analyzer. Output JSON only. Fields: sentiment, dimension(quality/shipping/support/price/other), severity(high/medium/low), summary(under 12 words). Use 'unknown' if undeterminable." --message "$line" >> out/results.jsonl
done < reviews.txt

300 reviews, ~15 minutes, one JSON per line. Aggregation for small files: feed it back —

bl text chat --system "Input is line-delimited JSON of review analyses. Output a stats table: count by dimension descending, high-severity count per group, one-line summary of top three issues." --message "$(cat out/results.jsonl)"

For thousands of rows, do the counting in jq or a pivot table instead — deterministic math shouldn't run on a probabilistic model.

The result that mattered

Shipping damage: 41 mentions. Product quality: 38. Support: 22. Her gut said quality was the top complaint; the data said shipping damage. She took the "41" to her carrier the next morning. The gap between gut and data is the product here.

Accuracy, honestly: 28/30 on a manual spot check. The two misses were sarcasm — every model's weak spot, not fixed by paying for a bigger one.

Same pattern, different system prompts

Ad compliance pre-check: JSON array of {quote, risk_type, explanation, suggested_rewrite} — caught an implied health claim ("say goodbye to lung-harming fumes") that no keyword blacklist would ever match. It's a self-check aid, not legal advice.
Contract clause extraction: {payment_terms, liability, dispute_resolution} with the load-bearing instruction "quote verbatim, never paraphrase" — paraphrased legal text is subtly wrong legal text.
Support inbox tagging: {intent, keyword} over a few hundred messages; compatibility questions turned out to be half of pre-sale volume, so the compatibility chart moved up the product page.
The inverse case — one long competitor analysis — flips the model strategy: default flagship, --max-tokens 8000 (default 4096 truncates long reports), and "never fabricate figures" in the system prompt.

Cost

bl usage stats --days 7 says the entire evening — 700+ calls — cost pocket change, mostly inside the free tier. The SaaS quote she'd gotten starts at four figures annually.

When not to do this

Forty reviews? Just read them. Can't write down what "high severity" means? The model can't tag it either. Anything with legal weight? This locates and drafts; a human decides.

If you've got a text backlog of your own, start with one review and one command: free tier here.

Curious: has anyone wired this kind of tagging loop into a scheduled job with drift monitoring? That's the part I haven't built yet.

I Installed a Pile of Agent Skills. It Still Couldn't Hand Me a File.

张洲诚（Zack.ZHANG） — Mon, 10 Aug 2026 01:58:09 +0000

The moment that made me look at my setup differently

Last week I needed to ship a post. It needed a cover image with the title rendered into it, plus an audio version for the team channel.

I asked my agent. It gave me a completely reasonable answer: use a design tool for the image, find a TTS service for the voiceover, here are some options you might like.

I had a pile of skills installed at that point. It understood my codebase. It matched my writing style. It could not hand me a single file.

Everything I'd installed was on the input side

If you've been watching GitHub trending, you've seen the same wave I have. In the last week of July, three of the top 20 fastest-growing repos were skills:

graphify — about +4,900 stars that week. Turns your codebase, docs, and PDFs into a queryable knowledge graph. Code parsing runs locally through tree-sitter AST, nothing leaves your machine.
hallmark — about +4,800. Exists purely to strip AI-slop out of design and copy.
i-have-adhd — about +3,270. Stops the agent from burying the answer under three paragraphs of preamble.

Plus find-skills sitting north of 60K subscribers, with half the tutorials now opening with "install this one first."

I lined up what I'd actually installed:

Skill	What it handles	What it produces
graphify	Reads code, docs, PDFs	Graph data + analysis
hallmark	Governs style	Text
i-have-adhd	Governs output structure	Text
find-skills	Finds other skills	A list

Every one either helps the agent understand something, or helps it say things better. Both genuinely useful. Both stop at text.

The moment you need an artifact — a PNG, an MP3, an MP4, text lifted out of a screenshot — there's nothing in the toolset. The agent recommending external tools isn't a cop-out. It has no output path.

The ecosystem has been hot for months and the output side is still close to empty.

Bonus: why some skills never seem to fire

This one bugged me for a while, and the Claude Code docs answer it directly (as of July 2026):

When the agent starts a session, it builds a manifest of every available skill along with its description, then uses the description field to decide whether any skill matches the request.

Two things fall out of that:

1. description is a routing key, not a docstring. The agent isn't reading through your skill files inferring intent — it's matching against descriptions. Skills whose descriptions spell out trigger scenarios and keywords get picked far more reliably. If you write your own skills, that field earns more attention than the body.

2. The manifest is built at session start. Anything installed mid-conversation may be invisible for the rest of it. Restart the session after installing — that's not superstition, it's how the manifest works.

Also worth knowing: Claude Code skills follow the Agent Skills open standard, which applies across multiple AI tools. The mental model transfers when you switch harnesses.

Filling the gap

Alibaba's Model Studio team maintains a skills repo (modelstudioai/skills, Apache-2.0) covering exactly the output side — image, speech, video, vision — all on top of one CLI called bl.

Same install motion you already know:

npx skills add modelstudioai/skills
npx skills add modelstudioai/cli --all -g

Node.js 18+, plus an API key (grab one here, or read the CLI install docs). Restart the session afterward — see above.

What changes: you stop memorizing commands. You describe the outcome, the agent assembles the call.

Cover image with the title rendered in

bl image generate --prompt "Clean technical article cover, dark background, crisp title text centered in frame, smaller subtitle beneath, faint geometric lines and terminal window motifs, flat design, no clutter" --size 16:9 --model qwen-image-2.0-pro --watermark false --out-dir ./covers

Both the title and subtitle landed correctly in the composition, and the terminal motifs showed up as asked. Text is part of the image — no second pass to overlay it.

A behavior worth knowing about: --size accepts a ratio (16:9) or pixels joined by an asterisk (1280*720). Write it the habitual way as 1280x720 and the CLI does not complain locally — run --dry-run --output json and you'll see "size": "1280x720" sitting in the request body, forwarded as-is. If you're scripting this, normalize upstream. Also --watermark defaults to true, so clean output needs it set explicitly.

Text to speech

bl speech synthesize --list-voices --model cosyvoice-v3-flash
bl speech synthesize --text-file ./intro.txt --voice longxiaochun_v3 --rate 0.9 --out ./intro.mp3

You can't invent a voice name — run --list-voices first. The default model returns a couple dozen voices as IDs plus a one-line style note (longxiaochun_v3, longcheng_v3, longtian_v3, …), all bilingual EN/ZH.

Speech rate is --rate (0.5–2.0), not --speed — which is the flag everyone reaches for first, myself included.

Reading a screenshot

bl vision describe --image ./error-screenshot.png --prompt "Transcribe the error message and key stack frames verbatim"

The command is bl vision describe — vision is the group, describe is the subcommand. Local paths work directly; upload happens inside the command.

Video, and one gotcha

bl video generate is async. Pair it with bl video task get and bl video download --task-id <id> --out <path>. Note that --poll-interval defaults differ per command — 5 seconds for video generate, 15 for video edit and video ref. Don't copy one polling value across all of them.

The money part

Output-side calls cost money, and here's the part worth sitting with: the agent decides how many calls to make. Ask for three candidate covers and that's three billable calls. That's a different mental model from text-only skills.

Set the guardrail before you start playing:

bl usage freetier --all          # auto-stop when free quota runs out
bl usage free --expiring 30      # console command — run `bl auth login --console` first
bl usage stats --days 30

Two things to verify rather than assume:

Free tier is not permanent. Validity windows, per-model allocation, and regional eligibility all have specific rules — check the official quota page for your account's region. Third-party "free tier roundup" posts get this wrong often enough that they're not worth trusting.
Quota does not fail over. When one model's allocation is exhausted, nothing routes you to a model that still has budget. You change the model parameter yourself.

Who this is for

Worth it if you're already installing skills and regularly need the agent to produce files — covers, voiceovers, demo clips, text out of screenshots. The flow stays in one place, no shuttling assets between tools.

Skip it if your work lives entirely in code and prose. It'll sit unused and still consume manifest context.

Different tool if you need precise composition control or batch-consistent style — a local ComfyUI node graph wins there, at the cost of a GPU and a workflow to maintain. Not the same problem.

One genuinely useful side note: that repo also maintains a curated index of third-party skills tracked from Anthropic, Vercel, Google Labs and others, flagged for whether the team actually verified them working, grouped into skill management, code, design, docs, video, and testing. If you're in the hunting phase, that list saves time on its own.

Console's here if you want to poke at it.

Closing

The thing this skill wave makes easy to miss: an agent's ceiling is the ceiling of the tools in its hands.

graphify gives it eyes for code structure. hallmark gives it taste. The output side lets it actually hand you the thing. None of them compete — you fill whichever gap is costing you.

Asking for a cover and a voiceover no longer gets me a list of tool recommendations.

Anyone else run into the "installed but never fires" thing? Curious whether the description-matching explanation matches what you've seen.

I Built the Entire Pre-Production Kit for a Vertical Drama in One Evening — From One Terminal

张洲诚（Zack.ZHANG） — Fri, 07 Aug 2026 09:22:39 +0000

The gig

A friend's three-person studio landed an 80-episode vertical drama (the ReelShort/DramaBox format: 60-second episodes, cliffhanger every minute). The producer wanted a pre-production package for episodes 1-3 in a week: scripts, character look references, shot lists, a narration sample.

Their workflow was three browser tabs playing relay — chatbot for scripts, image site for character looks, another tool for storyboards — with copy-paste as the integration layer. Episode 4 needs the character bible from episode 1, which lives... somewhere in a chat scroll.

The reframe: pre-production is asset production, and assets are files. Alibaba Cloud Model Studio's CLI (bl) runs text, image, and speech models from one terminal, so the whole kit became one folder. Show and tell below.

Setup

npm install -g bailian-cli
bl auth login --api-key sk-xxxx
mkdir -p drama/ep1-3/{script,roles,casting,storyboard,art,audio}

Node 18+. Key from the Model Studio console — free tier included, bl usage free shows the balance. Install guide here.

Scripts: genre rules live in the system prompt

bl text chat --max-tokens 8000 --system "You are a vertical short-drama screenwriter. One-minute episodes, every episode ends on a hook. Output per scene: setting, character actions, dialogue, shot suggestion, duration. 3-5 main characters." --message "Second-chance revenge romance: heroine betrayed and killed by her fiance and best friend, wakes up one month before the engagement. Write episode 1." > script/ep1.md

Two things I learned the hard way:

--max-tokens 8000 — the 4096 default truncated the script mid-scene-five
"every episode ends on a hook" must be explicit — otherwise the model paces like prestige TV and vertical-drama viewers swipe away

The character bible: most valuable file in the repo

Serials die by character drift. Fix: a structured bible that every downstream step references.

bl text chat --max-tokens 8000 --system "Extract all main characters. Output a bible per character as JSON: {name, role, age, appearance(hair/face/build/signature outfit — concrete enough to draw), personality_keywords, core_motivation, arc}. Ban vague phrases like 'strikingly beautiful'." --message "$(cat script/ep1-v2.md)" > roles/roles.json

"Concrete enough to draw" is the load-bearing clause. Without it: "coldly elegant" → ten runs, ten faces. With it: "long straight black hair, center part, oval face, cream turtleneck under camel coat" → a description that pipes straight into the image prompt.

Look tests: 12 casting references for cents

bl image generate --prompt "Vertical drama heroine look test, 25, long straight black hair center part, oval face, cream turtleneck under camel coat, studio grey backdrop, cinematic lighting, vertical half-body" --size 3:4 --n 3 --seed 42 --out-dir ./casting --out-prefix heroine

--n 3 per run, --seed 42 so a prompt tweak doesn't reroll the whole vibe. Honest boundary: generative models don't hold a face across images. These are casting references and mood boards, not promo material — we printed that caveat on the deck's cover page and the producer read it as professionalism, not weakness.

Shot lists, concept frames, art boards

Shot list = text job with the table schema pinned in the system prompt (shot number / type / frame / action / VO / duration / lighting notes) — the director argues with row numbers. The money shot gets a 16:9 concept frame; sets, props, and costumes reuse the same command with different prompts and sizes (16:9 / 1:1 / 3:4). Nine boards in half an hour, each with a concrete downstream user: location scout, props team, wardrobe.

Narration sample

bl speech synthesize --list-voices --model cosyvoice-v3-flash
bl speech synthesize --text "Three years ago she walked away with nothing. Today she is the youngest executive director the group has ever named." --voice longtian_v3 --out audio/narration-demo.mp3

Gotcha from testing: stacking --instruction on a system voice returns a 428 — pick the style via the voice itself.

The ledger

3 scripts, 4 bibles, 12 look tests, 3 shot lists, 9 boards, 1 MP3 — one evening, single-digit dollars per bl usage stats --days 7, mostly free tier. The real win is the shape: the folder is a Git repo. Episode 4 starts with cat roles/roles.json into the prompt — no drift. Wardrobe change request = edit one bible field, rerun two commands.

When not to do this

Funded production's final art pass (a concept artist's work and an AI draft are different products); anything needing face consistency across images; and the script's soul — the model writes competent scaffolding, the 2 a.m. binge factor still comes from a human.

Pitch package due next week? Start with one episode: free tier here.

Curious: anyone wired script → storyboard regeneration into a Git hook? That's the automation I haven't built yet.

Batch Text Analysis with an LLM CLI: 500 Reviews, One For Loop, a Few Cents

张洲诚（Zack.ZHANG） — Thu, 06 Aug 2026 03:11:21 +0000

I tried to get an AI to label 500 Etsy reviews by pasting them into a chat tab, twenty at a time. By batch three, the model had quietly invented a new category that wasn't in my labeling scheme. That's not a model problem — it's a container problem. Long conversations drift; batch work needs rules that don't.

So I moved the whole job into the terminal. This post is the full walkthrough: sentiment labeling for 500 reviews, a contract risk checklist, an AI-writing check for a thesis chapter, and turning a 2-hour lecture video into Obsidian notes. Total cost for the week: under $0.50.

The Tool

bl is the CLI for Alibaba Cloud Model Studio. Install with Node.js:

npm install -g bailian-cli

Get a free API key from the Model Studio console (new accounts include a free tier), then:

bl auth login

Pattern: Rules as Files, Input as Files, Output as JSON

The whole approach fits in one sentence: put your labeling rules in a file, feed inputs from files, write structured output to files. Every call gets identical rules — drift is gone by construction.

rule.txt:

You are a review analyzer. For the input review output JSON: {"sentiment": "positive/negative/neutral", "aspect": [matching items from "quality","shipping","packaging","price","service"], "intent": "praise/complaint/suggestion/question", "summary": "under 10 words"}. Output JSON only.

The loop:

for f in reviews/*.txt; do bl text chat --model qwen-turbo --system "$(cat rule.txt)" --message "$(cat "$f")" --output json > "out/$(basename "$f" .txt).json"; done

Three deliberate choices:

--model qwen-turbo: labeling is factory work, not reasoning work. On a 50-sample side-by-side, the budget tier matched the flagship default — at an order of magnitude lower cost. The 500-review batch cost cents.
--output json: results feed straight into a spreadsheet or script. (Piped output defaults to JSON anyway.)
File-per-review: 3 items failed on special characters; retrying meant re-running exactly 3 files, not the batch.

Sequential run: ~40 minutes. With --concurrent 4: ~11 minutes.

The aggregate: 62% of negative sentiment pointed at "shipping," and 17 product suggestions were hiding inside 5-star reviews. My friend had skimmed those reviews for three evenings and come away with vibes; the loop came back with numbers.

Contract → Risk Checklist

Same command, different contract (pun intended). The trick is the negative constraint:

bl text chat --system "You are a contract reviewer. List ONLY clauses that are unfavorable or unusual for the contractor. For each: quote the exact wording, explain the risk, suggest a redline. Skip boilerplate." --message "$(cat agreement.txt)"

Without "skip boilerplate," the model dutifully reviews every standard clause and buries the signal. With it, my 9-page freelance agreement came back as four flagged items — including an IP-assignment clause that kicked in before final payment. Each with exact quotes I could paste into my reply.

Boundary: this is triage. For real money, the checklist is what you bring to a lawyer.

AI-ness Check for a Thesis

Universities now run AI-content detection on submissions, and my cousin needed a self-check. Honest framing first: no tool guarantees passing any detector, and AI-detecting-AI has real false positives. What works is humbler — locate the most machine-flavored paragraphs and get sentence-level rewrite directions:

bl text chat --system "Analyze the input for AI-generation markers: mechanical parallel structures, stock transitions, vague claims with no concrete detail. Rate each paragraph High/Medium/Low and give specific humanization suggestions, down to the sentence." --message "$(cat chapter3.txt)"

Two paragraphs came back High — both were AI output she'd barely edited. She rewrote them herself using the suggestions.

2-Hour Lecture → Obsidian Notes

Different command, same philosophy. bl vision describe takes a local video file directly:

bl vision describe --video ./lecture.mp4 --prompt "This is a course lecture. Output Markdown study notes: chapters in teaching order, each with core arguments, key examples, and any formulas or code. End with a takeaway list. Use Obsidian-compatible syntax."

Minutes later: chaptered notes. I watched 25 minutes of the video instead of 120. Dedicated summarizer tools are more polished (timestamps, browser extensions) but subscription-based; at two videos a month, pay-per-call wins and the note format is whatever my prompt says.

The Bill

bl usage stats --days 7 at the end of the week: everything above, under $0.50, mostly inside the free tier. bl usage free shows remaining free quota before you fire off a big batch — worth a glance.

When to Use This (and When Not)

Use it when the work is high-volume, repetitive, and needs structured output — reviews, tickets, surveys, contract triage, lecture backlogs. Skip it if you analyze one text a month (chat tab is fine) or need zero-error output (AI is the triage layer, not the signature).

If you've got a pile of unread text of your own, the free tier is enough to run everything in this post: sign up here, and the distance between "unread" and "read, with a checklist" is one for loop.

What's the biggest batch-text job you've been putting off? Tell me in the comments.

I Automated My Meeting Minutes, Contract Drafts, and Reports With a CLI — Here's the Whole Setup

张洲诚（Zack.ZHANG） — Tue, 04 Aug 2026 03:08:23 +0000

Every Monday I used to lose half a day to paperwork that isn't my actual job: minutes from client calls, yet another statement of work, compressing a six-page memo for my manager, and the delicate "we're going to be late" email.

Last week I moved all of it into my terminal. This is the full setup — every command included.

Why not just use a chat tab?

I did, for months. The problem isn't quality, it's repetition: paste the transcript, re-explain the format, copy the result, times ten files. And the meeting bots (Otter, Fireflies, Fathom — all genuinely good) only cover meetings inside their ecosystems. My phone recordings from on-site interviews? Nobody's job.

Two properties fix this, and both are terminal-native:

Prompts become files — my minutes template and contract clause list live in --system strings I wrote once
Files are first-class inputs — recordings, CSVs, parameter sheets go straight into commands; ten inputs is a for loop

Setup (2 minutes)

Node.js 18+, then:

npm install -g bailian-cli
bl auth login

The CLI is bl, Alibaba Cloud Model Studio's command-line tool. Grab a free API key here — the free tier covered my whole week. Docs on the Model Studio CLI page.

Recording → minutes, two commands

Transcribe (local path works, it uploads for you — --diarization separates speakers, and you want that for multi-person calls):

bl speech recognize --url workshop-0728.m4a --language en --diarization --speaker-count 4 --out transcript.json

Generate, with the format pinned:

bl text chat --system "You are a minutes assistant. From the transcript produce formal minutes: attendees, discussion summary by topic, decisions, and action items with owner and due date. Mark anything not present in the transcript as [TBC]. Never invent details." --message "$(cat transcript.json)"

Lesson #1: my first run skipped --diarization and the minutes attributed a decision to the wrong person.
Lesson #2: "Never invent details" is load-bearing. Without it, the model helpfully fabricated a deadline nobody said out loud. With it, I got an honest [TBC].

Ten contract drafts in one loop

Eighty percent of my SOW never changes. So: one parameter file per client in contracts/, then:

for f in contracts/*.txt; do bl text chat --max-tokens 8000 --system "You are a contract drafting assistant. From the given parameters draft a software development services agreement with these clauses in order: parties, scope of work, timeline and milestones, payment terms, acceptance criteria, intellectual property, confidentiality, maintenance, liability, dispute resolution. Formal register. Output Markdown." --message "$(cat $f)" > "draft-$(basename $f .txt).md"; done

Lesson #3: the default 4096-token output cap truncated a long draft mid-liability-clause. --max-tokens 8000 fixed it.

Obligatory honesty: these are drafts for legal review, not signable contracts. My lawyer adjusted wording in three clauses and shipped it. Reviewing beats writing from scratch — that's the entire win, and it's enough.

The rest of the pile

Same pattern everywhere — format in --system, content in --message:

bl text chat --model qwen-turbo --message "Summarize this memo in under 200 words. You must preserve all deadlines and responsible departments: $(cat compliance-memo.txt)"

bl text chat --system "You are a retail data analyst. Structure: overview, monthly trends, anomalies, actionable recommendations. Every claim must cite specific figures from the data. No unsupported statements." --message "12 months of sales data follows: $(cat sales-2025.csv)"

bl text chat --message "Rewrite this email to be professional, courteous and concise while keeping the meaning. Explain each change and why: $(cat draft-email.txt)"

Lesson #4: summaries go to qwen-turbo (the cheap tier — fractions of a cent, totally sufficient); contracts and reports stay on the default model. Budget model for volume, better model for precision.

Lesson #5: "every claim must cite specific figures" turned the report from fluent filler into an actual analysis — it even flagged the March return-rate spike unprompted.

The week's ledger

Task	Before	After
Minutes from a 90-min recording	~1.5 h	~20 min (mostly transcription wait)
Ten contract drafts	Half a day	Minutes + legal review
Summaries / formulas / emails	10–30 min each	1–2 min each

Spend check (one-time bl auth login --console needed):

bl usage free --sort remaining
bl usage stats --days 30

~40 text calls, mostly inside the free tier. Coffee money at list rates.

Honest scorecard

Great for: recurring paperwork — SOWs, minutes, monthly reports. The prompt files compound; they're assets, not chats.
Skip it if: you draft two contracts a year and live entirely inside Zoom's ecosystem. The built-in bots are your shorter path.
Never its job: legal judgment, final responsibility for numbers. It converts "write from scratch" into "review and edit" — accountability stays human.

Free tier is here if you want to try. Start with whichever task annoys you most — mine was Monday's minutes.

What's the paperwork task you'd automate first? Curious what other people's worst offenders are. 👇

I Moved My Launch Copy Workflow into the Terminal (One Brief, One Loop, Every Platform)

张洲诚（Zack.ZHANG） — Fri, 31 Jul 2026 05:50:24 +0000

I shipped a side project last month, and the code was honestly the easy part. What ate my week was the launch copy: a Product Hunt tagline, an X thread, a LinkedIn post, a Reddit post that wouldn't read like an ad, plus a stack of SEO articles. Same product — five completely different voices.

Here's the workflow I ended up with: every platform voice is a .txt file, the product brief is another file, and one loop command generates the whole matrix in ~30 seconds. Honest breakdown below, including where it falls short.

The problem with the chat-tab workflow

My first approach was the obvious one: a chat tab, one piece at a time. It broke down in three ways:

Voice drift — thread #5 didn't sound like thread #1, because I phrased my request slightly differently each time
Evaporating prompts — the "Reddit voice" I tuned last week was gone with the session
Copy-paste tax — at volume, the mechanical work became the actual job

The root cause isn't the model. It's that a chat session is volatile storage, and platform voice is something you want persisted.

Voices as files, generation as a loop

The tool is bl, the CLI for Alibaba Cloud Model Studio:

npm install -g bailian-cli
bl auth login

(Node 18+. You'll need an API key — free to grab here, and the free tier covers everything in this post.)

The structure:

launch-copy/
├── brief.md            # product brief: value props, audience, pricing
├── voices/
│   ├── ph.txt          # Product Hunt: tagline + maker comment, banned hype words
│   ├── x-thread.txt    # X: 6-tweet thread, hook first
│   ├── linkedin.txt    # story-driven, no emoji walls
│   ├── reddit.txt      # plain text, zero marketing speak
│   └── seo.txt         # 800-word keyword article
└── out/

And the loop:

for f in voices/*.txt; do bl text chat --system "$(cat "$f")" --message "$(cat brief.md)" > "out/$(basename "$f" .txt).md"; done

--system carries the voice, --message carries the brief. Both read from files, output lands in out/. That's the entire architecture.

Three lessons from a month of real use

1. Lock the output format inside the voice file. My first Product Hunt draft came back with "revolutionary" in it. I added banned words: revolutionary, game-changing, disrupt to ph.txt — clean ever since. Fix it once in the file, and it stays fixed. That's the fundamental win over chat.

2. Temperature is a per-genre dial. Taglines at default settings were dead ("Learn smarter"). At --temperature 1.2 I got shortlist-worthy lines; at 1.8 it drifted off-product. Press releases went the other way: --temperature 0.3 gave me identical structure across three runs. You can't touch this dial in most chat UIs.

3. Split models by stakes. SEO volume work runs on the budget tier (--model qwen-turbo --max-tokens 1500) — a fraction of a cent per 800-word article. Front-facing copy (taglines, the launch thread) stays on the default flagship model. One flag, an order of magnitude in cost.

Bonus: covers without leaving the terminal —

bl image generate --prompt "Cozy desk scene, warm lamp light, open notebook next to a phone showing a study app, flat illustration, warm colors" --model qwen-image-2.0-pro --size 3:4 --n 2 --out-dir ./covers/ --watermark false

The numbers

Full launch run: ~60 text calls + 4 images.

bl usage free
bl usage stats --days 30

Most of it fit in the free tier. Priced at list rates, the entire token bill wouldn't buy a coffee — versus $39-49/month per seat for the usual copy SaaS. And retries become psychologically free: tweaking one word in a voice file and re-running costs fractions of a cent.

What it doesn't do

Honesty section. The output is draft tier, not publish tier — fact-checking and de-AI-flavoring stay human (my routine: batch in the terminal, polish the keepers in a chat window or by hand). If you write two pieces a week, a chat tab is genuinely more comfortable. And picking the winning tagline out of ten candidates is still your job.

Try it

Start small: install the CLI (docs), and save your single best-tuned platform voice as your first .txt file. The moment that file exists, your copy workflow starts compounding.

What does your launch-copy workflow look like — chat tabs, workflow platforms, or something scripted? Would love to compare notes in the comments.

Your best AI agent lives in a console you don't own. I moved mine into Git.

张洲诚（Zack.ZHANG） — Fri, 31 Jul 2026 02:22:05 +0000

Quick show and tell. Last month I realized something uncomfortable about my most-used AI agent: I couldn't take it anywhere.

It's a research agent I'd tuned for weeks — a dozen prompt iterations, two skills, an MCP data source, knowledge files, hand-picked tool permissions. All of that lives as scattered console pages on one cloud platform, under one account. If I switch accounts or platforms, I walk away with screenshots.

We'd never accept this for code (Git), dependencies (lockfiles), or infra (Terraform). So why accept it for agents?

What I tried

OpenAgentPack — open source (Apache-2.0, beta). One agents.yaml declares the whole agent stack; a Terraform-style workflow pushes it to the cloud.

npm install -g @openagentpack/cli   # Node.js 22+

mkdir my-agents && cd my-agents
agents init          # wizard writes a starter agents.yaml
agents validate      # offline check, zero API calls
agents plan          # preview create / update / delete
agents apply -y      # execute in dependency order

Here's a full run:

The declaration covers model, instructions, tools, skills, MCP servers, environments, and credential references — secrets stay in .env as ${VAR_NAME}, never in the file. So the YAML commits cleanly to Git.

agents:
  assistant:
    description: "General-purpose coding assistant"
    model: qwen3.7-max
    instructions: |
      You are a coding assistant.
    environment: dev
    tools:
      builtin: [bash, read, glob, grep]

Three things that sold me

1. plan is a real three-way diff. It reconciles your declared config, a local state file (remote IDs + content hashes), and what actually exists remotely. Change one field → one update in the plan. Someone hand-edits the console → flagged as drift.

2. My first mistake got caught offline. validate stopped an indentation slip before a single API call went out. Fail-fast where it's cheap.

3. Acceptance testing is built in. agents playground spins up a local WebUI and runs real sessions from the same declaration. I re-ran my standard research task after migrating and compared outputs against the old setup. Same structure, same rigor. You can also flip --provider (bailian / qoder / ark / claude) and benchmark the same scenario across backends.

Honest caveats

It's beta — the schema may change before 1.0. I've only moved test agents so far.
Provider parity is explicitly not promised: every capability is labeled native / emulated / unsupported per provider. Read that matrix before you migrate anything real.
State is a local file today; team-level state sharing is on you (early-Terraform vibes).

Why I think this matters

"Agents as code" feels like where "infrastructure as code" was a decade ago: obvious in hindsight, awkward to live without once you've tried it. Your prompts, workflows, and judgment deserve a form you actually own.

Repo: github.com/modelstudioai/OpenAgentPack

Trying the Bailian provider? You'll need a DASHSCOPE_API_KEY — free to create on Alibaba Cloud Model Studio.

Curious if anyone else is versioning their agents — what's your setup?

Stop Browsing LLM Provider Docs — Install Them Into Your Agent Instead

张洲诚（Zack.ZHANG） — Wed, 29 Jul 2026 09:59:57 +0000

I run a few side projects on LLM APIs, and the most annoying part of my week isn't debugging — it's looking things up. Pricing tiers split across input/output/thinking tokens. Rate limits buried three levels deep. Sample code that never matches the exact model I'm using. Four different portals (docs, console, model catalog, API reference) with four different layouts.

And none of that navigation muscle memory transfers between providers. Every platform organizes things differently, and they all ship new models and price changes every few weeks.

Here's the setup that made me stop browsing entirely.

The pattern: local docs, agent reads them

If you've used Context7, you know the idea — inject current docs into your AI assistant's context instead of letting it hallucinate from stale training data. That solves the open-source library side. But pricing, rate limits, and parameter schemas for a model platform don't live in any repo an MCP can pull.

Alibaba Cloud's Model Studio team shipped an Agent Skill applying the same idea to their platform: bailian-docs-llm-wiki. One install, and the platform's full documentation plus a structured snapshot of the model catalog become local files your agent reads directly.

Three layers:

Layer	What it is	Used for
`models/`	Structured catalog data, pulled from the console gateway API	Pricing, rate limits, context windows, sample code
`wiki/`	Synthesized concept/comparison pages	Concepts, architecture choices
`raw/`	Original official docs	API details, error codes

The models/ layer is the differentiator: it's not scraped HTML — it's the same data endpoint that powers the catalog UI. QPM limits, tiered prices, parameter definitions, and official sample code are all structured fields.

Setup

npx skills add modelstudioai/skills

Node.js ≥ 18. Pick bailian-docs-llm-wiki at the prompt — zero config after that; questions touching the platform's docs, models, or pricing activate it automatically. Works in Claude Code, Qwen Code, Cursor — anything that supports Agent Skills. Queries read local files, so they cost nothing and need no API key. You'll want a key once you actually run models (free tier for new accounts): get an API key.

What it replaces, chore by chore

Pricing and rate limits. Ask "What does qwen3-max cost for input and output? What's the rate limit?" — tiered prices, QPM, and context window come back together, with the source file path cited. I checked the file the first time. Numbers matched.

Cross-family model filtering. "Which models support function calling with 128K+ context?" — the catalog UI can't filter like that; the skill greps models.jsonl, one model per line, exact field matching. The inverse question is the one I actually ask most — most of us route easy jobs to cheap models and save expensive ones for hard problems: "which budget model is good enough for this batch classification job?" Price is just another field to filter on. Terminal users can skip the agent entirely (examples from the skill's own docs):

jq -c 'select(.contextWindow>=1000000)' models.jsonl
grep '"function-calling"' models.jsonl | jq -c '{model,family,contextWindow}'

Sample code and parameters, in-editor. The samples field carries official examples in curl/Python/Node.js/Java; predictConfig carries parameter names, defaults, and ranges aligned with the platform playground. Ask in your coding agent, paste, adjust — and have the agent run the sample right there to verify before wiring it into your project. The whole loop stays inside the editor.

Error codes and concepts. Error codes get grepped from the raw official docs locally — no more fighting a docs site's search box. Concept questions ("RAG options on this platform?") hit pre-synthesized comparison pages.

Catching up on updates. When I hear a new model dropped, I re-run the install command to refresh the snapshot, then ask "what's new in the model list?" Note the boundary: it's a snapshot you refresh, not a push subscription. For me that's the right trade.

Why it doesn't make things up

Three constraints baked into the skill's rules:

Answers must come from actual local files — no filling gaps from model memory for APIs, params, error codes, or prices.
Every answer cites a file path you can open and verify.
Conflict precedence: models/ (gateway data) > raw/ (official docs) > wiki/ (synthesized). Low-quality synthesized pages get bypassed automatically.

Not zero hallucination risk — but "verifiable by opening a file" beats "I think I found the right page."

Honest scope

Built for people working with Alibaba Cloud Model Studio or evaluating Qwen models. If your stack lives entirely on other providers, the skill deliberately refuses out-of-scope questions rather than improvising — correct behavior, but it won't help you there. Free tier if you want to poke at it: sign up.

What's your approach to keeping provider docs in your agent's context — Context7, llms.txt, something homegrown? Would love to compare notes.

I Ran My Whole Audio Workflow From the Terminal for a Week

张洲诚（Zack.ZHANG） — Mon, 27 Jul 2026 07:53:02 +0000

My audio workflow used to look like this: draft a script in ChatGPT, paste it into a TTS website, download the MP3, upload a meeting recording to a transcription tool, copy the transcript into a translator, download again. Five tabs, three accounts, the same file uploaded three times.

Gemini Notebook (the renamed NotebookLM, now 50+ languages) removes all of that — but it also removes the knobs. You can't pick the voice, can't shape the tone, can't chain the output into the next step. ElevenLabs synthesizes beautifully, Otter.ai transcribes live meetings, Descript edits podcasts — each excellent, each a silo.

So I spent a week doing the same tasks through one CLI instead. Here's what I ran and what came back.

modelstudioai / cli

Official Model Studio CLI（阿里云百炼 CLI）built for AI Agent frameworks, exposing models, search, multimodal, and workflow capabilities as structured tool calls.

The official command-line interface for Aliyun Model Studio (DashScope) AI Platform

Aliyun Model Studio CLI Site · 中文文档 · API Documentation · Get API Key

Chat with Qwen, generate images & videos, understand images, call agents, manage memory, search the web — all from your terminal.

Built for AI Agents. Every command works as a structured tool call.

Features

Equip your AI Agent out-of-the-box with these capabilities, composable across complex tasks:

Text chat — Qwen3.7-max: major gains in agentic coding, frontend coding, and vibe coding
Multimodal (Omni) — Full omni-modal support across text + image + audio + video
Image generation & editing — Qwen-Image 2.0: pro text rendering, photorealism, strong semantic adherence, multi-image composition
Video generation & editing — happyhorse-1.1 series: text-/image-/reference-to-video and natural-language video editing (up to 9-image reference)
Speech synthesis & recognition — CosyVoice streaming TTS, voice cloning from 5–20s samples; FunAudio-ASR covers 30 languages including 7…

View on GitHub

Setup (2 minutes, actually)

Bailian CLI is Alibaba Cloud's Model Studio CLI. Its bl speech subcommand covers TTS (CosyVoice model), ASR (Paraformer model), and speech translation.

npm install -g bailian-cli
bl auth login

Grab a free API key from the console — the free tier covered everything below. Verify with bl --version.

Day 1: Can It Do Comedy?

I started with the hardest TTS test I could think of — delivery, not just pronunciation:

bl speech tts --text "Let me tell you about the daily life of a programmer. Stand-up meetings, Jira tickets, and the eternal question: who broke the build this time?" --voice humorous --format mp3

First I ran it with a neutral voice, and the punchline landed like a weather report. With --voice humorous, the output had an actual beat before "who broke the build this time?" and a tonal lift on the question. I also noticed the em dash in my text produced a longer pause than a comma — punctuation is a timing control, which I did not expect.

Not open-mic-ready. Completely fine for a podcast cold open.

Day 2: Audiobook Voice, Ad Voice, Kid Voice

Same command, different --voice, wildly different output.

Gentle, for prose:

bl speech tts --text "It was an autumn evening. The setting sun painted the sky in shades of amber." --voice gentle --format mp3

Slow, warm, measured. One gotcha: I first fed it a long run-on sentence and the voice rushed through without breathing. Splitting into shorter sentences brought the pauses back. Speechify and Audible's AI narration do this well in a web UI; the CLI version becomes interesting when you loop it over 50 chapter files.

Energetic, for ad copy:

bl speech tts --text "Black Friday Mega Sale! Everything 50% off — limited time only!" --voice energetic --format mp3

"50% off" came out as a natural "fifty percent off," not digit-by-digit. My first draft had no exclamation marks and sounded flat even in this style — write the copy the way you want it shouted. Brand-critical campaign? Book a studio. A/B-testing ten versions of promo copy? This is a for-loop.

Childlike, for a story:

bl speech tts --text "Once upon a time, in a big forest, there lived a little rabbit. Every morning, it would look up at the sun and say: Good morning, Mr. Sun!" --voice childlike --format mp3

I tried gentle first — came out as a bedtime narrator, not a character. childlike brightened it into a proper storybook rabbit. Won't fool anyone into hearing a real kid, but for a prototype where each character is just a different flag in a script, it works. Production audiobooks still want the actor.

Day 3: Podcast Intro and a Quote Clip

bl speech tts --text "Hey everyone, welcome to Tech Discovery. I'm your host, and today we're diving into how AI is changing everyday life." --voice podcast-host --format mp3

Greeting energy up front, conversational settle by sentence two. Keeping the script under ~40 words kept the pacing tight; my longer clause-heavy draft dragged in the middle. This is the Gemini Notebook scenario with the opposite trade: it gives you a polished episode with zero decisions, this gives you building blocks with all the decisions.

Quote clip for social:

bl speech tts --text "The real innovation isn't in the model — it's in how we orchestrate it." --voice authoritative --format mp3

Works under ~20 words. I tried a 40-word excerpt and the gravitas turned into a lecture. The voice amplifies a strong line; it can't rescue a weak one.

Day 4: The Meeting Recording

An hour-long call, four people, and somebody has to write the minutes.

bl speech asr --input meeting.mp3 --speaker-diarization --output transcript.md

What came back, structurally:

[Speaker 1] Priority this week is closing out the export feature; staging updates this afternoon.
[Speaker 2] I'll take the docs — first draft by Thursday.

Two things I had to learn the hard way. Without --speaker-diarization, the transcript is one undifferentiated wall of text — the flag gets you Speaker 1 / Speaker 2 labels, and suddenly who-owns-what reads right off the file. And the punctuation restoration surprised me: the ums and filler got broken into readable sentences, so the output is markdown you can actually read. The minutes themselves are step two — I hand transcript.md to a chat model and ask for the summary, decisions, and action items with owners; since the input is already clean and speaker-labeled, that's a one-liner in the same script. Crosstalk segments come back rough, so I skim important minutes against the recording. Otter.ai still owns the live-during-the-meeting case — this only processes recordings after the fact. But the output is a file, and files pipe.

Day 5: Chapters for Show Notes

bl speech asr --input lecture.mp3 --output chapters.md

What came back is a timestamped chapter structure — ## 00:21:45 From tools to workflows — accurate to the sentence, so finding a topic no longer means scrubbing the progress bar. Two manual touches before shipping: the occasional boundary lands mid-thought where two topics blend, so I nudged a couple of cut points, and the auto titles read like plain summaries — I rewrote them with hooks for the show notes. Clean topic transitions produce clean boundaries; a meandering speaker produces a draft you'll adjust. Still beats scrubbing an hour of audio by hand.

Day 6: Translation, and My One Real Mistake

Chinese voice memo → English audio for a collaborator:

bl speech translate --input voice-memo.wav --source zh --target en --output translated.mp3

Two artifacts out: translated text + synthesized English audio. Names, dates, requests all survived. Idioms went literal — anything legal or public-facing still needs a human pass.

The mistake came with a bilingual interview. I ran:

bl speech translate --input interview.mp3 --source zh --target en --output transcript_en.md

The English segments came back mangled — I'd forced everything through one language assumption. The fix:

bl speech translate --input interview.mp3 --source auto --target en --output transcript_en.md

--source auto detects the language per segment, and the transcript cleaned right up. Mid-sentence language switches still come out with rough edges.

Day 7: Chaining It

Every bl call is an independent process — no session, no memory, you re-specify the voice each time. Annoying interactively; exactly right in a script, because nothing hidden influences the output:

bl speech translate --input meeting.mp3 --source auto --target en --output transcript_en.md
bl speech asr --input meeting.mp3 --speaker-diarization --output transcript.md
# distill transcript.md into summary.txt (chat-model pass or manual pick), then:
bl speech tts --text "$(cat summary.txt)" --voice podcast-host --format mp3

Recording in, narrated English brief out. Each stage debuggable in isolation. That week of experiments cost about a dollar total — per Bailian's official pricing (July 2026), TTS runs ~¥0.034 (≈ half a US cent) per minute of audio, ASR ~¥3.5 (≈ $0.50) per hour, speech translation ~¥0.5 (≈ $0.07) per minute.

Would I Keep Using It?

For the weekly grind — batch voiceovers, recorded meetings, bilingual interviews — yes; the file-shuttling between tabs is gone and the whole flow lives in a script I can rerun. For live meeting transcription I'd still open Otter.ai, for voice cloning or exact tonal work it's ElevenLabs or an actor, and if you touch audio once a month, a web tool with a preview button is simply less friction than a terminal.

Start here: install the CLI, get an API key, run one bl speech tts. The console shows what else the platform does.

What about you? Have you tried chaining audio tasks — TTS, transcription, translation — in a single scripted workflow? Team dedicated-tool or team pipeline? Drop your setup below.

All scenarios are based on real prompts. Command syntax reflects the current CLI version — check the official docs for updates.

10 AI Glasses Scenarios I Tested With Just a Terminal

张洲诚（Zack.ZHANG） — Mon, 27 Jul 2026 07:50:00 +0000

WAIC 2026 wrapped up in Shanghai last week. Every booth had hardware — AI glasses, brain-wave sleep devices, conversational labs. Specs everywhere: weight, brightness, battery.

But nobody answered the question I actually came with: what can these glasses do for me, today?

I went looking and found something interesting. The application layer that "agent glasses" promise — it's already buildable. Not next year, not after a firmware update. Right now, with a CLI tool and a phone camera standing in for the hardware.

The setup

# Install the Bailian CLI (requires Node.js >= 18)
npm install -g bailian-cli

# Authenticate
bl auth login

Grab a free API key from the Model Studio console — the free tier covers everything below. Setup takes about five minutes.

Two commands do all the heavy lifting:

Command	What it does	When to use
`bl vision`	Upload an image + a question, get a visual analysis	Food, contracts, plants, gym equipment
`bl chat`	Send text (optionally with a file or persona), get a response	Planning, analysis, recommendations, chat

Health: Eat, train, track

1. Food calorie recognition

Point your camera at a plate:

bl vision --image lunch.jpg --prompt "Identify the food, estimate calories and key macronutrients (protein, carbs, fat)"

I shot a plate of shredded pork with fish sauce over rice. Got ~650 kcal, protein/carb/fat ratios. Not lab-precise — but good enough to log a meal without manually searching a food database.

2. AI fitness coach

bl vision --image treadmill.jpg --prompt "Identify this equipment and generate a fat-loss plan: 3 sessions/week, 500 kcal per session"

Recognized the treadmill, produced a structured weekly plan — exercise type, duration, intensity, target heart-rate zone. Beats wandering between machines at the gym.

3. Body metrics analysis

bl chat --file health-7days.json --prompt "Analyze 7-day health data trends (heart rate, steps, sleep, blood oxygen, stress). Flag anomalies and suggest improvements."

Uploaded a week of smartwatch data. It caught a deep-sleep dip on days 3 and 5, correlated it with elevated stress scores, suggested an earlier wind-down. Whether that's medically actionable is a different question — but as a pattern-spotting tool, genuinely useful.

4. Smart diet manager

bl vision --image dinner-plate.jpg --prompt "Identify each dish, calculate total calories and macro ratios"
bl chat --message "Based on a fat-loss goal, suggest dietary adjustments for this meal"

Vision identifies the food, chat adjusts the plan. Turns "I should eat better" into a concrete, per-meal instruction.

Family: The third eye at home

5. Parenting assistant

bl vision --image baby-blocks.jpg --prompt "Describe the child's activity and assess developmental stage"
bl chat --message "Log today's feeding, nap, and play observations. Generate a weekly growth summary."

Photographed my one-year-old stacking blocks. The model identified it as fine motor skill development and logged the milestone. Not a pediatrician — but as a memory aid for sleep-deprived parents, it beats scribbling in a notebook.

6. Gift selection assistant

bl vision --image kids-room.jpg --prompt "Analyze this scene for gift-giving clues: interests, ages, existing items"
bl chat --message "Based on the scene analysis, recommend 3 gift options with reasoning and price range"

Shot my kid's room. It spotted a half-finished Lego castle and a nearly empty skincare bottle. Inferred: a Lego expansion set for the kid, skincare restock for my wife, a family board game as a wildcard. More thoughtful than my default ("just get a gift card").

Business: Scan, assess, decide

7. Contract risk scanner

bl vision --image lease-contract.jpg --prompt "OCR this contract page and extract the full text"
bl chat --message "Review this contract clause by clause. Flag any risky terms (excessive penalties, unusual terms, hidden fees). Assign risk levels and suggest mitigations."

Scanned a residential lease. It flagged a termination penalty clause as "high risk" (two months' rent — above local norms). My lawyer later confirmed it was worth negotiating.

8. Hotel search & booking

bl chat --message "Trip: May 20-22, 2 nights, near Shanghai Bund, budget hotel, total budget 1000 RMB. Find and recommend suitable hotels."

Three options with price, location, rating, amenities — plus a comparison table and a booking recommendation. No camera needed. What I'd normally spend 20 minutes on across three booking sites.

Companion: From tool to partner

9. Visual Q&A

bl vision --image plant.jpg --prompt "What plant is this? What's its name (scientific and common)? How do I care for it?"

Held up a succulent I'd been slowly killing for months. It identified it as an Echeveria, told me I was overwatering, and gave a care card: bright indirect light, water when soil is fully dry, every 2-3 weeks. The plant is now thriving.

10. Companion robot

bl chat --persona "You are XiaoZhi, a warm and cheerful companion robot. You pick up on emotional cues and proactively suggest activities or games." --message "I'm so happy today! Let's hang out!"

A chatbot with a persona. Not groundbreaking on its own — but in the context of agent glasses with a visual feed and calendar, the potential is a persistent, context-aware companion that knows what you're looking at and what you're doing.

What actually changed

Task	Before	After
Log a meal's calories	Search food database, estimate portions	Snap a photo, get instant estimate
Start a gym routine	Google, cobble together a plan	Photograph equipment, state goal, get a structured plan
Review a contract	Read every line, miss the buried clause	Scan the page, get flagged risks with levels
Pick a gift	Wander a store, guess	Photograph the room, get targeted recommendations
Identify a plant	Reverse image search, then find a care guide	One command: name + care instructions
Book a hotel within budget	Open 3 tabs, filter, compare	State constraints, get a comparison table

The pattern: input gets simpler (a photo or a sentence), output gets more structured (tables, plans, ranked recommendations). The AI doesn't make the decision for you — it does the tedious processing so you can decide faster.

Who is this for?

Early adopters who bought AI glasses and are underwhelmed. The hardware is here; the application layer is what's missing.
Developers building for the agent glasses ecosystem. Qwen opened the door to third-party Skills. The CLI is the fastest way to prototype what a Skill could do.
Anyone who doesn't have glasses yet but wants a preview. Every scenario runs with a phone camera and a terminal.
Anyone whose daily routine includes repetitive information tasks. If you do it manually every week, there's probably a bl command for it.

WAIC 2026 made one thing clear: the AI hardware race is on. But hardware without applications is just expensive plastic. The real question isn't "which glasses are lightest" — it's "what can the glasses do for me that my phone can't?"

These 10 use cases don't answer that fully. But they show the application layer is already buildable today. The glasses just make the input frictionless — the intelligence is already there, waiting to be invoked.

What use case would you build first? Have you tried any CLI-based AI tools in your daily routine? Drop a comment — I'm curious what people come up with.

I Generated 50 Sales Reports with One CLI Command — Here's How

张洲诚（Zack.ZHANG） — Mon, 20 Jul 2026 10:20:58 +0000

Mid-year review season. You know the drill.

My team owed leadership a polished Q2 deck, plus every regional sales lead needed their own weekly report. Total count: about 50 reports. Same structure, different data.

The first deck I did the honest way — PowerPoint, three full days. Not because I can't use templates, but because the "raw data → insight → visual story" pipeline is brutally long. Each chart means copying numbers from Excel, fixing formatting, writing analysis. One slide averages 40 minutes. Twenty slides = two working days gone.

Then I looked at the remaining 49. That math doesn't work.

The GUI tool problem

I tried the obvious solutions:

Gamma ($20/mo): Fast AI generation, but no batch mode — each deck requires manual input and manual export
Beautiful.ai ($12/mo): Great design, but can't read my raw Excel data
WPS AI (~$4/mo): Can read data, inconsistent quality, no batch

The common issue: GUI tools don't support scripting. One deck saves time. Fifty decks means doing it fifty times by hand.

The CLI approach

I found Bailian CLI on GitHub — a command-line tool that calls large models directly from the terminal, reads files as context, and can be looped in a script. Here's what my workflow ended up looking like.

Setup

pip install dashscope-cli
bl configure --api-key YOUR_API_KEY

Free API key from the Bailian console — new users get complimentary credits.

Step 1: Generate an outline

The worst part of building a deck isn't layout — it's "what goes on slide one."

bl chat --model qwen-plus \
  --prompt "Generate a PPT outline for Q2 sales performance review, covering:
1. Performance overview (revenue, profit, YoY/QoQ)
2. Regional comparison (East/South/North/Southwest)
3. Growth attribution (which product lines drove growth)
4. Risks and anomalies
5. Next quarter action plan
Include 2-3 key points and visualization suggestions per module."

30 seconds → structured outline with chart recommendations (stacked bars for revenue composition, heatmaps for growth distribution). Previously this took 30 minutes on a whiteboard.

Step 2: Data-driven content

The key differentiator — feeding in the actual data file:

bl chat --model qwen-max \
  --file sales_q2.xlsx \
  --prompt "Based on this Q2 sales data, generate executive-facing PPT content:
1. Extract 3 core conclusions (with data support)
2. Identify 2-3 anomalies or notable trends
3. Recommend next-quarter actions
4. Write out each slide's title and bullet points
Emphasize YoY growth trends and regional differences."

It reads the actual numbers, analyzes them, and outputs specific conclusions — not template filler. For example: "East China Q2 revenue grew 23% YoY, driven by enterprise SaaS, while North China saw -5% negative growth — renewal rate decline needs attention."

GUI tools can't do this. Gamma and Beautiful.ai only work with text you type in; they won't read your source files.

One complete executive deck: ~1 hour (including manual tweaks and layout). Down from three days.

Step 3: Batch it

Same structure, different data per region. Textbook scripting scenario:

for region in east south north southwest central northeast northwest; do
  bl chat --model qwen-plus \
    --file "data/${region}_q2.xlsx" \
    --prompt "Based on ${region} region Q2 sales data, generate weekly report content:
1. Regional performance summary
2. Top 5 customer contribution analysis
3. YoY and QoQ changes
4. Items requiring HQ support
Output as structured PPT page content." \
    --output "output/${region}_weekly_report.md"
done

Seven regions, 8–10 minutes total. Structured Markdown output → batch import into deck template.

Approach	Time for 50 reports	Data accuracy	Repeatability
Fully manual	~25 hours (30 min each)	Copy-paste errors likely	Redo from scratch
GUI tools	~12 hours (15 min each)	Manual data entry	Semi-automated
CLI script	~10 min + 1 hr layout	Reads source data directly	Fully repeatable

Next quarter? Swap the data files, run the same script. Zero rewrite.

Beyond decks

The same pattern works for anything "given materials → structured document":

# Business plan
bl chat --model qwen-max \
  --prompt "Draft a business plan outline for an enterprise analytics SaaS..."

# Data analysis report
bl chat --model qwen-max \
  --file user_behavior_june.csv \
  --prompt "Write a product data report: DAU, retention, conversion, anomalies..."

# Excel formulas
bl chat --model qwen-plus \
  --prompt "Write an XLOOKUP formula that..."

Meeting minutes, contract drafts, quarterly summaries — same logic.

Cost

Tool	Monthly cost	Batch support	File input	Best for
Gamma	$20/mo	No	No	One-off polished decks
Beautiful.ai	$12/mo	No	No	Design-first
WPS AI	~$4/mo	Limited	Partial	WPS ecosystem
Bailian CLI	Pay-per-token	Native scripting	Yes	Batch + data-driven

Using qwen-plus: one deck ~$0.05–0.07, 50 regional reports ~$2–4, daily misc ~$1–2/month.

Honest limits

CLI has a learning curve — not as plug-and-play as GUI tools
Output is content structure; final .pptx layout still needs human work
Quality depends on prompt quality
Complex visualizations still need manual handling
If you only make one deck occasionally and care about design polish, Gamma/Beautiful.ai are better

The CLI's edge: batch processing + data-driven generation + programmability.

If mid-year reporting season is crushing you too, consider a scripting approach. Core idea: hand the repetitive content generation to the machine, keep the aesthetic judgment and business decisions for yourself.