A Four-Unit Study Plan for Applied AI in Traditional Chinese

Most people studying applied AI do not stall because the material is missing. They stall because nothing they build is allowed to fail. This plan attaches one artifact and one pass/fail test to each of four units, so “I finished the unit” becomes a claim you can check.

How to structure the four units

The rule is identical for every unit: read it, build one artifact, run one test. Do not start the next unit until the test passes on data you chose, not on the sample data that shipped with the lesson.

Because you are studying in Traditional Chinese, add one cheap artifact that runs across all four units: a glossary file. Chinese-language AI material has real terminology drift. Prompt appears as 提示詞 and 提示語; fine-tuning as 微調 and 調適; agent as 代理, 智能體 and 代理人 depending on the author. Keep glossary.md with three columns: the term you will use, the English original, and one sentence of your own definition. When two sources disagree, you decide and record the decision. That is what turns the language choice into an advantage instead of a source of confusion.

Unit 1 and 2: build a prompt-and-validate loop

Unit 1 is the API surface, not chatting with a model. You should leave it knowing what a system message does, how tokens are counted, and what streaming changes about how you read output. Unit 2 is how you assemble the context window, which is a different skill from writing a polite question.

Start with a raw call you can inspect. Keep the model name in an environment variable so you can swap endpoints without editing files.

mkdir -p study/unit1 && cd study/unit1
export OPENAI_API_KEY=...          # or any OpenAI-compatible endpoint
export BASE_URL=https://api.openai.com/v1
export MODEL=...                   # set your model here

curl -s "$BASE_URL/chat/completions" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "'"$MODEL"'",
    "temperature": 0,
    "messages": [
      {"role": "system", "content": "你是一位嚴謹的技術編輯。先給結論，再給理由。"},
      {"role": "user", "content": "用兩段話解釋檢索增強生成（RAG）。"}
    ]
  }' | jq '{usage, content: .choices[0].message.content}'

The usage field is the point of unit 1. Chinese text is not tokenized the same way as English, and the only reliable way to know your cost per request is to read the number your own endpoint returns. Do not estimate from character counts.

Unit 2’s artifact is a test set plus a validator, not a clever prompt. Write the cases before you write the prompt.

import json, os
from openai import OpenAI

client = OpenAI(base_url=os.environ["BASE_URL"], api_key=os.environ["OPENAI_API_KEY"])

CASES = [
    {"text": "系統將於今晚 23:00 進行維護，請提前儲存。", "expect": "normal"},
    {"text": "你的帳號已被停用，請立即聯繫客服。", "expect": "urgent"},
    {"text": "週年慶優惠，全館五折。", "expect": "ignore"},
]

def classify(text: str) -> dict:
    r = client.chat.completions.create(
        model=os.environ["MODEL"],
        temperature=0,
        response_format={"type": "json_object"},
        messages=[
            {"role": "system", "content": "把信件分類為 urgent、normal 或 ignore，並用一句話說明理由。只輸出 JSON。"},
            {"role": "user", "content": text},
        ],
    )
    return json.loads(r.choices[0].message.content)

for c in CASES:
    out = classify(c["text"])
    print(c["expect"], out["label"], c["text"][:12])

Pull the cases from your own inbox, support queue or meeting notes. Ten real cases beat fifty invented ones. If you write the test set after seeing the model’s output, you are grading your own homework. Context engineering — deciding what belongs in the window at all — is the part most self-learners skip; there is a longer treatment of it at /blog/what-is-context-engineering/.

Unit 3 and 4: retrieval, tools, and shipping

Unit 3 resolves most complaints that start with “the model ignored my document.” The fix is usually chunking and retrieval, not a firmer instruction. A minimal config you can version and diff:

# unit3/rag.yaml
source_dir: ./docs          # your own files, mixed zh-Hant and en
chunk:
  size_tokens: 350
  overlap_tokens: 60
  split_on: ["\n\n", "。", "！", "？"]   # keep Chinese sentence boundaries
embed_model: your-embedding-model
top_k: 5
log:
  file: ./runs/unit3.jsonl
  fields: [query, retrieved_ids, scores, answer]

Test it with three queries: one purely in Traditional Chinese, one in English, one mixed in the same sentence. Compare which paragraphs come back. Do not assume your embedding model places zh-Hant and English text in the same neighborhood, and do not assume it treats zh-Hant and zh-Hans identically — measure it on your own corpus, because published claims about this vary by model version. Frequent failures: chunks split mid-sentence because you only split on blank lines; top_k so large that the correct paragraph gets buried; and a glossary term that appears in your query but never in the source documents.

Unit 4 is one scheduled automation, not a system. Fetch input, call the model with a schema, validate the response, write the result, notify on failure. Add a maximum token budget per run and an idempotency key so a retry after a timeout does not duplicate the output. Keep a manual fallback path, because a scheduled job you cannot run by hand is a job you cannot debug. If you would rather not hand-roll cron, retries and logging, the tradeoffs between hosted automation tools are covered at /blog/zapier-vs-n8n-vs-ai-workflow-builder/.

How to tell you actually learned a unit

Recognition is not learning. Four tests, in increasing order of honesty:

1. Explain it in Chinese without saying the English word. If you cannot define 溫度取樣 or 上下文視窗 in one sentence without borrowing the English term, your glossary entry is empty.
2. Cold rebuild. Open a new folder and rebuild the previous unit’s artifact without opening the lesson. Twenty minutes is a reasonable budget; the point is whether you reach for instructions or for your own notes.
3. Predict the failure, then cause it. Before running, say which error you expect from a 6000-token prompt, a malformed JSON response, or a tool that returns HTTP 500. Being right once means you understand the boundary; being surprised means you memorized a happy path.
4. Re-test later. After finishing unit 4, rerun unit 2’s test set without touching the code. If it fails, you learned the API calls, not the design.

A clear sign you have not learned a unit: your artifact only works on the lesson’s sample data, or you cannot say why a parameter is set to the value it is.

What to do next

1. Create the study repo today and commit glossary.md with five terms you have already seen translated two different ways.
2. Write ten classification or extraction cases from your own inbox or notes before writing any prompt, and run them as a script.
3. Build the retrieval config above over your own documents, log every query for a week, and read the log before changing anything.
4. Ship one scheduled automation with a token budget, an idempotency key, and a manual run path — then break it once on purpose.
5. If assembling this path yourself is slower than you want, the Traditional-Chinese AI Course is a four-unit, seventeen-lesson course in Traditional Chinese that takes a beginner from zero to applied AI workflows, priced at $69 USD one-time; treat it as the reading list for the plan above, not a replacement for the artifacts.

Get Traditional-Chinese AI Course

Traditional-Chinese AI Course — $69, one-time payment, instant download. See the full breakdown on the review page.

Related reading

• The Ultimate Guide to AI Automation 2026
• How I Built a 10-Product Digital Business
• Building an AI Content Factory