分類: 🔧 後端開發

  • 拔掉 RLS 的兩天:AI 時代規模化 Day One 為何從奢侈變預設

    重點摘要

    • 540 萬包裹壓測,警衛的社區包裹列表要 7330 毫秒。病根是 RLS 兩條 PERMISSIVE policy 用 OR 合併,讓查詢規劃器用不到 community_id 索引。
    • 全面拔除 173 條 policy、85 張表的 RLS,租戶隔離 100% 改由應用層帶 community_id。同一條查詢從 7330ms 降到 1.34ms,約 5500 倍。
    • 但拔掉 RLS 不是終點——第二波跨社區洩漏被「單租戶壓測」蓋住了:對照社區在多數表是 0 筆,洩漏判準(本社區數=全平台數)自動成立。要每張表都灌 ≥2 個社區才測得出;而且漏帶 community_id 不只洩漏,更是少了索引,同一個病根換地方又長。
    • AI 把規模準備的「建造成本」打掉了,但有兩個成本它打不掉:分區帶來的「複雜度稅」(維護照繳),與「取決於規模實測才知道對錯」的經驗決策(RLS 自己就是反例)。
    • 結論:AI 時代「規模化 Day One」從奢侈變預設,但「準備什麼」的判斷力更值錢——有把握的提前上,取決於壓測的,老實留給壓測。

    一個 V2 產品、兩天、一個 AI 協作者,把一套多租戶系統從「靠資料庫兜底」推進到「應用層自己負責」。這篇記錄的不是 commit log,是技術選型的隱性成本,怎麼在特定規模與特定哲學下才現形——以及 AI 怎麼悄悄改寫了「該不該提前準備規模化」這道老題目。

    先講結論:MVP 智慧是成本算出來的啟發法,不是定律

    傳統智慧說:MVP 先做,別過度工程,規模化以後再說。這句話我一直信,直到這兩天我意識到——它是一條成本驅動的啟發法,不是定律

    它成立的前提是「規模準備很貴」。以前要做分區、多租戶隔離、idempotency、離線佇列這整套規模機械,往往要多三到四倍的人力、好幾個月。那個成本,才讓「先別做、等需要再說」變成理性選擇。但兩件事同時改變了這個算式:

    1. AI 把建造成本打掉了。那套規模機械,AI 輔助下生成 + 維護的人力崩塌。
    2. 這是 V2,不是 try。前一版已經證明了領域——住戶、警衛、包裹是真需求,而且會有很多社區。規模不是猜測,是 near-certainty。「You Ain’t Gonna Need It」的前提「你可能不需要」,直接是假的。

    所以對一個 AI 輔助、領域已驗證的 V2,Day One 就準備規模化,比經典 MVP 智慧主張的更該做。但這篇真正有料的地方,是兩個 AI 也打不掉的成本。後面講。

    當初為什麼這樣選技術?

    這套系統的技術選型,是三股力量的合力:領域驅動 + 規模前瞻 + 不重蹈前版覆轍

    • Flutter 單一 codebase:住戶用手機、警衛用平板,功能大半重疊靠角色 gate。兩份原生 = 兩倍維護;一份 + responsive 是省力的對。加上離線優先是硬需求(警衛平板斷網也要能收件、拍照、印通知條)。代價老實說:CanvasKit 的 web 端很痛,e2e 自動化一路在跟它的無障礙語意樹搏鬥。
    • Go + GraphQL(型別契約):Go 單一 binary 好部署、並發強,對著「1000+ RPM / 1000 社區」的目標。GraphQL 用型別嚴謹的契約——這是對前版的反動:舊版用 category/method 字串路由 + PHP 的型別強制轉換怪招,踩過坑。型別世界 = runtime 少驚喜。
    • PostgreSQL + RLS(Row-Level Security):這個最值得講,因為我們親手拆了它

    RLS 的故事:為安全而選,為清亮而拆

    RLS 當初為什麼選?防禦縱深。理由聽起來無懈可擊:「把租戶隔離放在資料庫層,app 出 bug 也繞不過。」每個社區的資料用 policy 鎖死,誰都別想跨社區看到別人的包裹。

    然後規模化壓測來了。我們灌了 540 萬包裹、5.4 萬戶、202 個社區,模擬一個 V2 跑兩三年後的樣子。一量——警衛的社區包裹列表,7330 毫秒。七秒。

    病根不是索引沒建,是 RLS 的兩條 PERMISSIVE policy 用 OR 合併(是系統管理員) OR (社區=X)。community_id 只出現在 OR 的一邊,查詢規劃器就用不到 community_id 索引,只能 Seq Scan 掃完整張表的所有分區。這個病,設計時看不出來,要到 5.4M 才現形

    業主的反應很關鍵。他不要「在 DB 加更多限制」來繞,他要的是更乾淨:「我不要我的資料庫跟我的 AP 有這樣的依賴。本來就該做到零洩漏,怎麼會依賴 RLS?」

    於是我們全面拔除 RLS——173 條 policy、85 張表,全部 DROP。租戶隔離 100% 改由應用層:每一條碰租戶資料的查詢,自己帶上 community_id = current_setting('app.community_id')

    拆的過程,反過來證明「本來就該零洩漏」當時是假的

    審計時我抓到,授權中介層對「同社區範圍」的操作寫死了一行註解:「RLS 負責租戶隔離,這裡不另外檢查。」也就是說,有好幾個改別人資料的後端進入點(停用警衛、在別社區建戶、復活別社區的軟刪戶),它們的隔離正確性,本來就完全押在 RLS 上。RLS 一拔,這些就是跨社區提權漏洞。

    派去掃的 AI 子代理一開始判了 23 個缺口;我逐條人工驗證,收斂到 3 個真缺口——其餘有的早被別的守衛擋著、有的是子代理幻覺出根本不存在的函式。這也是個教訓:AI 的清單要逐條驗,不能盲信。

    拆完,效能呢?同一條查詢,帶上 community_id:

    查詢 RLS 開(OR 合併擋索引) RLS 拔除 + 應用層 community_id
    警衛社區包裹列表(5.4M 列) 7330 ms(Seq Scan 全分區) 1.34 ms(Index Scan)
    包裹改動歷程鑽取 0.2 ms

    從 7330ms 到 1.34ms,約 5500 倍。反諷的地方:當初選 RLS 是「為了安全」。它不但變成效能地雷,還讓 app 層偷懶——「反正 DB 會兜底」,於是 app 層的隔離就不嚴謹了。兜底機制養出了被兜底者的鬆懈。

    拔完 RLS 之後:洩漏沒結束,是換了個地方躲

    拔掉那天修了 3 個提權,我以為收工了。錯。RLS 一拔,等於把「DB 兜底」這層拿掉,所有原本偷懶的查詢全部裸奔——真正的第二波,要再跑一輪壓測才現形。

    一個包裹計數查詢,給某社區警衛回了 280 萬——那是整個平台的數字,不是他那個社區的。病根:這個 count 自己手寫 WHERE,繞過了會自動補 community_id 的中央 helper。同一類的還有一票:社區統計(*Stats)、各種計數(*Count)、住戶/包裹 picker、以及「先 load-by-id 再改」的 mutation——全是各自為政手寫查詢、漏帶租戶欄位的高風險地帶。

    但這篇最該記住的,是為什麼第一次壓測沒抓到。答案很反直覺:單租戶結構上測不出跨租戶洩漏。

    我第一次灌的 540 萬,只灌在 parcelshouseholds 兩張表,其他維度(使用者、訪客、公告、picklist)對照社區根本 0 筆。而洩漏的判準是「本社區查到的數字 == 全平台的數字」——當對照組是 0,這條恆等式自動成立,洩漏被 0 資料蓋得死死的。修法不只是補 WHERE,是補資料形狀:每一張要驗的表,都灌進 ≥2 個社區的資料,動態探針才有對照組去抓「你回給我的,有沒有混進別人的」。

    還有一層,業主一句話點破:漏帶 community_id 不只是洩漏,是效能。「為什麼還有功能沒戴上 ID,這不只會洩漏,重點是效能會變差,沒用到 index。」少了那個欄位,查詢就跟當初 RLS 的 OR 一樣用不到索引、掃全表。防洩漏和上索引,是同一個動作——community_id 既是隔離邊界,也是索引前綴。當初那個「OR 擋索引」的病根,拔了 RLS 之後,在每一條手寫查詢裡換個地方又長了出來。

    規模下另外兩個 Day One 就得拍的板

    同一輪還拍了兩個一旦上線就很難回頭的板,都是「規模 + 時間」逼出來的。

    • 快照 vs 正規化:歷史標籤不准 join。包裹上的物流公司、儲位、包裹類型、收件人姓名,全部存成當下的文字快照,不是外鍵。為什麼不正規化?因為這些是歷史事實。若做成外鍵去 join 現行字典,哪天某家物流公司改名或下架,過去的包裹紀錄會被回頭改寫——未來的公司出現在過去的資料上。原則一句話:身分用外鍵,歷史標籤用快照。這跟「證據鏈不可竄改」是同一個底層要求。
    • 控制面狀態用單例快取,不是每頁查 DB。社區可被系統管理員停用,每個請求都得確認「這社區還活著嗎」。最笨的做法是每頁打一次 DB——那又是另一種 RLS 式的過度防禦。做法是一個程序級單例快取(map + 鎖),10 分鐘 TTL,miss 才查 DB,停用/復活時主動逐出;隔離檢查收斂在一個 chokepoint(進交易時查一次),不撒在每條查詢。順手修了個誠實問題:社區停用後登入原本回「帳密錯誤」會誤導用戶,改成帳密對的人才告知「社區暫停服務中」——既不誤導本人,也不洩漏社區存在給攻擊者。

    兩個 AI 也打不掉的成本

    回到開頭的 thesis。AI 讓規模準備「便宜到值得 Day One 就做」——但有兩個成本它打不掉。

    成本 AI 打掉了什麼 AI 打不掉什麼
    複雜度稅 建造成本(生成分區/隔離/佇列) 維護稅:每次改動/debug 都要付。例:pg_total_relation_size 對分區母表回 0,最大的表都報 0,要展開分區層才量得到
    經驗決策 實作速度 壓測經驗:RLS 的「OR 擋索引」要 5.4M 才看得見,連 AI 都沒辦法 Day One 告訴你對的選擇

    成本一:AI 打掉「建造成本」,沒打掉「複雜度稅」。月分區讓程式更難推理。這兩天我們親自繳了這個稅:監測資料量時,pg_total_relation_size 對分區母表只算母表本身(回 0);還有 FK 要複合鍵、分區不繼承 RLS、清測試資料時被自己剛上的 append-only trigger 擋住……這個複雜度,是每一次未來改動、每一次 debug 都要付的稅,連 AI 也付。「AI 讓規模準備好建」是真的,「規模準備免費」是假的——稅照繳,只是從建造繳給了維護。

    成本二:有些規模決策是「經驗的」,Day One 就是準備不了——RLS 自己就是鐵證。RLS 本來就是 Day One 的規模準備(多租戶隔離),結果它是錯的 Day One 選擇。為什麼當初設計看不出來?因為「OR 擋索引」這個病要 5.4M 壓測才看得見。有些決策,正確答案取決於規模行為,而那行為你預測不了——那是壓出來的,不是設計出來的。而且如前面那一節的教訓:光有規模還不夠,要對的「資料形狀」——對照社區是 0 筆的那次壓測,把第二波洩漏整個蓋住了。經驗決策不只需要壓力,需要對的壓力

    AI 時代,「規模化 Day One」從奢侈變預設。但「準備什麼」的判斷力反而更值錢:有把握的結構提前上(便宜了);取決於規模實測的決策,老實留給壓測。

    有把握的(會有很多社區 → 按社區/時間分區;離線不可妥協 → 佇列),提前做。沒把握的(隔離機制、索引策略),別假裝設計階段就能拍板。這跟我之前寫過的 企業 AI 落地為什麼失敗 是同一個底層觀念:方法論不能照抄,要看你的前提條件還成不成立。

    方法:規格化、決策留證、以及「我自己打臉自己」的報告

    這兩天還做了第二件大事——把包裹做成可被法庭級檢驗的證據鏈。改動寫進不可竄改的 log(鑽一顆包裹的歷程,5.4M 下 0.2 毫秒)、簽名與照片在儲存層鎖死不可刪、系統管理員調查要「破窗」且每次都留審計。但比功能更值得分享的是方法

    • 規格先行。每個設計決定都先寫進規格、辯論清楚、鎖進文件,才動手。對話會被壓縮遺忘,規格不會。
    • 決策留證,不靠主觀評分。業主不信任 AI 加工過的「成本/風險」評分,他要看真實檔案、真實行數、schema 影響。所以需要他拍板的時刻,我生的是事實卡片,不是紅黃綠燈。
    • 三份報告的誠實檢驗。最後他要一份評分報告。但他要的不是一個數字——他要三份做比較:原始版、我「現在的預估」(鎖時間戳,不准事後改)、和「全部做完 + 全面測試後的真實量測」。核心是拿我的主觀預估去對真實量到的,差多少 = 我的評估可信度。

    結果:我預估綜合 7.5,真實約 7.8,誤差約 0.3 分;方向性預測(「dev 環境的測試污染會讓部分整合測試紅、但那不是回歸」「forensic 能力做完會升」「效能會守住」)全中。唯一校準:我對「系統穩定度」過度保守——實際零回歸。這種「逼 AI 先承諾預測、再用真實數據打臉」的設計,把「AI 的話可不可信」變成一個可量測的問題。

    人機協作:最好的部分不是分工,是辯論

    這兩天的分工大概是:業主出領域知識與方向決策,AI 出執行、驗證與反思。但最好的部分不是分工,是辯論。RLS 該不該拆、拆了 sysadmin 怎麼查日誌、照片資料夾要不要鏡射分區、孤兒清理會不會變成刪證據的後門——這些不是「下指令、執行」,是來回推。

    業主用領域常識把我拉回現實(「哪有警衛不分社區的,警衛 A 在四個社區工作就是四個警衛」),我用壓測數據和審計把假設證偽(「你說本來就零洩漏,但我們現有 code 就漏了 3 個」)。AI 不會累、能掃完每個呼叫點、能把 23 個候選逐條驗到剩 3 個真的;但判斷「準備什麼」「什麼時候該停下來問人」,還是要人。

    結語

    如果只能留一句:老的 RD 有老的包袱,所以才有「MVP、先別管規模」的智慧。但那個智慧是成本算出來的。當 AI 把建造成本打掉、當你做的是領域已驗證的 V2——規模化就是 Day One 的事。只是別忘了,AI 打不掉複雜度稅,也替不了你壓測;有把握的提前上,沒把握的,老實壓出來——而且要用對的資料形狀去壓,單租戶測不出跨租戶的洩漏。

    RLS 是我們「Day One 準備了錯的東西、規模化才發現」的活標本。它沒有讓這個決定變壞——它讓這個決定有了教材

    技術細節:Flutter + Go(gqlgen) + PostgreSQL 16;月分區、River 佇列、MinIO。壓測 540 萬包裹 / 202 社區 / RLS-off:熱查詢 1.34ms、改動 log 鑽歷程 0.2ms。

  • 讓 Claude Code 走企業自管:從直連 Azure Foundry 到 API Gateway

    重點摘要

    • Claude Code 官方原生支援把後端從 Anthropic 訂閱換成雲端供應商,本文走 Azure / Microsoft Foundry 這條,目標是把資料與計費留在公司合規邊界內。
    • 第一階段:用 CLAUDE_CODE_USE_FOUNDRY=1 直連 Foundry 部署的 Claude,含 settings.json、Entra ID 認證、原始 curl。
    • 第二階段:在前面架一個自家 DNS 的 API Gateway,Claude Code 改用 ANTHROPIC_BASE_URL 只打一個入口,Gateway 依 model 欄位路由到後端——這才是企業統一控管的正解。
    • 關鍵觀念:不是每個模型一個網址,而是一個入口、用 body 的 model 名分流。

    為什麼要弄:當 AI 訂閱開始「換軌」

    2026 年起,前沿模型供應商的計費邏輯正在改變:訂閱方案把「互動使用」和「自動化 / Agent 使用」拆成不同的計量池,企業帳號甚至無法直接購買訂閱、只能走 API。對個人開發者這是成本問題;但對企業,真正的痛點是另外兩個字:控管

    企業導入 AI 編碼工具時,資安與法遵部門會問的第一個問題永遠是:「我們的程式碼與機密,送去哪裡?誰能存取?怎麼稽核?成本怎麼歸戶?」 把 Claude Code 直接接公開 API,這些問題全部無解。解法是讓推論跑在公司自己的雲端租戶裡,資料留在合規邊界內,並在前面架一道統一閘道。本文就是這條路的逐步實戰,從最簡單的直連,進化到可上線的企業架構。延伸閱讀可參考我先前寫的 用 Claude Code Hooks 打造大腦反饋迴路

    全局:兩個階段

    整條路分兩階段。先讓 Claude Code 直連雲端供應商上的 Claude(證明機制),再把它收斂到自家閘道後面(正式控管)。

    階段一(直連):
      Claude Code  --->  https://<resource>.services.ai.azure.com/anthropic/v1/messages
    
    階段二(閘道):
      Claude Code  --->  https://ai-gw.yourcompany.com/v1/messages  --->  雲端供應商後端
                         (自家 DNS、統一入口、依 model 路由、注入真憑證)

    第一階段:Claude Code 直連雲端 Foundry

    1. 在 Foundry 部署 Claude 模型

    在 Foundry 入口建立資源並部署 base model。三個實務重點,踩過才知道:

    • 地區限定:Claude 模型目前只開放在特定區域(本文撰寫時為 East US 2 與 Sweden Central),選錯區一定部署失敗。
    • 務必接受服務條款:第一次在資源上部署 Claude,後台要建立一個對應的供應商組織(Anthropic Organization)。部署時跳出的 Terms of Service 一定要在「正確登入帳號」狀態下按接受,否則握手失敗。
    • bad-state 陷阱:一旦某次部署握手失敗進入 bad state,該資源就修不好、重部任何模型都會死。正解是建立全新資源,別在壞掉的資源上重試。

    2. 設定 Claude Code(settings.json)

    最乾淨的做法是把環境變數寫進 Claude Code 的 settings.jsonenv 區塊(跨平台、持久,Windows 與 Linux 通用)。檔案位置:Linux 是 ~/.claude/settings.json,Windows 是 %USERPROFILE%\.claude\settings.json

    {
      "language": "繁體中文",
      "theme": "dark",
      "env": {
        "CLAUDE_CODE_USE_FOUNDRY": "1",
        "ANTHROPIC_FOUNDRY_RESOURCE": "<your-resource-name>",
        "ANTHROPIC_FOUNDRY_API_KEY": "<your-foundry-key-or-omit-for-entra-id>",
        "ANTHROPIC_DEFAULT_SONNET_MODEL": "<your-sonnet-deployment-name>",
        "ANTHROPIC_DEFAULT_OPUS_MODEL":   "<your-opus-deployment-name>",
        "ANTHROPIC_DEFAULT_HAIKU_MODEL":  "<your-haiku-deployment-name>"
      }
    }

    各變數的意義:

    變數 作用
    CLAUDE_CODE_USE_FOUNDRY設為 1 啟用 Foundry 整合。沒設的話 Claude Code 會走預設的公開 Anthropic API。
    ANTHROPIC_FOUNDRY_RESOURCE你的資源名稱;Claude Code 會自動組成端點 https://<resource>.services.ai.azure.com/anthropic
    ANTHROPIC_DEFAULT_*_MODEL三個層級(Sonnet/Opus/Haiku)各自的「部署名稱」,不是 model id。注意部署名可能跟 model 名不同(例如同名重建時會自動加序號)。

    重要:ANTHROPIC_DEFAULT_*_MODEL 一定要填「實際部署名」。Claude Code 內部會依當下任務挑層級(主要寫 code 用 Sonnet/Opus,讀檔、摘要等雜活用 Haiku),把對應的部署名塞進請求送出。

    3. 認證:Entra ID(建議)或 API 金鑰

    兩種選擇。企業環境建議 Entra ID:不把金鑰寫進檔案,改用 Azure CLI 的身分,集中式身分管理、適合團隊與 CI/CD。只要在啟動 Claude Code 前登入即可:

    # 方案 A:Entra ID(不放金鑰進檔案,建議)
    az login
    az account show        # 確認登入到正確訂閱
    # 然後在 settings.json 拿掉 ANTHROPIC_FOUNDRY_API_KEY 那行即可
    
    # 方案 B:API 金鑰(快速測試用)
    # 直接把金鑰填進 settings.json 的 ANTHROPIC_FOUNDRY_API_KEY

    4. 驗證設定

    啟動 claude,在裡面打 /status,確認 API provider 顯示 Microsoft Foundry、resource 與 model 都正確。啟動橫幅若顯示類似 Sonnet 4.5 · API Usage Billing,代表它走的是 API 計量(雲端供應商),不是訂閱。最後送一句測試訊息,有正常回應就代表端到端打通。

    5. 直接打 Messages API:預設協議就能用

    很多人會問:不能直接用「預設的 Messages API」嗎?能,而且它就是。 Foundry 的端點本來就是標準的 Anthropic Messages API,只是換了網址與認證。跟原生 Anthropic API 只有三點差別:網址不同、model 欄位填「部署名」、認證用 Azure 的方式。以下是兩種認證的原始 curl:

    # 用 API 金鑰(Header 是 x-api-key)
    curl -X POST https://<resource>.services.ai.azure.com/anthropic/v1/messages \
      -H "Content-Type: application/json" \
      -H "x-api-key: $AZURE_API_KEY" \
      -H "anthropic-version: 2023-06-01" \
      -d '{
        "model": "<your-deployment-name>",
        "max_tokens": 256,
        "messages": [{"role":"user","content":"Hello, which model are you?"}]
      }'
    
    # 用 Entra ID(Header 是 Authorization: Bearer,scope https://ai.azure.com/.default)
    curl -X POST https://<resource>.services.ai.azure.com/anthropic/v1/messages \
      -H "Content-Type: application/json" \
      -H "Authorization: Bearer $AZURE_AUTH_TOKEN" \
      -H "anthropic-version: 2023-06-01" \
      -d '{
        "model": "<your-deployment-name>",
        "max_tokens": 256,
        "messages": [{"role":"user","content":"Hello, which model are you?"}]
      }'
    

    6. 一個必知限制:訂閱資格與配額

    有個坑要先知道:Foundry 上的 Claude 通常限定企業等級訂閱(Enterprise / MCA-E),而且非企業訂閱的預設配額可能是 0 RPM / 0 TPM,免費 / 試用 / 純 credit 帳號不支援。意思是——你用個人帳號可以「部署成功」,但真正送推論時可能撞到 0 配額或資格錯誤。這正是企業要在正式的公司訂閱下跑、而不是個人帳號的硬理由。

    第二階段:進化成 API Gateway

    為什麼要 Gateway

    直連能動,但每台機器各自拿著後端憑證、各自直接打雲端——這在企業是不可維護也不安全的。把一道閘道架在中間,你得到一個單一控制點:

    • 統一認證與 RBAC:誰能用、能用哪些模型,集中管理;client 只拿你發的 token,永遠看不到後端真憑證。
    • 稽核與成本歸戶:每一筆請求記 log,依使用者 / 專案歸戶成本。
    • 限流與配額:在閘道做,而不是寄望每個 client 自律。
    • 供應商解耦:哪天要把某個模型從 A 雲換成 B 雲,改閘道就好,幾百台 client 一行都不用動。

    關鍵架構原則:一個入口,依 model 路由

    最容易設計錯的地方:不要做成「Sonnet 一個網址、Opus 另一個網址」。 Claude Code 整個 session 只認一個 base URL,它靠請求 body 裡的 model 欄位區分模型,所有請求都送到同一個入口。所以正確設計是:閘道對外只露一個 DNS 入口,內部再依 model 名稱路由到對應的後端部署。你想像中的「API1 / API2 分流」應該活在閘道後面,對 client 只露一扇門。

    Claude Code 改成 Gateway 模式

    不再用 Foundry 那組變數,改用通用閘道模式。注意 model 這裡填「乾淨的標準名」,讓部署名的映射藏在閘道裡:

    {
      "env": {
        "ANTHROPIC_BASE_URL": "https://ai-gw.yourcompany.com",
        "ANTHROPIC_AUTH_TOKEN": "<gateway-issued-token>",
        "ANTHROPIC_DEFAULT_SONNET_MODEL": "claude-sonnet-4-5",
        "ANTHROPIC_DEFAULT_OPUS_MODEL":   "claude-opus-4-1",
        "ANTHROPIC_DEFAULT_HAIKU_MODEL":  "claude-haiku-4-5",
        "CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY": "1"
      }
    }
    • ANTHROPIC_BASE_URL(通用)取代 CLAUDE_CODE_USE_FOUNDRY;Claude Code 會打 {BASE_URL}/v1/messages
    • ANTHROPIC_AUTH_TOKEN 會以 Authorization: Bearer 送出(若閘道收 x-api-key,改用 ANTHROPIC_API_KEY)。
    • model 填標準名,閘道內部再對應到實際部署名——client 從此不必知道後端命名怪癖。

    閘道必須遵守的契約

    你的閘道本質是一個 Anthropic Messages API 相容的透傳反向代理。違反任一條,Claude Code 與所有官方 SDK 就打不進去:

    要求 說明
    對外端點 POST /v1/messages選配 /v1/messages/count_tokens/v1/models(供模型發現)。
    body 原樣透傳收到什麼 Anthropic Messages JSON,就照樣轉發,絕不改 schema
    支援 SSE streamingstream:true 必須逐塊串回,這是最常翻車的點。
    依 model 欄位路由把標準名映射成對應後端部署名並轉發。
    後端注入真憑證閘道持有後端金鑰 / service principal,client 永遠看不到。
    錯誤碼原樣回429 / 401 / 400 照轉,client 才能正確重試。

    一條封包的端到端追蹤

    把上面串起來,一通 Sonnet 請求與一通 Haiku 請求,打的是同一個網址,只有 body 的 model 不同:

    # Claude Code 做主要工作(Sonnet 層)
    POST https://ai-gw.yourcompany.com/v1/messages
    Authorization: Bearer <gateway-token>
    anthropic-version: 2023-06-01
    {"model":"claude-sonnet-4-5","messages":[...],"stream":true}
    
    # Claude Code 做雜活(Haiku 層)-- 網址與 token 一模一樣,只有 model 變
    POST https://ai-gw.yourcompany.com/v1/messages
    Authorization: Bearer <gateway-token>
    {"model":"claude-haiku-4-5","messages":[...]}
    
    # 你的 Gateway 收到後:
    #   1) 驗 token + RBAC(這個人 / 這隊能用哪些 model)
    #   2) 讀 model 欄位,查路由表:
    #        claude-sonnet-4-5 -> 後端部署 "claude-sonnet-4-5-xx"
    #        claude-haiku-4-5  -> 後端部署 "claude-haiku-4-5"
    #   3) 改寫 model 成真部署名、換上後端真憑證、轉發到雲端
    #   4) 後端回標準 Anthropic 回應 -> Gateway 原樣串回 -> Claude Code 收到

    用現成的,別手刻 schema

    別自己發明一套 JSON 格式包起來——那會讓 Claude Code 和所有官方 SDK 全部失效,很多公司「封裝 API」就死在這。直接用支援 Anthropic 相容 + model-based routing 的成熟方案:雲端原生的 API 管理服務(如 Azure API Management)、或開源的 LLM 閘道(如 LiteLLM proxy、Portkey)。它們原生就能做認證、限流、路由與 log。

    常見錯誤與排查

    症狀 原因 / 解法
    Claude Code 一直要你登入 Anthropic沒設 CLAUDE_CODE_USE_FOUNDRY=1,它走了預設公開 API。
    model is not availableANTHROPIC_DEFAULT_*_MODEL 沒對到實際部署名(注意同名重建的序號後綴)。
    401 / 403金鑰錯,或 Entra scope 不是 https://ai.azure.com/.default,或缺 RBAC 角色。
    429 / 0 配額非企業訂閱預設配額為 0;改用企業訂閱或申請配額。
    部署一直 Failed 又刪不掉資源進入 bad state;建新資源,別在壞掉的上面重試。
    經閘道後 streaming 不會動閘道沒正確透傳 SSE;確認 stream:true 的逐塊轉發。

    結語

    這條路的核心其實只有一句話:Foundry 的端點就是標準 Messages API,所以閘道只要當一個透傳代理。 先用直連證明機制能通,再用閘道把它收斂成「單一入口、依 model 路由、注入真憑證」的企業架構——資料留在合規邊界、計費可歸戶、供應商可替換。當前沿模型的使用門檻越來越高,能把它穩穩接進公司治理框架的能力,本身就是一種競爭力。

  • Claude Design 實戰拆解:brainstorming/spec/plan 三層流程的必要性與代價

    重點摘要

    • Claude Design 不是一個工具,是 Claude Code 裡由 brainstormingwriting-planssubagent-driven-development 三個技能組成的結構化開發流程,把「想 → 寫規格 → 拆任務 → 做 → 審查」變成可追蹤的步驟。
    • 最大價值是「砍掉不該做的事」——在我的失智症陪伴專案裡,這個流程幫我在寫 code 前砍掉了背景音樂、獨立話題卡、每日心情打卡三個功能,省下至少 3-4 小時重工。
    • 設計原則會在對話中浮出來——使用者一句「照顧者腦子清晰的,可以有期待的方式知道」變成整個系統的「可預期」原則,驅動 45 條提示語都用同一個模板。
    • 但它不適合所有情境——單檔 HTML 原型用 subagent-driven-development 會被 39 次 subagent dispatch 拖到超慢,實測比 inline 慢 3-5 倍。
    • 判斷標準:想事情時用 brainstorming、寫一致內容時用 spec、多檔複雜時用 subagent;單檔改一個函式就直接 inline。
    • 最深的反省:Claude Design 其實就是把 SDD「菜譜化」。人人可以照做,但如果不懂菜譜背後的「為什麼」,遇到菜譜涵蓋不了的變化就卡住。AI 時代最危險的是「永遠繞著菜譜轉、卻以為自己會了」——你的能力上限會被 AI 給的菜譜深度封頂。
    • 用中華一番「大魔術熊貓豆腐」案例說明:對手下黑手、大豆意外變納豆、把汙染當靈感——這三個 AI 結構上做不到的元素。文末附 7 個對抗菜譜化的具體做法,最關鍵是「保留一塊 AI 絕不介入的創作領域」。

    「Claude Design」這個名字其實沒有官方定義,它是 Claude Code 裡一組設計驅動的工作流程技能(superpowers:brainstorming / writing-plans / subagent-driven-development)的總和。我最近用它做了一個失智症陪伴 APP 的重大功能迭代,這篇文章把它在實戰中「什麼時候救了我」跟「什麼時候反而拖慢我」完整拆給你看。

    Claude Design 是什麼?三層流程一次看懂

    Claude Design 是一套讓 AI 助手在動手寫 code 前先「想清楚 → 寫規格 → 拆任務」的結構化流程。它不是任何新工具,而是 Claude Code 內建的三個技能組合使用:

    階段 技能名稱 產出 目的
    1. 發想 brainstorming 設計 spec(Markdown) 用多輪一問一答釐清需求、砍掉不該做的、浮出設計原則
    2. 規劃 writing-plans 實作計畫(含驗證步驟) 把 spec 拆成 10-20 個可個別 commit 的小任務
    3. 執行 subagent-driven-development 每個 task 一個 commit 派 subagent 做、派 subagent 審 spec、派 subagent 審 code quality

    重點不是「三個步驟」這個形式本身,而是每一步強迫你跟 AI 在不同粒度上達成共識:brainstorming 達成「做什麼」、spec 達成「做成什麼樣」、plan 達成「怎麼拆」、subagent 執行時還能雙重審查。

    沒用 Claude Design vs 用 Claude Design 的實際差異

    同樣是「加一個照顧者支援功能」的需求,兩種做法的差別在哪?這是我實測後的對照:

    面向 直接叫 AI 寫 走 Claude Design 流程
    需求釐清 憑 AI 猜,常常做錯方向 多輪問答,需求明確後才動手
    功能範圍 容易做太多(AI 傾向加功能) 在 brainstorming 階段就砍掉不必要項目
    一致性 做到一半風格會漂移 spec 用表格固定內容模板
    可追蹤 一個大 commit 或多個散亂 commit 每 task 一個 commit,可個別 revert
    重工成本 常常寫完才發現方向錯 方向錯在 spec 階段就發現
    速度 單點快、整體容易重工 前期慢、後期穩;不適合微任務

    實戰案例一:砍功能,省下 3-4 小時重工

    Claude Design 最值錢的貢獻不是寫 code,是阻止你寫不該寫的 code。在我的失智症陪伴 APP 迭代過程中,brainstorming 流程實際上幫我砍掉了三個功能:

    砍掉案例 1:背景音樂

    我一開始提議加背景音樂(失智症音樂療法有根據),brainstorming 過程中討論到「單檔 HTML 沒辦法帶 MP3、base64 嵌入會讓檔案爆到 30MB、用 File API 每次要重選」三個技術方案的取捨後,使用者自己說「先不要」。如果沒經過討論直接開寫,我大概會先做 File API + ducking 邏輯寫個兩小時,結果做完發現整個方向不對。

    砍掉案例 2:獨立話題卡

    原本規劃「話題卡」+「遊戲中陪伴提示」是兩個獨立功能。討論到一半,使用者界定:「這個 APP 是玩樂的時候用,真的要純聊天另外開 APP」。這句話直接把「獨立話題卡」功能從 spec 刪除,只保留遊戲情境下的提示。沒有這個界定,我會把話題卡塞進首頁,未來做下一個 APP 會有功能衝突。

    砍掉案例 3:每日心情打卡

    我在 brainstorming 時列過 5 個功能候選,其中「每日狀態簡記」(3 秒打卡心情/精神/食慾)看起來很有價值。使用者沒選這個,理由是「會把 v2 從『打開就用』變成『每天要記得打卡』,失智照顧者已經很累了」——這是使用者比我更懂他的使用情境的典型例子。AI 單獨設計是想不到這層的。

    這三個砍掉的功能合計估計省了 3-4 小時的 coding + 之後的 code review + git 回改。這才是 Claude Design 最值錢的部分——它讓「沒寫到 code 就砍掉」變成可能。

    實戰案例二:「可預期」這個原則如何救了 45 條提示語

    brainstorming 過程中,使用者往往會不經意說出一句話,變成整個系統的設計支柱。這次是這一句:

    「我希望對於照顧者而言,他是腦子清晰的,他可以有期待的方式知道,我可以看到該說什麼。」

    這句話裡面的「可預期」被提煉成整個功能的設計原則,寫進了 spec。然後這個原則驅動了三個具體決策:

    1. 提示固定模板:15 個遊戲 × 3 個時機(開場/答對/完成)= 45 條提示,全部用「情境 → 可以直接說的話」這個同一個格式,照顧者看一次就學會。
    2. 摘要強制預覽:不是一按就複製,而是開 modal 預覽、確認內容,才複製。照顧者對輸出「可預期」。
    3. 按鈕只在完成活動後才出現:有資料才有按鈕,避免使用者按下去才發現「沒東西可傳」。

    沒有 brainstorming 把這個原則浮出來、沒有 spec 把它寫下來,我會寫 45 條有個性的不同句型(AI 本能會追求多樣性)。結果照顧者每次要重新解讀 UI,反而更累。「可預期」這個字沒有出現在原始需求,是對話中自然生成的,但它比任何功能清單更重要。

    實戰案例三:Spec 表格讓語氣不漂移

    Spec 文件裡有一張表格,把 15 個遊戲 × 3 個時機 × 實際內容全部列出來:

    遊戲 開場 答對時 完成時
    顏色辨識 哇,好多顏色,你以前最愛穿什麼顏色? 對!你好厲害 今天陪你看顏色,我也覺得很漂亮
    認字遊戲 這個字你以前就認得吧 對啦,這個字你小時候就會了 今天還認這麼多字,真棒
    呼吸練習 我們一起慢慢呼吸 (改成中段顯示)吸氣…吐氣…不急 輕輕摸摸他的手,這樣就好

    如果不是在 spec 階段一次寫完這張表,而是「做到顏色遊戲時寫顏色的 3 條 → 做到形狀遊戲時寫形狀的 3 條」這樣推進,語氣一定會漂移。寫到第 10 個遊戲的時候我會忘記前面的語氣,變成有些句子很溫暖、有些很乾。表格逼我一次寫完,才有辦法保持「你年輕時、你很厲害」這類一致的溫度。

    這是表格化內容的威力——它讓「一致性」不是靠意志力維持,而是靠資料結構強制。

    反例:Claude Design 不適合的時候

    這次實戰也讓我踩到一個很明顯的坑:subagent-driven-development 對單檔 HTML 原型是殺雞用牛刀

    我一開始對 13 個 task 全部套用標準流程:每個 task 派 1 個 implementer subagent + 1 個 spec reviewer + 1 個 code reviewer,總共 39 次 subagent dispatch,每次 20-130 秒。前幾個 task 都只是「加一個 const、改一個函式」這種改動,triple review 完全是過殺。

    使用者實測後直接問我:「你寫程式變慢很多你用什麼模型」——這是一個誠實的信號。我當下檢討並切換到 inline 執行模式(我自己在 session 裡直接做),後半段 8 個 task 的速度回到正常的 3-5 倍。

    這個教訓很值:流程的 overhead 必須跟 task 粒度匹配。如果你的 task 只是改 20 行 code、不會影響其他模組,triple review 沒有價值,還會讓每個 task 多花 3-5 分鐘在 subagent 啟動/總結上。

    更重要的反省:Claude Design 是「菜譜」,不是基本功

    讀到這裡,你可能會問:「Claude Design 其實不就是 Spec-Driven Development(SDD)嗎?」 沒錯。brainstorming + spec + plan + implement 這四步是 SDD 老方法,不是 Claude Code 發明的。Claude Design 做的事其實是把 SDD 從「一千個人有一千種做法」方法化成「人人可以順暢工具化」的標準流程

    這是好事,也是很危險的事。

    菜譜出現前、出現後

    想像一下麻婆豆腐這道菜:

    • 菜譜出現前:只有師傅會做。每個師傅的麻婆豆腐都不一樣,因為他們從「為什麼要用豆瓣醬、為什麼花椒要後下」這種基本功思考過。客人要求「少辣多麻、加竹筍」這種變化,師傅能即時調整。
    • 菜譜出現後:人人可以照做,麻婆豆腐變得普及。但只會照菜譜的人,遇到「客人對豆瓣醬過敏,要用別的替代」這種問題就卡住了——因為他從來沒問過「為什麼要用豆瓣醬」。

    Claude Design 就是出現了菜譜。它把 SDD 的步驟變成 Skill、把「設計審批」變成 <HARD-GATE>、把 subagent 審查變成標準流程。你不需要知道為什麼要分離「設計」和「實作」,照著 skill 走就有規範的輸出。

    為什麼 AI 時代這件事特別危險

    菜譜時代的廚師,至少還能從菜譜回推原理——多做幾次就知道花椒晚下是為了香氣不揮發。但 AI 時代:

    1. 你問 AI「怎麼做需求分析」→ AI 給你 Claude Design 流程
    2. 你照流程做,產出看起來很漂亮的 spec 和 plan
    3. 你以為你會做需求分析了
    4. 遇到「這個需求太模糊、brainstorming 走 10 輪還是卡住」這種菜譜沒涵蓋的情況
    5. 你再問 AI → AI 給你另一個菜譜
    6. 你永遠繞著菜譜轉,沒有真的建立「為什麼需求會模糊、要怎麼引出使用者的隱藏前提」這種基本功

    最可怕的結果:你的能力上限永遠等於 AI 提供的菜譜深度。菜譜涵蓋不了的變化,你就做不到。而且因為你沒痛過傳統 SDD 的坑,你連「現在這個情境是菜譜解不了的」都判斷不出來——你不知道自己不知道

    SDD 真正的基本功是什麼

    Claude Design 的 skill 不會教你這些,但這些才是真正讓你能判斷、變通、甚至挑戰流程的基本功:

    菜譜只教你「做什麼」 基本功讓你懂「為什麼」
    brainstorming 要一次問一個問題 人的認知頻寬有限,多問題並排會讓使用者選擇癱瘓而隨便回答
    spec 要寫 45 條提示的表格 分批生成會有語氣漂移,但為什麼會漂移?因為 LLM 每次 context 都重新「感覺」一次
    實作前要設計審批 因為修改 code 的成本遠高於修改文字,越晚發現方向錯越貴
    subagent 要 triple review 多視角審查降低單一 agent 的盲點,但前提是 task 複雜到值得這個 overhead
    每 task 一個 commit Git bisect 的粒度等於 debug 速度,太粗的 commit 追 bug 要多花 10 倍時間

    懂了「為什麼」,你才能在菜譜斷裂的地方自己接住。例如:brainstorming 走不下去,你會知道這是因為使用者自己也沒想清楚,你要換一個方式(給他看 mockup 而不是繼續問字)而不是換另一個菜譜。

    給讀者的反省題

    每次用 Claude Design 之前,自問一句:「如果沒有這個菜譜,我會怎麼做這件事?」

    • 如果你答得出來 → 你用 Claude Design 是省時間
    • 如果你答不出來 → 你該先花時間讀 SDD 的原理,而不是依賴 skill 的自動化

    這不是反對 Claude Design。菜譜是好事,讓一道菜普及化。我想提醒的是:Claude Design 方便到你可能永遠不會問「為什麼」。而一個工程師的上限,取決於他問過多少個「為什麼」

    什麼時候用、什麼時候跳過?判斷決策表

    情境 建議流程 理由
    有多個可能方向、還在猶豫 brainstorming 避免選錯方向重工
    要改 15+ 個相似位置、要寫一致的內容 brainstorming + spec 用表格強制一致性
    多檔複雜後端、有 test framework、多人協作 完整三層 + subagent triple review 能防止衝突跟回歸 bug
    單檔 HTML、改一個函式、加一個按鈕 直接 inline,跳過流程 overhead 大於價值
    修 bug 已經知道怎麼修 直接改,不派流程 問題明確時流程是拖累
    重構一個模組的架構 brainstorming + spec(可能跳過 subagent) 要想清楚新架構但執行可以快

    3 個給讀者的實作建議

    1. 開工前先問自己一句話:「這個 task 的粒度適不適合走流程?」如果是「修一個 bug」「改一個顏色」,直接做;如果是「加一個新功能」「重構一個模組」,走 brainstorming。
    2. brainstorming 時刻意引導 AI 砍東西,不是加東西。AI 本能傾向加功能,你要主動問「這個是不是另一個 APP 的事?」「這個能不能先不要做?」。砍掉的功能是最值錢的產出。
    3. Spec 一定要用表格呈現重複性內容。如果你有 10+ 個相似的東西(15 個遊戲的 3 條提示、20 個 API 端點的 error message、12 個表單欄位的 placeholder),強制用表格一次寫完,不要分批生成。

    中華一番案例:AI 結構上做不到的創新

    講到這裡都還是抽象論述。讓我用一個具體案例把「AI 為什麼結構上做不到某些創新」講清楚——1997 年日本動畫《中華一番》第 43 集「大魔術熊貓豆腐」。

    劇情背景:小當家與黑暗料理界的邵安,在樓麟艦上進行豆腐對決。評委要求不能用現成豆腐,必須從黃豆開始做。比賽中:

    1. 對手下黑手:黑暗料理界的向恩把稻草偷偷放進小當家的大豆裡
    2. 意外發生:稻草上的納豆菌讓大豆發酵,大豆變成了納豆(日本傳統發酵食品)
    3. 認知翻轉:小當家看到黏糊牽絲的納豆,不是當成「比賽被破壞」丟掉,而是把這個意外當成靈感起點
    4. 創新誕生:從納豆的特性衍生出做法與工具,最終做出「大魔術熊貓麻婆豆腐」擊敗邵安

    (資料來源:萌娘百科納豆條目,ACGN 中的納豆相關劇情段落)

    這故事裡有三個 AI 結構上做不到的元素

    劇情元素 AI 為什麼做不到
    對手下黑手破壞材料 AI 的 brainstorming 永遠假設「正常情境」,不會模擬「比賽中有人陷害你」這種社會性干擾
    辨識大豆已變納豆 需要跨文化背景知識在當下湧現。一個四川廚師要有人把日本發酵食品的視角帶進來,AI 知道但不會主動從「邊緣」冒出來
    把失敗當靈感起點 AI 被訓練避免失敗、給成功解。被汙染的食材應該丟掉重做——這是 AI 的強勢模式。把 contamination 翻轉成創新起點是訓練資料裡的反模式

    我把這個對比叫做「紹安路 vs 小當家路」

    • 紹安路:精修技術、重組既有元素、走正統菜譜 → AI 擅長
    • 小當家路:個人記憶 + 意外事件 + 跨文化知識 + 重新定義失敗 → AI 做不到

    紹安在豆腐三重奏對決中輸得更深:他自以為原創的料理,其實 7 年前師父陳邦鈴就做過一樣的。他切斷了有意識的傳承,但無意識的傳承切不斷——他走遍中國、投奔黑暗料理界研發的「自創」菜,結構上還是師承的重組。

    用 Claude Design 久了的人可能遇到比紹安更慘的處境:紹安至少還是在複刻真實的師父,你在複刻 AI 訓練資料——但你不會知道,因為沒人會告訴你「這個東西 AI 在 2023 年就生成過一模一樣的了」。

    7 個對抗紹安化的具體做法(可以從下個 task 開始)

    如果你接受「菜譜化是現實、不會回頭」這個前提,那問題就不是「要不要用 Claude Design」,而是「怎麼用但不被它吃掉」。以下是我經過這次專案後整理的 7 個具體做法:

    1. 先離線想 10 分鐘,再開 AI

    用紙筆或純文字檔,在沒有 AI 的狀態下先寫下你對這題的想法——即使亂七八糟、半句話、只有關鍵字。寫完才來找 AI。這 10 分鐘的差別,是你有沒有在對話開始前建立自己的立場。

    2. 刻意加入 AI 絕對不會建議的約束

    AI 傾向推薦「平均來說最好的解」。你主動加怪條件逼自己走不一樣的路。例:做失智症陪伴工具時,不要說「做陪伴 APP」,說「做一個只能給老花眼、色盲、聽障照護者用的工具」——限制是創新的助產士。

    3. 每週跟一個「四郎」講一次話

    不是讓他們給你解決方案,是把他們的「意外知識」放進你生活。失智照護協會的阿姨、你媽或阿嬤(上一代的照護記憶)、會日文的朋友、幼稚園老師(他們跟認知差異的小孩互動方式跟失智照顧很像)⋯⋯讓他們隨口說的話在你腦裡發酵,像稻草丟進黃豆

    4. 把「bug / 意外 / 失敗」當創作材料,不是要避免的事

    開一個 inspirations-from-failures.md,每次遇到意外事件,先不要問怎麼解,先寫三句話:這個意外讓我看到什麼我原本沒看到的?這個限制如果我接受它,會變成什麼新東西?如果我把這個「bug」當成功能,會是什麼?AI 的訓練資料裡「bug 要修」是強勢模式,你要刻意反抗這個傾向。

    5. 對 AI 使用「反向問法」

    每次 AI 給你答案,下一句問:「這答案的相反是什麼?」「80 歲阿嬤會怎麼想這件事?」「如果這是錯的,錯在哪?」「這答案看起來合理,可是我錯過了什麼?」——這會強迫 AI 跳出訓練資料的中心,去邊緣抓東西。AI 不會主動做這件事,你得逼它。

    6. 保留一塊「AI 絕不介入」的創作領域

    不是「少用 AI」,是完全禁止。具體例子:照顧長輩的手寫日記(絕不給任何 AI 看)、一個嗜好(煮菜、種花、學樂器)、每週一天完全不開 Claude / ChatGPT。這塊領地是你保持「能產生小當家型靈感」的保護區。失去這塊,你永遠只能是紹安。

    7. 跟 AI 約定「小當家模式」信號詞

    當你要創新、不要優化時,直接跟 AI 說:「這次我要小當家模式,不要 Claude Design」。你的 AI 應該立刻做三件事:關閉所有 brainstorming/spec/plan 流程建議、不給業界做法、反過來問你的個人史跟身邊的人。這是你跟 AI 之間的信號詞。沒有它,AI 會把菜譜當成預設。

    優先順序:如果只能選一個開始

    選第 6(AI 禁區)。沒有這個,其他六個遲早會被 Claude 侵蝕回去。禁區是你維持「小當家能力」的物理基礎。

    結論:不是流程多就好,是流程跟 task 匹配才好

    Claude Design 不是一個「你該永遠用」的聖杯,也不是一個「多此一舉」的噱頭。它是一套當你面對真正需要思考的問題時,把你跟 AI 之間的對話規則化的工具。

    我這次失智症陪伴 APP 專案裡,Claude Design 救了我的前半段(brainstorming 砍功能 + spec 寫一致的 45 條提示),拖慢了我的後半段(subagent-driven-development 對單檔 HTML 過殺)。能分清這條線,是下次用它用得更好的關鍵。

    如果你的下一個 task 真的很簡單、你已經知道怎麼做——直接做。但如果你正在「想不清楚這功能該不該做」或「要做 15 個相似的東西怕語氣不一致」,那就值得花 20 分鐘先走 brainstorming。這 20 分鐘會幫你省下 3-4 小時。

    延伸閱讀

  • Ionic 逆向重建 Flutter 完整踩坑紀錄:三套 APP、20+ 個坑、一套方法論

    重點摘要

    • 從 Ionic 1 / AngularJS + WordPress PHP 逆向重建三套 Flutter APP,歷時一週,踩了 20+ 個分類的坑
    • 最毒的方法論錯誤:審查時讀了原始碼,實作時卻只靠缺失清單——導致多輪審查永不收斂
    • PHP Broker API 的 Content-Type 是 text/html、數值欄位全是 String、token 欄位名稱每個子系統不同
    • WordPress Multisite 的 table prefix 陷阱:直接打 plugin 路徑走 main site(wp_),跟 WP Admin 看到的(wp_2_)不同
    • 逆向工程的核心原則:原始碼是唯一 ground truth,不是用戶的記憶,不是截圖,不是 AI 的推測

    這篇文章記錄了一個完整的逆向重建專案:將一套社區管理系統(三套 APP + WordPress 後端)從 Ionic 1 / AngularJS 遷移到 Flutter。不是新開發,是一比一逆向複製——原版有的每一個按鈕、每一個欄位規則、每一個邊角功能,新版都必須完全復現。

    三套 APP 分別是:住戶 APP(社區公告、包裹、費用等)、管理平板(出勤、包裹管理、公設租借、訪客登記等)、門禁保全 APP(簽到簽退、巡邏、QR 掃描)。它們共用同一個 WordPress PHP 後端。

    以下是按主題分類的完整踩坑紀錄和方法論總結。

    一、逆向重建最毒的方法論錯誤是什麼?

    逆向重建最毒的方法論錯誤是「審查讀原始碼、實作不讀」。這聽起來不可能,但在 AI 輔助開發中極其常見:

    1. 審查 Agent:從原版 HTML / JS 逐行讀 → 產出缺失清單 → 每項有行號出處 ✅
    2. 實作 Agent / 新 Session:拿到缺失描述(如「公告無窮捲軸缺失」)→ 直接寫 Flutter → 沒有讀原版邏輯
    3. 結果:修了 A,同頁的 B/C/D 仍缺(因為根本沒讀那頁的完整原始碼)
    4. 下輪審查:再從原版讀 → 再找到 B/C/D → 循環不斷

    我們經歷了 7 輪審查才讓管理平板的缺失清單收斂。前 3 輪每輪都有 10+ 個新發現,根本原因只有一個——方向反了。

    建立的強制規則

    • 拿到缺失 ID 時,必須先讀對應的原始碼(file:line),不得只靠缺失描述動手
    • 修某頁某功能時,如果手上沒有該頁完整 Source Inventory → 必須先做 Source Inventory
    • Review 方向必須是:原版 HTML → 原版 JS → 原版 PHP → 列清單 → 逐項對照新版。禁止從 Flutter 出發猜原版有什麼

    二、Source Inventory 協議:逆向工程的唯一正確開始方式

    Source Inventory 是在動手寫任何程式之前,先把原版的所有功能逐行列出來的過程。每一項都必須標注原始碼來源(檔案 + 行號),沒有行號的項目等於捏造的。

    - [ ] 登出按鈕
          來源:account.html:142 <button ng-click="logout()">
    
    - [ ] 棟別/樓層兩層下拉選單
          來源:visitor-form.html:55-67, controllers.js:9366-9398
    
    - [ ] 黑名單檢查(借用簽名後、API 呼叫前)
          來源:publicequip.js:2040-2052

    清單涵蓋四大類:所有 UI 元素(按鈕、欄位、badge、空狀態提示)、所有互動行為(點擊、滑動、下拉刷新)、所有 API 呼叫及欄位映射所有頁面入口/出口

    最容易漏的永遠是邊角功能:登出藏在 header component、空狀態提示在條件分支、黑名單檢查在簽名驗證之後。主流程之外的東西,AI 不會主動去找。

    三、PHP Broker API 的七大陷阱

    這套系統的 API 層是 WordPress PHP plugin,所有請求都走同一個 Broker endpoint。以下是我們踩過的每一個 API 相關的坑:

    3.1 Content-Type 是 text/html

    PHP Broker 的回應 Content-Type 是 text/html 而非 application/json。Dio(Flutter HTTP 套件)如果設了 ResponseType.json,會解析失敗。必須設 ResponseType.plain 再手動 jsonDecode

    3.2 數值欄位全是 String,除了偶爾不是

    大多數 JSON 數值欄位回傳的是字串("id":"1")。但 $wpdb->get_results() 對 int DB 欄位有時會回傳 PHP native int(JSON 裡沒有引號)。解法:所有 nullable String 欄位一律用 ?.toString(),避免 type 'int' is not a subtype of type 'String?'

    3.3 Token 欄位名稱每個子系統不同

    子系統 Token 放在 例外
    主 Broker(住戶/平板)data.cookie
    Guard Broker(門禁)data.tokenvalidate_authdata.cookie

    搞混了就會被判定為 anonymous user,API 回 "非有效角色,無法使用!",而且沒有任何認證失敗的明確錯誤碼

    3.4 returnCode 不統一

    "OK""0"(package 模組)、"1""ERROR""dup"——全是字串,不要做整數比較。每個模組的成功碼不同,必須逐一確認。

    3.5 Category / Method 命名混亂

    有的是 snake_case(get_ticket_by_member_id),有的是 camelCase(retrivePublicEquipTXN——對,retrive 是拼錯的),有的是完全不同的規則(createTableAccount)。必須從 PHP 程式碼抄出精確字串,不能猜。

    3.6 Response 結構不一致

    • mutual:回 {rows_1:[], rows_2:[]}(自己的 + 社區其他人的)
    • ticket:回 {data: {rows, total, totalPages}}(分頁結構)
    • package_light:returnCode 用 "0" 而非 "OK"
    • getTwCode:空表時回 data: ""(空字串),不是 []

    3.7 磁卡批次 API 是 flat array

    大部分 API 的 data 格式是 {data: {key: value}},但磁卡批次領取是平坦陣列 [{id, card_no, status}]。PHP 端用 is_array($data) 判斷。這意味著 Flutter HTTP client 的 data 參數不能寫死為 Map,必須改成 dynamic

    四、WordPress Multisite 的 Table Prefix 陷阱

    WordPress Multisite table prefix 陷阱是整個專案最令人崩潰的問題之一。直接打 plugin PHP 路徑(如 /wp-content/plugins/.../API_Broker.php)時,WP 識別為 main site (blog_id=1),使用 wp_ 前綴。但在 WP Admin 介面、phpMyAdmin 看到的是 wp_2_(子站表)。

    後果:seed 測試資料時插到 wp_2_ulifeplus_*,但 API 查的是 wp_ulifeplus_*——資料永遠看不到,而且不報錯,就是空陣列。

    另外,改網域必須改 5 個地方wp_options(siteurl + home)、wp_blogs(domain)、wp_site(domain)、wp-config.php(DOMAIN_CURRENT_SITE + WP_HOME + WP_SITEURL)。DOMAIN_CURRENT_SITE必須含 port,否則會無限 302 redirect。

    五、validate_role() 全面封鎖事件

    所有 28 個 PHP endpoint 都在進入主邏輯前呼叫 validate_role()。原版只接受 ulifeplus_api / ulifeplus_admin / administrator / ulifeplus_operator,不含住戶帳號 ulifeplus_subscriber

    原因:原版平板用的是專屬服務帳號(QR code 開通碼流程),不是住戶帳號直接登入。重建版讓住戶直接登入 → 所有 API 一律 ERROR

    修補方案需要雙層:(1) patch PHP 接受 ulifeplus_subscriber;(2) 給測試帳號加 ulifeplus_api role。而且 wp_capabilities 的序列化格式 a:N:{s:LEN:"role_name";b:1;} 的 LEN 必須精確——寫錯一個字元,整個 unserialize 就失效,用戶變成沒有任何 role。

    六、三套 APP 的進化軌跡:從混亂到方法論

    第一套:住戶 APP——摸清後端規則

    住戶 APP 是最先做的,主要踩了後端相關的坑:Content-Type 是 text/html、數值欄位全是 String、member_id vs WP user_id 混淆、validate_role 全面封鎖、WP Multisite table prefix。這些經驗讓我們對 PHP Broker 的行為有了完整的心智模型。

    第二套:管理平板——方法論崩潰與重建

    管理平板是最複雜的(10+ 模組),也是方法論崩潰的戰場。7 輪審查、每輪都有新發現、多個 Agent 交叉審查卻互相誤報(false positive)。最終逼迫我們建立了 Source Inventory 協議、四大卡點規則、和「審查必須從原版出發」的強制流程。

    核心教訓包括:

    • Grid → Card List 轉換會遺失 checkbox column 和 cellTemplate 等「免費」UI 行為
    • 條件式按鈕(enableShowClosed 等)的每個 ng-if 都是業務意圖,不能合併或省略
    • smart_disp.get_hidden_code() 遮名演算法需要完整移植,不能簡化
    • 日期範圍查詢必須含時間(00:00:00 / 23:59:59),否則 BETWEEN 漏掉當天
    • Feature flag 的預設值不一定是 false,必須讀完整條件判斷

    第三套:門禁 APP——方法論成熟

    到第三套門禁 APP 時,Source Inventory 協議已經內化。整個 APP 從原始碼分析到 21/21 測試通過只花了一天。但還是踩了新坑:

    • Guard Broker 的 token 欄位是 data.token(不是主 Broker 的 data.cookie
    • PHP class constant const data = "date" 從不生效(bareword array key 行為)
    • showDialog 的 BuildContext 跨 async 導致確認 dialog 靜默失敗
    • HTTP 部署下相機 API 被瀏覽器封鎖(Secure Context 限制)
    • Flutter Web 的 SPA 狀態在測試間污染(需 full HTTP reload)

    七、Flutter 遷移的技術坑清單

    症狀 修法
    flutter_secure_storage Web 失敗HTTPS 才能用 Web Crypto APIWeb 改用 SharedPreferences
    Platform.isAndroid Web crashdart:io 在 Web 不可用kIsWeb + defaultTargetPlatform
    CORS 重複 headerAccess-Control-Allow-Origin: *, *PHP 已有 CORS,不要加 .htaccess
    Dialog context stale確認後邏輯靜默跳過dialogCtx 不用外層 context
    Release build debugPrint 消失完全無錯誤訊息寫 SharedPreferences breadcrumb
    ConsumerWidget 無 initState需要 async 初始化改用 ConsumerStatefulWidget
    base-href 部署子路徑資源 404--base-href=/app/
    API_BASE_URL dart-defineWeb 連到 localhost--dart-define=API_BASE_URL=http://IP:PORT

    八、AI 輔助逆向工程的認知陷阱

    AI 輔助逆向工程的認知陷阱是這個專案最深層的教訓。AI 在讀原始碼方面能力極強,但在以下場景會系統性犯錯:

    1. 「我以為我知道這頁有什麼」——AI 會基於已讀的程式碼推測未讀的部分,經常猜錯
    2. 改名後誤報缺失——搜尋 scan_addr_code() 找不到,但 Flutter 用了 _scanAddressCode(),同樣邏輯換了名字就被誤報
    3. 函數名稱 ≠ 實際行為——updateUser() 實際上還做 log 寫入、狀態機轉換;getActiveItems() SQL 是 status != 'deleted' 不是 status = 'active'
    4. 「延後功能」不是藉口——AI 傾向把不確定的功能標記為「deferred」,但只要原版存在的就必須實作

    破解方式:建立 Source Inventory 清單,每項附行號。行號是可審計的(可以回去原始碼驗證),AI 的記憶不可審計。

    九、跨專案知識管理:Brain 檔案系統

    為了讓踩過的坑不只活在一個專案裡,我們建立了 Domain Brain 系統:每個技術領域一個 markdown 文件,記錄所有踩過的坑、修法、和來源。

    例如 legacy-code-rebuild.md 記錄了逆向工程的通用方法論;wordpress-broker.md 記錄了 WP Broker API 的所有特殊行為。每次 fix: commit 時,強制要求更新對應的 brain file。

    核心原則:Brain = 上次做的時候踩了什麼坑(經驗)Skill = 正確的做法是什麼(模式)。兩個都要讀。

    十、建議給想做逆向重建的團隊

    1. Source Inventory 先行——不管系統多簡單,先把所有功能列出來(附行號)。簡單的系統往往有最多隱性規則
    2. 後端先跑通——先用 curl 打通每一個 API endpoint,確認 request/response 格式,再寫 Flutter
    3. 每個模組獨立測試——不要等到所有模組做完才整合。我們的 21/21 unit + integration test 在開發過程中抓到了大量問題
    4. 記錄每一個坑——Brain 系統不是可選的,是必要的。第一套 APP 踩的坑如果沒記下來,第三套 APP 會再踩一次
    5. 不要信任 AI 的記憶——AI 會遺忘、會推測、會混淆。只有程式碼行號是可驗證的

    結語

    這個專案讓我深刻體會到:逆向重建的難度不在於「寫新程式」,而在於「完整理解舊系統」。舊系統的每一行 if/else 都是某個真實場景的反映,每一個看似多餘的欄位都有它存在的理由。

    AI 可以加速這個過程,但無法取代「逐行讀原始碼」這個步驟。捷徑是最遠的路——我們前 3 輪審查走了捷徑(從 Flutter 出發找問題),花了 3 倍時間;改用正確方法論(從原版出發列清單)後,第三套 APP 一天就完成了。

    希望這篇記錄能讓正在考慮做逆向重建的團隊少走一些彎路。

    追記:驗收階段又踩的五個大坑(2026-04-13 深夜)

    上面的文章發佈後幾小時,用戶開始實際驗收。結果又炸出一系列問題,每一個都是在開發階段「看了原始碼但沒看完整」造成的。

    坑 10:Dart 的 Map<dynamic, dynamic> 型別推導陷阱

    Flutter 的 API client 在呼叫 api.call(data: {}, token: token) 時,{} 空 Map literal 在 dynamic 參數中被 Dart 推導為 Map<dynamic, dynamic>。原本程式碼檢查 effectiveData is Map<String, dynamic>false → token 永遠不被加到 request 裡。

    影響範圍:27 個 API call。所有傳 data: {} 的頁面全壞(儀表板、帳號開通等),但傳了明確 key 的頁面(如 data: {'address_code': x})正常。這造成「有些頁面好有些壞」的假象,極難排查。

    教訓:原版 JavaScript param.token = value 不做任何型別檢查,直接賦值。重寫到靜態型別語言時,不要加「聰明」的型別守衛。笨方法之所以沒 bug,就是因為它笨。

    坑 11:config.js 常數映射層被完全忽略

    原版 Ionic 有一層 config.js 常數映射:sel → "select"upd → "update"del → "delete"add → "insert"sel2 → "select2"。Flutter 重寫時,有些地方用了短名(config.js 的 key),有些用了長名(PHP 接受的值)。PHP 只認長名。

    影響範圍:19 個 API call。寄放交辦頁面完全打不開(PHP switch/case 不匹配,回 ERROR 但 message 空字串),debug 時完全看不到線索。

    教訓:逆向重建時必須識別原版的每一層抽象。看了 controllers.js(呼叫端)和 factories.js(發送端)不夠——中間的 config.js 映射層不能跳過。每一個字串值都必須追到 PHP handler 的 switch/case 確認一致。

    坑 12:捏造不存在的 API method

    Flutter 程式碼裡出現了 method: 'select_category_detail'(包裹統計)和 category: 'util'(多帳號驗證碼)等原版完全不存在的 API call。追溯原始碼發現:前者在原版是純客戶端計算(groupBy + filter),後者正確的 category 是 'app_member'、method 是 'register_switchsite_validation_code'

    教訓:如果在原始碼裡找不到某個 API endpoint,那它就不存在。不要「合理推測」一個 API 可能存在。

    坑 13:API URL 不應該寫死在 compile time

    Flutter 用 --dart-define=API_BASE_URL=http://192.168.0.48:8010 在 compile time 寫死 API URL。結果 LAN 和 HTTPS 要分別 build,Cloudflare 快取舊 JS 時 URL 就錯。

    原版做法:API_BROKER_URL 在 config.js 是空字串,QR 碼啟動或登入時從 server 回傳 burl(blog_site_url),組合成完整 URL 存入 localStorage。

    修法:Web 版用 Uri.base.origin 自動偵測當前頁面的 origin 作為 API base URL。不管從哪個網域開,API 自動跟著。compile time 的 --dart-define 只作為 fallback。

    坑 14:外部服務走錯路由

    廣告 Banner API 在原版是打一個完全獨立的外部伺服器(vender01.tw),不是走 WP Broker。Flutter 把它包成了 category: 'ad_banner' 送進 WP Broker,當然找不到。

    教訓:原版有多個 factory(brokerFactorycommonServerFactoryomFactoryapi-vender),每個打不同的 server。重寫時必須識別每個 API call 走的是哪個 factory、打的是哪個 server。

    總結:為什麼驗收時才發現這些問題

    以上 5 個坑有一個共通點:「看了原始碼」不等於「看完了原始碼」。每次都是「看了主要的幾個檔案」但漏了中間層(config.js 映射、factory 路由、型別推導規則)。

    逆向重建的正確審查流程應該是:從 PHP handler 的 switch/case 開始,反向追每一個常數值回到 config.js,再追到 controllers.js 的呼叫端。不是從呼叫端出發猜 PHP 接受什麼。方向反了,就永遠追不完。

  • 後端老兵的工具箱:C# 非同步、Python 逆向工程、架構選型實戰

    後端老兵的工具箱:C# 非同步、Python 逆向工程、架構選型實戰

    寫了十幾年後端,從 SQL Server DBA 一路走到架構師,我發現後端開發實戰能力的核心從來不只是會寫 SQL。真正拉開差距的,是你工具箱裡有多少把不同的扳手。這篇文章整理了我在 dotblogs 上累積的幾個關鍵主題:C# 非同步模式、Python 逆向工程實戰、資料庫架構選型、壓力測試,以及從 DBA 到架構師的技術演進。每一個主題都不是教科書式的介紹,而是實際踩過坑之後的心得。後端開發實戰最重要的一課:不要只讀,要動手測。

    TL;DR 重點摘要

    • C# 非同步控制:SemaphoreSlim 比 lock 更適合 async 場景,BlockingCollection 是 producer-consumer 的標準解法,別再自己造輪子。
    • Python 逆向工程:當 API 太貴,直接逆向 Web 介面的 JSON 回應是可行路線,但要做好延遲控制與路徑文件化。
    • 架構選型:資料庫不是選最潮的,而是看存取模式決定 — 高頻讀用 cache、搜尋用倒排索引、日誌用列式儲存。
    • 壓測不是選配:沒壓測過的系統就是紙老虎,JMeter 的 Thread Group + Listener 是最基本的品質門檻。

    1. C# 非同步模式 — Semaphore 與 BlockingCollection

    在 .NET 後端開發中,非同步處理是繞不開的主題。當你有 100 個 HTTP 請求要同時發出去,但目標伺服器只能承受 10 個並發時,你需要的不是 lock,而是 SemaphoreSlim

    為什麼 Semaphore 比 lock 更適合 async?

    很多人習慣用 lock 來控制並發,但 lock 有一個致命問題:它不支援 async/await。你不能在 lock 區塊裡面 await,否則會收到編譯錯誤。即使你繞過去了(用 Monitor),async 的 continuation 可能在不同執行緒上執行,導致 unlock 失敗。

    SemaphoreSlim 則原生支援 WaitAsync(),專為 async 場景設計。它的心智模型是「停車場」:車位(permit)有限,滿了就在外面等,有車出來才放行。

    // SemaphoreSlim throttling concurrent HTTP requests
    public async Task<List<string>> FetchAllAsync(List<string> urls)
    {
        // Only allow 10 concurrent requests
        var semaphore = new SemaphoreSlim(10);
        var httpClient = new HttpClient();
        var tasks = urls.Select(async url =>
        {
            await semaphore.WaitAsync();
            try
            {
                var response = await httpClient.GetStringAsync(url);
                return response;
            }
            finally
            {
                semaphore.Release();
            }
        });
    
        var results = await Task.WhenAll(tasks);
        return results.ToList();
    }
    

    注意 finally 裡的 Release() — 不管成功或失敗都要釋放,否則 permit 會洩漏,最終所有請求都會卡住。

    BlockingCollection:Producer-Consumer 的標準解法

    BlockingCollection<T> 是 .NET 內建的執行緒安全佇列,底層預設使用 ConcurrentQueue。它最強大的特性是 GetConsumingEnumerable() — consumer 端可以用 foreach 持續等待新資料,直到 producer 呼叫 CompleteAdding()

    // Producer-Consumer pattern with BlockingCollection
    var queue = new BlockingCollection<WorkItem>(boundedCapacity: 100);
    
    // Producer thread
    Task.Run(() =>
    {
        foreach (var item in GetWorkItems())
        {
            // Blocks if queue is full (back-pressure!)
            queue.Add(item);
            Console.WriteLine($"Produced: {item.Id}");
        }
        queue.CompleteAdding(); // Signal no more items
    });
    
    // Consumer thread
    Task.Run(() =>
    {
        // Blocks automatically when queue is empty
        // Exits when CompleteAdding() is called and queue is drained
        foreach (var item in queue.GetConsumingEnumerable())
        {
            ProcessItem(item);
            Console.WriteLine($"Consumed: {item.Id}");
        }
    });
    

    這裡的 boundedCapacity: 100 是關鍵 — 它提供了背壓(back-pressure)機制。當 consumer 處理速度跟不上 producer 時,佇列滿了 producer 就會被阻塞,而不是無限制地吃記憶體。這跟傳統 ThreadPool 的固定 worker 模型不同:ThreadPool 維護一組固定的執行緒,而 Semaphore + BlockingCollection 用的是「等待」機制,更彈性也更省資源。


    2. Python 逆向工程 — 當 API 太貴,我就自己拆

    2021 年我碰到一個需求:要把 2600 多筆地址轉成經緯度座標。Google Maps Geocoding API 當時每 1000 次要收 5 美元,算一算要十幾美元。對一個一次性的專案來說,這太不划算了。

    於是我打開 Chrome DevTools,觀察 Google Maps 搜尋框的網路請求。發現它回傳的不是標準 JSON API,而是一個巢狀極深的陣列結構。座標藏在類似 d[16][0][0][7][1][3] 這種路徑裡。

    import requests
    import json
    import time
    import random
    
    def geocode_address(address):
        """Reverse-engineered Google Maps search to extract coordinates."""
        url = "https://www.google.com/maps/search/"
        params = {"q": address}
        headers = {
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
                           "AppleWebKit/537.36 Chrome/91.0"
        }
    
        resp = requests.get(url, params=params, headers=headers)
        text = resp.text
    
        # The response contains a deeply nested JSON-like structure
        # Find the coordinate data block
        try:
            # Extract the nested array from response
            start = text.find("window.APP_INITIALIZATION_STATE")
            if start == -1:
                return None
    
            # Parse the nested structure
            data_start = text.find("[", start)
            data_end = text.find("];", data_start) + 1
            raw = text[data_start:data_end]
    
            # Navigate the deeply nested path for coordinates
            parsed = json.loads(raw)
            # Path varies by response type, document it!
            lat = parsed[16][0][0][7][1][3][0]
            lng = parsed[16][0][0][7][1][3][1]
            return (lat, lng)
        except (IndexError, KeyError, json.JSONDecodeError):
            return None
    
    
    def batch_geocode(addresses):
        """Process addresses with random delays to avoid detection."""
        results = {}
        for i, addr in enumerate(addresses):
            coords = geocode_address(addr)
            results[addr] = coords
            print(f"[{i+1}/{len(addresses)}] {addr} -> {coords}")
    
            # Random delay: 3~15 seconds to mimic human behavior
            delay = random.uniform(3, 15)
            time.sleep(delay)
    
        return results
    

    幾個實戰經驗:

    • 隨機延遲是必須的:固定間隔很容易被偵測,3 到 15 秒的隨機延遲更像人類行為。
    • 文件化提取路徑d[16][0][0][7][1][3] 這種路徑完全沒有語意,Google 隨時可能改結構。你必須在程式碼旁邊寫清楚這條路徑代表什麼,否則三個月後你自己也看不懂。
    • 錯誤處理要寬容:有些地址搜不到、有些回傳結構不同,用 try/except 包住並記錄失敗的地址,事後手動補。
    • 這不是長期方案:逆向工程的結果隨時會因為前端改版而失效,只適合一次性或低頻的資料收集。

    最終我用這個方法在一個週末處理完 2600 多筆地址,成本是零。但我也很清楚:如果這是一個需要長期維護的服務,老老實實付 API 費用才是正道。


    3. 架構選型 — 不同系統該用什麼資料庫?

    2021 年我在部落格上寫了一系列「架構師慢慢學」的文章,其中最受歡迎的是資料庫選型。核心觀點只有一句話:資料庫的選擇應該由存取模式驅動,而不是技術潮流。

    太多團隊因為「大家都在用 MongoDB」就把所有東西塞進去,結果需要 JOIN 時痛不欲生。也有人因為「Redis 很快」就把所有資料都放 cache,然後面對一致性問題束手無策。

    系統類型 vs 資料庫選型對照表

    系統類型 建議資料庫 原因
    後台管理系統(Admin) RDBMS(PostgreSQL / SQL Server) 低併發、需要複雜查詢和 JOIN、資料完整性優先
    高流量前台系統 RDBMS 後端 + Redis 前端 RDBMS 保證資料正確,Redis 用 Key/Value 加速讀取
    日誌 / Log 系統 列式儲存(ClickHouse)+ 倒排索引(Elasticsearch) 寫入量大、需要聚合分析和全文搜尋
    交易系統 RDBMS + Cache + 一致性協議 ACID 不可妥協,cache 用於讀加速但需要失效策略
    即時監控系統 時序資料庫(InfluxDB / TimescaleDB) 時間序列寫入優化、自動聚合降精度
    搜尋系統 RDBMS 後端 + Elasticsearch 前端 RDBMS 為資料源,ES 提供倒排索引加速模糊搜尋

    幾個決策原則:

    1. 先問讀寫比例:讀多寫少 → 考慮加 cache;寫多讀少 → 考慮列式儲存或訊息佇列緩衝。
    2. 再問一致性需求:金融交易不能最終一致,社群按讚可以。
    3. 最後問查詢模式:需要 JOIN → RDBMS;需要全文搜尋 → 倒排索引;需要時間範圍聚合 → 時序 DB。

    這不是什麼高深的理論,但我看過太多團隊在第一步就跳過去,直接被「這個技術很紅」帶著走。


    4. JMeter 壓測 — 不壓測的系統都是紙老虎

    你寫的 API 在開發機上跑得飛快,但上線後 100 人同時用就當機了。這種事我見過不止一次。壓力測試不是「有空再做」的事情,它是品質門檻。

    JMeter 基本設定

    Apache JMeter 是免費的壓測工具,核心概念只有三個:

    • Thread Group(執行緒群組):模擬多少使用者同時操作。設定 Number of Threads = 100 就是 100 個並發使用者。
    • Sampler(取樣器):每個使用者要做什麼動作。最常用的是 HTTP Request Sampler,填入 URL、Method、Body 就行。
    • Listener(監聽器):收集結果的報表。Summary Report 給你吞吐量和錯誤率,Aggregate Report 給你百分位數響應時間。

    關鍵指標怎麼看

    指標 意義 健康標準(參考)
    Throughput 每秒處理的請求數 依業務而定,但應隨並發數線性增長直到瓶頸
    P90 Response Time 90% 的請求在此時間內完成 一般 API < 500ms
    P99 Response Time 99% 的請求在此時間內完成 應 < P90 的 3 倍,否則有長尾問題
    Error Rate 失敗請求的百分比 < 0.1% 為優秀,> 1% 要警覺

    常見錯誤

    1. 在同一台機器上跑 JMeter 和被測服務:JMeter 本身也吃 CPU 和記憶體,會互相干擾。壓測機和被測機必須分開。
    2. 沒有暖機(Warm-up):JVM 或 .NET 的 JIT 編譯在前幾次請求時會比較慢,應該先跑一輪不計入結果的請求。
    3. 只看平均值:平均響應時間 200ms 看起來很好,但如果 P99 是 5 秒,代表每 100 個使用者就有 1 個等 5 秒。看百分位數才有意義。
    4. 不模擬真實場景:所有人都打同一個 API endpoint 不代表真實負載。應該混合不同操作的比例。

    我的習慣是:在專案中期就開始跑基準壓測,而不是上線前才慌張地補。早發現瓶頸,修復成本低十倍。


    5. 從 DBA 到架構師 — 我的技術演進路線

    我的技術路線不是一開始就規劃好的,而是一步步堆疊出來的:

    • 2020:SQL Server DBA — 每天看執行計劃、調索引、處理 deadlock。這個階段讓我理解了資料庫內部的儲存引擎、鎖機制、B-Tree 索引結構。
    • 2021:.NET 後端開發 — 開始寫 C# Web API,發現 DBA 背景讓我寫出的 SQL 比大多數工程師都好。但也發現自己在非同步、設計模式上的不足。
    • 2022-2023:全端開發 — 接觸前端、Python、爬蟲、自動化。工具箱從一把螺絲起子變成一整個工具箱。
    • 2024-2026:架構設計 — 開始做系統設計、技術選型、效能規劃。發現以前每個階段的經驗都在這裡匯聚。

    DBA 背景帶給我的不公平優勢

    理解資料庫內部運作,會從根本上改變你寫應用程式的方式:

    • 你知道 SELECT * 在有 covering index 時多浪費多少 I/O,所以你會主動只選需要的欄位。
    • 你知道 NVARCHARVARCHARDATALENGTH() 下的差異,所以你會根據實際資料選擇正確的型別。
    • 你看過太多 table scan 的慘案,所以你設計 API 時會強制分頁,而不是讓使用者一次撈全部。
    • 你理解 transaction isolation level 的差異,所以你知道什麼時候用 READ COMMITTED SNAPSHOT 可以大幅降低鎖爭用。

    給後端工程師的建議

    如果你想往架構方向發展,我的建議是:學任何東西都要動手測試

    • 想搞懂索引?建一個百萬筆的測試表,比較有索引和沒索引的執行計劃。
    • 想搞懂 SemaphoreSlim?寫一個 console app,開 1000 個 task,觀察不同 permit 數量的效果。
    • 想搞懂資料庫選型?不要只讀比較文章,自己用 Docker 裝一個 ClickHouse、一個 PostgreSQL,塞相同的資料,跑相同的查詢,比較速度。

    2021 年我在部落格上寫「架構師慢慢學」系列時,最大的收穫不是寫出來的文章,而是為了寫文章去做的那些實驗。讀十篇文章不如自己跑一次 DATALENGTH() 比較 CHARVARCHAR 的儲存差異。那個數字會刻在你腦子裡,比任何文章都深。


    結語

    後端工程師的價值不在於精通某一個框架或語言,而在於工具箱的廣度和深度。C# 的非同步模式讓你處理高並發,Python 的靈活性讓你快速解決一次性問題,架構選型的思維讓你做出正確的技術決策,壓力測試讓你對系統有信心。

    這些東西沒辦法在一天內學會,但每一個都值得你花時間去實驗。畢竟,不壓測的系統是紙老虎,不動手的學習是紙上談兵

    如果你也是從 DBA 或其他專精領域起步的工程師,不要覺得自己起步晚。每一個階段的深度經驗,都會在你走向架構師的路上成為別人沒有的武器。

  • SQL Server 踩坑實錄:從 DELETE 不釋放空間到 NOT IN 效能炸彈

    SQL Server 踩坑實錄:從 DELETE 不釋放空間到 NOT IN 效能炸彈

    這篇文章是我從 DBA 到全端架構師這幾年,在 SQL Server 效能優化上踩過的坑的總整理。不是教科書式的理論,而是每一條都是我實際測試、實際踩雷後的血淚經驗。如果你正在處理 SQL Server 效能優化的問題——DELETE 後空間沒釋放、查詢莫名其妙變慢、鎖定機制搞不清楚——這篇應該能幫你少走不少冤枉路。

    TL;DR 重點摘要

    • DELETE 不會釋放磁碟空間,只是標記刪除。要真正回收空間,必須用 TRUNCATE 或 ALTER INDEX REBUILD。
    • NOT IN 是效能炸彈,改用 NOT EXISTS 可以讓查詢快數十倍,尤其在子查詢結果集大的時候。
    • 沒有 TABLOCKX 的交易不安全,並行交易會讀到未提交的資料(Dirty Read),高併發場景務必設定正確的隔離層級。
    • 暫存表不是都一樣,@ 表變數、# 本地暫存表、## 全域暫存表各有適用場景,選錯會嚴重影響效能。

    1. 儲存空間的真相 — DELETE 真的刪除了嗎?

    這大概是我當 DBA 第一年最震驚的發現:DELETE 不會釋放磁碟空間。它只是把資料列標記為「ghost record」,等待背景的 Ghost Cleanup 程序來處理。但即使 Ghost Cleanup 跑完了,那些頁面(Page)還是屬於該表的配置空間,不會歸還給作業系統。

    如果你想真正回收空間,只有兩條路:

    • TRUNCATE TABLE:直接釋放所有資料頁面,包含 7-byte 的列標頭(row header),速度極快,但會清除所有資料。
    • ALTER INDEX … REBUILD:重建索引時重新組織頁面,回收碎片化的空間。

    三種配置單元(Allocation Unit)

    SQL Server 在底層把資料分成三種配置單元儲存:

    配置單元 儲存內容 典型欄位類型
    IN_ROW_DATA固定長度 + 行內變動長度資料char, int, datetime, nvarchar(100)
    LOB_DATA大型物件資料nvarchar(max), text, image, xml
    ROW_OVERFLOW_DATA超過 8060 bytes 的變動長度資料nvarchar 超過行內限制時溢出

    CHAR vs VARCHAR 的儲存差異

    很多人以為「反正都是存字串」,但底層差異巨大。CHAR(100) 不管你存 1 個字還是 100 個字,永遠佔用 100 bytes。VARCHAR(100) 則只儲存實際資料長度加上 2 bytes 的長度前綴。

    -- Verify with DATALENGTH()
    DECLARE @fixed CHAR(100) = 'Hello';
    DECLARE @variable VARCHAR(100) = 'Hello';
    
    SELECT DATALENGTH(@fixed) AS CharLength,      -- Result: 100
           DATALENGTH(@variable) AS VarcharLength; -- Result: 5

    另外要注意:索引佔用的是真實空間(IN_ROW_DATA)。當你清空表後,索引也被清空。但只要 INSERT 新資料,索引會立即重新填充。而且 VARCHAR 欄位建索引時,仍然受到 900 bytes 索引鍵大小限制

    Azure SQL Database 的常見假警報

    在 Azure SQL Database 上,大量 DELETE 後看到儲存空間快滿了——這是假警報。空間根本沒被釋放。DELETE ... WITH (TABLOCK) 效果有限,必須搭配 TRUNCATEALTER INDEX ALL ON [TableName] REBUILD 才能真正回收。


    2. 鎖定機制 — 你的交易真的安全嗎?

    我曾經在生產環境遇過一個離奇的 Bug:兩筆交易同時更新同一張表,結果一筆交易讀到了另一筆還沒 COMMIT 的資料。這就是經典的 Dirty Read(髒讀)

    不使用適當鎖定機制時,會碰到三種資料異常:

    異常類型 說明 情境
    Dirty Read(髒讀)讀到其他交易未提交的資料T1 UPDATE 未 COMMIT,T2 SELECT 讀到修改後的值
    Non-repeatable Read(不可重複讀)同一交易內兩次讀取結果不同T1 SELECT → T2 UPDATE COMMIT → T1 再次 SELECT 結果變了
    Phantom Row(幻影列)同一交易內多出新的資料列T1 SELECT → T2 INSERT COMMIT → T1 再次 SELECT 多了一列

    正確的做法:TABLOCKX 排他鎖

    -- Problem: Without TABLOCKX, T2 can read T1's uncommitted changes
    -- Session 1
    BEGIN TRAN T1;
    UPDATE Orders SET Amount = 999 WHERE OrderID = 1;
    -- (not committed yet)
    
    -- Session 2 (runs concurrently, sees Amount = 999 → Dirty Read!)
    SELECT Amount FROM Orders WHERE OrderID = 1;
    
    -- Solution: Use TABLOCKX for exclusive access
    BEGIN TRAN T1;
    SELECT * FROM Orders WITH (TABLOCKX) WHERE OrderID = 1;
    -- Now T2 is BLOCKED until T1 commits or rolls back
    UPDATE Orders SET Amount = 999 WHERE OrderID = 1;
    COMMIT TRAN T1;

    在高併發場景中,如果不想鎖整張表,也可以考慮設定交易隔離層級為 SERIALIZABLE 或使用 ROWLOCK, UPDLOCK 組合,但 TABLOCKX 是最簡單粗暴且確定有效的方式。


    3. 查詢優化 — EXISTS vs IN 的效能陷阱

    這個坑我踩了不止一次。先講結論:

    • 正向查詢(EXISTS vs IN):執行計畫幾乎相同,效能差異不大。
    • 否定查詢(NOT EXISTS vs NOT IN)NOT EXISTS 遠遠快於 NOT IN,差距可達數十倍。
    -- NOT IN: Slow — performs O(n*m) comparison, NULL handling issues
    SELECT * FROM Products
    WHERE ProductID NOT IN (
        SELECT ProductID FROM OrderDetails
    );
    
    -- NOT EXISTS: Fast — uses semi-join, stops at first match
    SELECT * FROM Products p
    WHERE NOT EXISTS (
        SELECT 1 FROM OrderDetails od
        WHERE od.ProductID = p.ProductID
    );
    
    -- Additional trap: if OrderDetails.ProductID contains ANY NULL value,
    -- NOT IN returns ZERO rows! NOT EXISTS handles NULL correctly.

    NOT IN 之所以慢,是因為它必須對子查詢的每一筆結果做比對,而且還要處理 NULL 的三值邏輯。NOT EXISTS 則是用半連接(Semi-Join)策略,找到第一筆匹配就停止。

    排序與 TOP 的隱藏陷阱

    加上 TOP 之後,SQL Server 的排序演算法會完全改變。沒有 TOP 時用完整排序(Full Sort),有 TOP 時用 Top-N Sort,記憶體需求和執行路徑完全不同。

    SQL 執行順序(必背)

    很多查詢優化的問題,根源是不理解 SQL 的實際執行順序:

    FROM → JOIN → WHERE → GROUP BY → HAVING → SELECT → DISTINCT → ORDER BY → TOP/OFFSET

    注意 SELECT 在 WHERE 之後,所以你不能在 WHERE 中使用 SELECT 裡定義的別名。而 ORDER BY 在 SELECT 之後,所以可以用別名排序。理解這個順序,很多「為什麼這樣寫不行」的問題都迎刃而解。

    另外,索引不只消除全表掃描,還能跳過排序階段。如果 ORDER BY 的欄位剛好有索引,SQL Server 可以直接按索引順序讀取,省掉排序的 CPU 和記憶體開銷。


    4. 全文檢索 — 比 LIKE ‘%keyword%’ 快一百倍

    如果你的應用有「搜尋文章內容」的需求,還在用 LIKE '%keyword%',那你的查詢基本上每次都是全表掃描。全文檢索(Full-Text Search)透過反向索引(Inverted Index)來加速文字搜尋,效能差距是數量級的。

    建立全文檢索的前提與步驟

    前提:目標表必須有主鍵(Primary Key)。因為反向索引需要唯一識別碼來對應每筆資料。

    -- Step 1: Enable full-text search on the database (if not already)
    -- (SQL Server installs Full-Text Search as a feature)
    
    -- Step 2: Create a full-text catalog
    CREATE FULLTEXT CATALOG ftCatalog AS DEFAULT;
    
    -- Step 3: Create a full-text index on the table
    -- The table MUST have a primary key
    CREATE FULLTEXT INDEX ON Articles (
        Title LANGUAGE 1028,      -- 1028 = Traditional Chinese
        Content LANGUAGE 1028
    )
    KEY INDEX PK_Articles          -- Must reference the PK
    ON ftCatalog
    WITH CHANGE_TRACKING AUTO;     -- Auto-update when data changes
    
    -- Step 4: Query using CONTAINS or FREETEXT
    SELECT * FROM Articles
    WHERE CONTAINS(Content, N'效能優化');
    
    -- Compare with LIKE (full table scan every time)
    SELECT * FROM Articles
    WHERE Content LIKE N'%效能優化%';

    語言設定很重要:LANGUAGE 1028(繁體中文)會使用對應的斷詞器(Word Breaker),直接影響搜尋品質。英文斷詞用空格就行,但中文斷詞需要語意分析,設錯語言會導致搜不到結果。


    5. 監控與追蹤 — 沒有 Profiler 怎麼辦?

    SQL Server Profiler 在生產環境不一定能用(效能開銷太大,或者根本沒權限)。這時候 DMV(Dynamic Management Views)就是你的救星。

    追蹤特定時間範圍的查詢

    -- Find top queries by CPU time within a time range
    SELECT TOP 20
        qs.last_execution_time,
        qs.execution_count,
        qs.total_worker_time / 1000 AS total_cpu_ms,
        qs.total_elapsed_time / 1000 AS total_elapsed_ms,
        qs.total_logical_reads,
        SUBSTRING(st.text,
            (qs.statement_start_offset / 2) + 1,
            ((CASE qs.statement_end_offset
                WHEN -1 THEN DATALENGTH(st.text)
                ELSE qs.statement_end_offset
              END - qs.statement_start_offset) / 2) + 1
        ) AS query_text
    FROM sys.dm_exec_query_stats qs
    CROSS APPLY sys.dm_exec_sql_text(qs.sql_handle) st
    WHERE qs.last_execution_time >= '2026-04-04 09:00:00'
      AND qs.last_execution_time <= '2026-04-04 18:00:00'
    ORDER BY qs.total_worker_time DESC;

    查看當前執行中的程序

    -- Quick check: who's running what right now?
    EXEC sp_who2;
    
    -- Or with more detail via DMV
    SELECT
        r.session_id,
        r.status,
        r.command,
        r.wait_type,
        r.wait_time,
        t.text AS query_text,
        r.cpu_time,
        r.reads,
        r.writes
    FROM sys.dm_exec_requests r
    CROSS APPLY sys.dm_exec_sql_text(r.sql_handle) t
    WHERE r.session_id > 50; -- Exclude system sessions

    全庫儲存空間盤點

    -- Iterate all user tables and check space usage
    CREATE TABLE #SpaceUsed (
        TableName NVARCHAR(128),
        Rows NVARCHAR(20),
        Reserved NVARCHAR(20),
        Data NVARCHAR(20),
        IndexSize NVARCHAR(20),
        Unused NVARCHAR(20)
    );
    
    DECLARE @tbl NVARCHAR(128);
    DECLARE tbl_cursor CURSOR FOR
        SELECT TABLE_SCHEMA + '.' + TABLE_NAME
        FROM INFORMATION_SCHEMA.TABLES
        WHERE TABLE_TYPE = 'BASE TABLE';
    
    OPEN tbl_cursor;
    FETCH NEXT FROM tbl_cursor INTO @tbl;
    
    WHILE @@FETCH_STATUS = 0
    BEGIN
        INSERT INTO #SpaceUsed
        EXEC sp_spaceused @tbl;
        FETCH NEXT FROM tbl_cursor INTO @tbl;
    END
    
    CLOSE tbl_cursor;
    DEALLOCATE tbl_cursor;
    
    SELECT * FROM #SpaceUsed ORDER BY CAST(REPLACE(Reserved, ' KB', '') AS BIGINT) DESC;
    DROP TABLE #SpaceUsed;

    6. 暫存表大全 — @、#、## 到底差在哪?

    SQL Server 有三種暫存表,看起來差一個符號,但行為天差地別:

    特性 @TableVar(表變數) #TempTable(本地暫存表) ##GlobalTemp(全域暫存表)
    儲存位置記憶體(小量時)/ tempdbtempdbtempdb
    統計資訊無(優化器假設 1 列)
    作用範圍當前批次/程序當前 Session所有 Session
    交易回滾不受 ROLLBACK 影響受 ROLLBACK 影響受 ROLLBACK 影響
    可建索引僅限宣告時的約束可隨時建立可隨時建立
    適用場景少量資料(< 100 列)大量資料、需要索引跨 Session 共享資料

    選擇指南

    • 資料量 < 100 列,且不需要索引 → 用 @TableVar
    • 資料量大,需要統計資訊讓優化器做正確決策 → 用 #TempTable
    • 需要跨 Session 共享(例如 ETL 中間結果) → 用 ##GlobalTemp(但要小心生命週期管理)
    • 在 ROLLBACK 時需要保留資料(例如錯誤日誌) → 用 @TableVar,因為它不受交易回滾影響
    -- Table variable: optimizer always estimates 1 row
    DECLARE @small TABLE (ID INT, Name NVARCHAR(50));
    INSERT INTO @small SELECT TOP 10 ID, Name FROM Products;
    
    -- Local temp table: has statistics, better for large datasets
    CREATE TABLE #bigtemp (ID INT, Name NVARCHAR(50));
    INSERT INTO #bigtemp SELECT ID, Name FROM Products;
    CREATE INDEX IX_bigtemp_ID ON #bigtemp(ID); -- Can add indexes
    
    -- Global temp table: visible to all sessions
    CREATE TABLE ##shared (ID INT, Name NVARCHAR(50));
    -- Other sessions can SELECT from ##shared

    最常見的錯誤是:把幾萬筆資料塞進 @TableVar,然後納悶為什麼 JOIN 超慢。原因是優化器認為裡面只有 1 列,選了 Nested Loop 而不是 Hash Join。換成 #TempTable 就正常了。


    結語

    SQL Server 的這些坑,有的文件上有寫但沒人看,有的要自己測過才會懂。我把這幾年的經驗整理在這裡,希望能幫到正在跟 SQL Server 搏鬥的你。如果只能記住一件事,請記住:NOT IN 是效能炸彈,永遠用 NOT EXISTS 取代它。這一個改動可能就能讓你的查詢從分鐘級變成秒級。


    常見問題 FAQ

    Q: DELETE 後空間沒有減少,是 Bug 嗎?

    不是 Bug,這是 SQL Server 的設計。DELETE 只標記刪除,頁面仍歸屬於表。使用 TRUNCATE TABLE 或 ALTER INDEX REBUILD 來真正回收空間。

    Q: NOT IN 和 NOT EXISTS 結果一樣嗎?

    不一定。如果子查詢包含 NULL 值,NOT IN 會返回空結果集(因為 NULL 的比較結果是 UNKNOWN)。NOT EXISTS 則能正確處理 NULL。除了效能差異,正確性也是選擇 NOT EXISTS 的原因。

    Q: 什麼時候該用表變數 @,什麼時候用暫存表 #?

    簡單判斷:資料量少於 100 列用 @,超過就用 #。關鍵差異在於統計資訊——表變數沒有統計資訊,優化器會做出錯誤的執行計畫。

    Q: 全文檢索和 LIKE 差多少?

    在百萬筆資料的文字欄位上,全文檢索可以比 LIKE '%keyword%' 快 100 倍以上。LIKE 前綴帶 % 時無法使用索引,只能全表掃描;全文檢索則使用反向索引,直接定位包含關鍵字的列。

    Q: 生產環境不能用 SQL Profiler 該怎麼監控?

    使用 DMV(動態管理檢視):sys.dm_exec_query_stats 搭配 sys.dm_exec_sql_text 可以按時間範圍追蹤查詢,sys.dm_exec_requests 可以看當前正在執行的查詢,效能衝擊遠小於 Profiler。

  • 工程師做完專案就丟上 GitHub?你少做了這些事

    身為一個寫 code 的人,我以前的工作流程大概是這樣:

    1. 有個想法
    2. 熬夜把它做出來
    3. git push origin main
    4. 收工,去睡覺

    然後呢?然後就沒有然後了。

    專案靜靜地躺在 GitHub 上,星星數停在個位數(其中兩個是我自己的帳號和我女朋友被我拜託按的),偶爾有個路過的陌生人開了個 issue 問「這還有在維護嗎?」——沒有,但我不好意思說。

    直到最近我做了一個小專案,花了一些時間研究「做完之後該做什麼」,才發現原來我們工程師漏掉的東西,比寫的 code 還多。


    META Tags 不是裝飾品

    先來個靈魂拷問:你的 index.html<head> 裡面有什麼?

    我猜大概是這樣:

    <head>
      <meta charset="UTF-8">
      <title>My Cool Project</title>
    </head>
    

    恭喜,你的網站在搜尋引擎眼中跟一張白紙差不多。

    Google 爬蟲來到你的頁面,看到一個 title,然後……就沒了。它不知道你這個頁面在幹嘛、給誰用、解決什麼問題。它只好自己猜,而搜尋引擎猜東西的能力,大概跟我猜女朋友今天為什麼不開心一樣爛。

    最低限度,你應該加上這些:

    <head>
      <meta charset="UTF-8">
      <meta name="viewport" content="width=device-width, initial-scale=1.0">
      <title>你的專案名稱 — 一句話說明它是什麼</title>
      <meta name="description" content="用 50-160 字描述你的專案做什麼、給誰用">
      <meta name="keywords" content="關鍵字1, 關鍵字2, 關鍵字3">
    
      <!-- Open Graph:社群分享預覽 -->
      <meta property="og:title" content="專案名稱">
      <meta property="og:description" content="專案描述">
      <meta property="og:image" content="https://your-username.github.io/your-repo/preview.png">
      <meta property="og:url" content="https://your-username.github.io/your-repo/">
      <meta property="og:type" content="website">
    
      <!-- Schema.org JSON-LD:結構化資料 -->
      <script type="application/ld+json">
      {
        "@context": "https://schema.org",
        "@type": "WebApplication",
        "name": "你的專案名稱",
        "description": "專案描述",
        "url": "https://your-username.github.io/your-repo/",
        "author": {
          "@type": "Person",
          "name": "Your Name"
        },
        "applicationCategory": "UtilityApplication",
        "operatingSystem": "Web Browser"
      }
      </script>
    </head>
    

    我知道你在想什麼:「這也太多了吧,我只是做個 side project 耶。」

    對,我也這樣想過。但你花了 40 小時寫 code,多花 20 分鐘把 meta tags 補齊,投報率其實很高。


    SEO 和 AEO 的差別

    大家都聽過 SEO(Search Engine Optimization),就是讓 Google 找到你的東西。但 2025 年以後,有另一個東西叫 AEO —— Answer Engine Optimization。

    差別在哪?

    • SEO 是讓使用者搜尋「台灣失智症照護工具」的時候,你的網站出現在搜尋結果裡。
    • AEO 是讓使用者問 ChatGPT 或 Perplexity「有沒有推薦的失智症照護互動工具?」的時候,AI 直接把你的專案資訊抽出來回答。

    關鍵差異:傳統 SEO 靠的是關鍵字密度、反向連結、網站權重這些。AEO 靠的是結構化資料

    上面那段 Schema.org JSON-LD 就是結構化資料。它用一種機器能直接理解的格式,告訴 AI「這個網站是什麼類型、做什麼用、誰做的」。AI 搜尋引擎不需要去「理解」你的網頁內容,它直接讀這段結構化的 JSON 就好。

    這就像是你寫了一份完美的文件,但沒寫 API 文件一樣。人類看得懂,但機器不知道怎麼呼叫你。Schema.org 就是你給搜尋引擎寫的 API 文件。


    GitHub Topics 是免費的曝光

    這個我真的覺得很虧,因為我用了 GitHub 這麼久,從來沒認真設定過。

    你的 repo 頁面右上角有個 About 區塊,裡面可以寫 description 和加 topics。Topics 就像是 hashtag,GitHub 有專門的 topic 搜尋頁面,使用者可以透過 topic 找到相關專案。

    你最多可以加 20 個 topics。免費的曝光,不用白不用。

    用 CLI 設定很快:

    # 設定 repo description
    gh repo edit your-username/your-repo --description "你的專案一句話描述"
    
    # 加上 topics(注意:GitHub Topics 只支援英文小寫)
    gh repo edit your-username/your-repo --add-topic "dementia-care,elderly-care,cognitive-training,taiwan,web-app,html,javascript,open-source,healthcare,accessibility"
    

    重點提醒:GitHub Topics 只支援英文。所以就算你的專案是中文的,topics 也要用英文寫。想想你的目標受眾會用什麼英文關鍵字搜尋,就加什麼。


    GitHub Pages 等於免費網站

    如果你的 repo 裡有 index.html,恭喜你,你離擁有一個免費網站只差兩個步驟:

    1. 去 repo 的 Settings > Pages
    2. Source 選 main branch,資料夾選 / (root)
    3. 按 Save

    完成。你的網站就是 https://your-username.github.io/your-repo/

    每次你 git push,GitHub Actions 會自動幫你部署。不用買主機、不用設定 DNS、不用搞 nginx 設定檔、不用 Docker。零成本。

    更重要的是:你前面寫的那些 meta tags 和 Schema.org 結構化資料,只有在一個可以被公開訪問的網站上才有意義。 GitHub repo 頁面不會被 Google 當成你的「網站」來索引那些 meta tags。開了 GitHub Pages,你的 SEO 和 AEO 才算正式上線。


    Google Search Console — 主動告訴 Google 你存在

    很多人以為把網站放上去,Google 自然就會找到你。

    理論上是的。實際上,一個沒有任何外部連結指向的小網站,Google 爬蟲可能好幾個月都不會路過。你的專案就這樣安安靜靜地存在於網路上,像深山裡的一間便利商店,開著燈但沒有路。

    解法很簡單:去 Google Search Console 主動提交。

    驗證方式最簡單的是 meta tag 驗證——Google 給你一段 meta tag,你貼到 index.html<head> 裡:

    <meta name="google-site-verification" content="你的驗證碼">
    

    然後在 Search Console 的「網址審查」功能裡,貼上你的 GitHub Pages URL,按「要求建立索引」。

    我的經驗是提交後大概 2-3 天就會被 Google 索引。比起被動等待可能要等幾個月,這個 ROI 非常高。整個流程大概 10 分鐘。


    打賞和贊助機制

    「我做的是免費開源專案耶,談錢太俗了吧。」

    我以前也這樣想。但後來我發現:願意付費支持你的人,跟你收不收費是兩回事。有些人就是覺得你做的東西有價值,想請你喝杯咖啡。你不給他管道,他想付都付不了。

    幾個選項,各有優缺點:

    Ko-fi — 國際通用的打賞平台,介面很乾淨。但台灣收款要透過 PayPal 或 Stripe,PayPal 的手續費偏高,Stripe 台灣的個人帳號支援也有限制。適合有國際受眾的專案。

    綠界 ECPay — 台灣最方便的選擇,支援信用卡、ATM 轉帳、超商繳費,對台灣使用者來說付款門檻最低。缺點是設定流程比較繁瑣,可能需要聯繫客服才能搞定。但搞定之後就很順了。

    銀行轉帳 QR Code — 最簡單直接的方式。產生你的銀行帳號 QR code,使用者用手機銀行掃一下就能轉帳。零手續費、零平台抽成。缺點是沒有平台幫你追蹤誰贊助了多少。

    GitHub Sponsors — 在 repo 根目錄放一個 .github/FUNDING.yml,你的 repo 頁面就會自動出現一個 Sponsor 按鈕:

    # .github/FUNDING.yml
    github: your-username
    ko_fi: your-kofi-username
    custom:
      - https://your-payment-link.example.com
    

    這個檔案的設定非常簡單,但效果很好——那個 Sponsor 按鈕就放在 repo 頁面最顯眼的位置,每個路過的人都看得到。

    重點是:你不需要只選一個。 你可以同時放 Ko-fi 給國際用戶、綠界給台灣用戶、銀行轉帳給懶得註冊任何平台的人。多一個管道就多一個機會。


    README 是你的門面

    工程師寫 README 通常是這樣:

    # My Project
    
    ## Installation
    npm install
    
    ## Usage
    npm start
    

    然後就沒了。

    拜託,你的 README 是大多數人對你專案的第一印象(也可能是最後一印象)。它不只是技術文件,它是你的故事。

    一個好的 README 應該包含:

    1. 為什麼做這個 — 你遇到了什麼問題?什麼契機讓你動手做?這個故事比你想像的重要一百倍。「我阿嬤確診失智症,我想做一個讓她可以動動腦的小工具」比「這是一個認知訓練 Web App」有感染力多了。
    2. 這是什麼、給誰用 — 用一般人聽得懂的話說明。
    3. 怎麼用 — 截圖、GIF、或是 live demo 連結。
    4. 技術細節 — 用了什麼技術、架構是什麼(這部分寫給工程師看的)。
    5. 如何支持 — 打賞連結、或是告訴別人怎麼 contribute。

    真實的故事比任何行銷文案都有效。人們不只是在用你的工具,他們是在參與你的故事。


    Social Preview 和 OG Tags

    最後一個,也是最容易被忽略的:分享預覽

    當你把 repo 連結或網站連結貼到 LINE 群組、Facebook、Twitter 的時候,會出現什麼?

    如果你什麼都沒設定,就是一個光禿禿的網址。沒有預覽圖、沒有描述、沒有標題。在訊息流裡面,它跟垃圾連結看起來一模一樣。

    如果你有設定 OG tags(前面 meta tags 那段已經教過了)加上一張好看的預覽圖,分享出去就會有標題、描述、還有圖片。在 LINE 群組裡點擊率差個三五倍很正常。

    GitHub repo 本身也可以設定 Social Preview:去 repo 的 Settings > Social Preview,上傳一張 1280×640 的圖。這樣別人在社群分享你的 repo 連結時,就會顯示這張圖。

    你可以用 Canva、Figma 之類的工具花 5 分鐘做一張。不需要多精美,有總比沒有好太多了。


    結論

    回顧一下,做完 side project 之後你應該做的事:

    1. 把 meta tags 補齊(description、OG tags、Schema.org JSON-LD)
    2. 開 GitHub Pages,讓你的專案有一個公開網址
    3. 去 Google Search Console 提交你的網址
    4. 設定 GitHub Topics 和 About description
    5. 放上打賞/贊助連結
    6. 好好寫你的 README,說你的故事
    7. 設定 Social Preview,讓分享出去有個樣子

    這些事情全部加起來,大概花你一到兩個小時。

    你已經花了幾十個小時甚至幾百個小時寫 code,多花兩個小時讓它被看見,很值得。

    我以前一直覺得「好的東西自然會被發現」。但事實是,網路上好的東西太多了,大部分都沒被發現。被發現的那些,不一定是最好的,但一定是最容易被找到的。

    我們工程師很擅長解決技術問題,但不太擅長「讓別人知道我們解決了什麼問題」。

    這篇文章就是我學到這件事之後,寫給跟我一樣的人的。

    希望你的下一個 side project,不再只是 GitHub 上的一個小點。

  • iDempiere Plugin 開發完整指南:踩遍台灣統一發票的 10 個坑

    重點摘要

    • 我們用兩天為 iDempiere 12.0 從零開發了台灣統一發票 OSGi Plugin,踩了至少 7 個主要的坑
    • 最燒時間的 bug:SeqNoGrid 缺失導致 Grid View 在按「新增」時拋出 IndexOutOfBoundsException——官方文件完全沒提
    • EventHandler 模式是 iDempiere 12 的正確驗證方式,ModelValidator 不透過 OSGi DS 登錄根本不執行
    • 2Pack ZIP 結構、事件主題比較、雙 JVM 部署問題——每一個都能讓你白白浪費半天

    這篇文章記錄了我們為 iDempiere 12.0 從零開發台灣統一發票(統一發票)與營業稅申報 Plugin 的完整過程。如果你正在開發 iDempiere Plugin,這篇文章能幫你少掉至少一天的除錯時間。

    為什麼要做這個 Plugin?

    台灣的統一發票制度獨特而嚴格:每兩個月一期的雙月申報週期、財政部核配的字軌號碼(如 AA01234567)、三聯式(B2B)和二聯式(B2C)的不同計稅方式、以及嚴格的 FLOOR 取捨規定。

    這些都是 iDempiere 標準功能完全沒有覆蓋的。既有的 C_Invoice 系統不知道什麼是「字軌」,不知道進項折讓要在哪一期申報,更不知道 401 申報表長什麼樣子。所以我們做了這個 Plugin。

    系統架構概覽:四張表對應四個階段

    iDempiere Plugin 開發的核心是理清業務模型。台灣統一發票有清楚的生命週期,我們用四張資料表對應:

    財政部核配字軌
          │
          ▼
    TW_InvoicePrefix      ← 字軌管理(AA、AB 等,號碼範圍、有效期)
          │ 開立發票時
          ▼
    TW_Invoice_Prefix_Map ← 每張發票的字軌號碼對應(含買方統一編號)
          │ 如有退貨/折讓
          ▼
    TW_InvoiceAdjustment  ← 銷項/進項折讓(方向、期別、超期申報)
          │ 期末
          ▼
    TW_TaxStatement       ← 401 申報表(銷項稅、進項稅、留抵、應納稅額)

    技術層面:OSGi bundle(Equinox),2Pack 管理 dictionary,AbstractEventHandler 做 PO 事件驗證,服務層純 Java 方便單元測試。最終成品:87 個測試全部通過,4 張 TW_* 資料表,4 個 iDempiere 視窗。

    把台灣稅法翻成 Java 程式碼

    稅額計算:FLOOR,不是 ROUND

    這是財政部的明確規定,一律捨去,不四捨五入。聽起來簡單,但在邊界值差一塊錢,申報出去就是對不上帳:

    // 二聯式(B2C):含稅金額已知,反推銷售額和稅額
    BigDecimal saleAmount = grossAmount
        .divide(new BigDecimal("1.05"), 0, RoundingMode.FLOOR);
    BigDecimal taxAmount = saleAmount
        .multiply(new BigDecimal("0.05"))
        .setScale(0, RoundingMode.FLOOR);
    
    // 注意:taxAmount ≠ grossAmount - saleAmount
    // 財政部規定:用前者(先算銷售額,再乘 5%)

    字軌狀態機:單向前進

    字軌狀態只能往前走,不能回頭:I(未啟用)→ A(使用中)→ C(已用完)。這是台灣稅法要求,已啟用的字軌必須被追蹤,不能撤回。

    // EventHandler 在 PO_BEFORE_CHANGE 攔截
    if ("A".equals(oldStatus) && "I".equals(newStatus))
        throw new AdempiereException("使用中字軌不可降回未啟用(台灣稅法)");
    if ("C".equals(oldStatus))
        throw new AdempiereException("已用完字軌不可再變更狀態");

    雙月申報期別計算

    // 從發票月份算期別
    int period = (month - 1) / 2 + 1;  // 1=1-2月, 2=3-4月 ... 6=11-12月

    七個真實踩坑紀錄

    坑 1:事件主題比較,一個字毀掉一切

    這個 bug 讓狀態驗證完全靜默失效了很久。症狀是:程式碼看起來完全正確,但驗證從來不觸發。

    // 錯誤 — 永遠不會觸發
    if (topic.endsWith("po_before_change")) { ... }
    
    // 正確
    if (IEventTopics.PO_BEFORE_CHANGE.equals(topic)) { ... }

    iDempiere 的 topic 格式是 org/adempiere/po/PO_BEFORE_CHANGE(全大寫),endsWith 配對小寫後綴當然不匹配。靜默失效最可怕——不報錯,只是所有驗證都沒執行。規則:事件主題永遠用 IEventTopics 常數。

    坑 2:ModelValidator 是個陷阱

    Validator 類別一開始實作了完整的 ModelValidator 介面(initialize、modelChange、docValidate、login…),程式碼寫得很整齊,但驗證從來不執行。

    原因:ModelValidator 需要透過 ModelValidationEngine.addModelValidator() 主動登錄。單純 implements ModelValidator + @Component 什麼都不會發生。

    正確的 iDempiere 12 Plugin 驗證模式:

    // *Validator.java    → 純靜態方法,不實作任何介面
    // *EventHandler.java → extends AbstractEventHandler,OSGI-INF/*.xml 登錄為 DS 服務
    
    // EventHandler 捕捉 OSGi 事件,呼叫 Validator 的靜態方法做驗證
    @Component(immediate = true, service = IEventHandler.class)
    public class InvoicePrefixEventHandler extends AbstractEventHandler {
        @Override
        protected void doHandleEvent(Event event) {
            String topic = (String) event.getProperty(IEventTopics.EVENT_TOPIC);
            if (IEventTopics.PO_BEFORE_CHANGE.equals(topic)) {
                String err = InvoicePrefixValidator.validateStatusTransition(...);
                if (err != null) throw new AdempiereException(err);
            }
        }
    }

    坑 3:2Pack ZIP 打包方式,犯了兩次

    iDempiere 的 PackIn 解壓 ZIP 到 /tmp/,預期路徑是 /tmp/tw_invoice_system/dict/PackOut.xml

    第一次:ZIP 裡多了 2pack/ 前綴層。第二次:用了 zip -j(junk paths),把所有目錄剝掉,路徑變成 /tmp/PackOut.xml/dict/PackOut.xml——把文件名當目錄了。

    # 正確打包方式
    mkdir -p /tmp/b/tw_invoice_system/dict
    cp PackOut.xml /tmp/b/tw_invoice_system/dict/
    cd /tmp/b && zip -r 2Pack_1.0.10.zip tw_invoice_system/
    
    # 永遠要驗證結構
    unzip -l 2Pack_1.0.10.zip

    坑 4:SeqNoGrid 缺失 → Grid View 崩潰(最燒時間)

    這是整個過程中最「無辜」的 bug——不是邏輯錯誤,是 XML 少了兩個欄位。所有 73 個 AD_Field 元素都缺少 <SeqNoGrid> 和正確的 <IsDisplayedGrid>

    iDempiere 12 的 Grid View 渲染器在初始化行編輯器時需要 SeqNoGrid 做排序依據,全部 NULL 導致:

    java.lang.IndexOutOfBoundsException: Index: 2
        at GridTabRowRenderer.editCurrentRow

    任何視窗,只要在 Grid 模式下按「新增」,必爆。這個 bug 在官方文件裡完全沒有提到。修復:補上這兩個欄位。

    <SeqNo>10</SeqNo>
    <SeqNoGrid>10</SeqNoGrid>        <!-- = SeqNo,顯示欄位 -->
    <IsDisplayedGrid>Y</IsDisplayedGrid>
    
    <!-- 隱藏欄位(SeqNo=0)-->
    <SeqNoGrid>0</SeqNoGrid>
    <IsDisplayedGrid>N</IsDisplayedGrid>

    坑 5:兩個 JVM 搶 Port,Deploy 進錯的那個

    症狀很奇怪:OSGi telnet console 顯示 bundle ACTIVE ✅,但 Web Console 找不到這個 bundle ❌。

    最後發現機器上跑著兩個 iDempiere JVM:

    JVM 擁有 Port 說明
    JVM-A(舊的)8080/8443Web 瀏覽器連這個
    JVM-B(新的)12612OSGi telnet 連這個

    deploy.sh 透過 telnet 把 bundle 裝進了 JVM-B,但使用者看的 Web Console 是 JVM-A。原因是 idempiere-server.sh 有 restart loop,systemctl restart 啟動了新 JVM,但舊 JVM 沒死。

    # 診斷方法
    ps aux | grep java | grep -v grep | wc -l  # > 1 就是這個問題
    
    # 修復:kill 兩個 JVM,等 30 秒讓 port 釋放,再 restart
    sudo kill <pid1> <pid2>
    sleep 30
    sudo systemctl restart idempiere

    坑 6:AD_Field UUID 衝突

    2Pack 重裝時,iDempiere 已為新建的 Tab 自動插入標準欄位(AD_Client_ID、AD_Org_ID、IsActive)。當 PackIn 再次嘗試用不同 UUID 插入同一個 (tab_id, column_id) 組合時,違反了 UNIQUE(ad_tab_id, ad_column_id) 約束,拋出 POSaveFailedException

    解法:對這類「系統可能已存在」的標準欄位,PackOut.xml 使用固定的 placeholder UUID。PackIn 遇到重複就 UPDATE 而不是 INSERT。升版 UUID 策略:已存在的 field → 保留原 UUID;新增的 field → 才用新的 uuid4。不要為了「整齊」換掉既有 UUID。

    坑 7:清除 DB 做全新安裝——FK 刪除順序

    當要做「完整卸載 → 清 DB → 重裝」的驗證時,刪資料的順序錯了好幾次。

    正確順序:AD_Field → AD_Tab → AD_Window,每一步都有 FK 指向下一個。特別注意:AD_PreferenceAD_Menu 也會 FK 到 AD_Window,忘記刪這兩個就卡住。另外:ad_package_imp 記錄了 2Pack 安裝歷史,不清掉的話 Incremental2PackActivator 判定「已安裝過同版本」就跳過不執行。

    如果重來一次,我們會怎麼做

    1. 先建立 PackOut.xml 驗證腳本

    每次 2Pack 安裝後自動跑這些 SQL,出問題立刻知道,不用等到 UI 爆炸:

    -- SeqNoGrid 是否設定
    SELECT tablename, count(*) FILTER (WHERE seqnogrid > 0) ok
    FROM ad_table JOIN ad_tab ... JOIN ad_field ...
    WHERE tablename LIKE 'TW_%' GROUP BY tablename;
    
    -- _UU 欄位是否 updateable
    SELECT columnname, isupdateable FROM ad_column
    WHERE tablename LIKE 'TW_%' AND columnname LIKE '%_UU';

    2. 把 ZIP 結構驗證寫進 Maven build

    <plugin>
      <groupId>org.codehaus.mojo</groupId>
      <artifactId>exec-maven-plugin</artifactId>
      <executions>
        <execution>
          <phase>verify</phase>
          <goals><goal>exec</goal></goals>
          <configuration>
            <executable>bash</executable>
            <arguments>
              <argument>-c</argument>
              <argument>unzip -l resources/META-INF/2Pack_*.zip | grep -q "dict/PackOut.xml"</argument>
            </arguments>
          </configuration>
        </execution>
      </executions>
    </plugin>

    3. 每次 commit 前跑 deploy.sh –check

    加一個 dry-run 模式,只驗證 JAR 可部署、OSGi console 可連線、bundle 存在,不實際更新。讓這個檢查成為 commit hook。

    給下一個要做 iDempiere Plugin 的人

    iDempiere 的文件很少,很多行為只有讀原始碼才能理解。以下是花最多時間搞懂的六件事:

    # 規則 說明
    1ModelValidator 不是 OSGi 服務@Component 不會讓它跑起來,要用 EventHandler
    2SeqNoGrid 是 Grid View 必備欄位缺了不報錯,只在按「新增」時崩潰
    32Pack ZIP 結構有嚴格要求打包後一定要 unzip -l 驗證,絕不用 zip -j
    4_UU 欄位必須 IsUpdateable=Y否則 UUID 永遠 NULL
    5IEventTopics 常數不要用字串字面量比較 topic,靜默失效
    6Incremental2PackActivator 記住安裝歷史同版本不重裝,升版要改 ZIP 檔名

    後記:實作兩個流程(又踩了三個坑)

    文章發完當天,隨即著手實作原本標注為「計劃中功能」的兩支 SvrProcess

    • GenerateTaxStatementProcess — 聚合 TW_Invoice_Prefix_Map 的銷售資料、折讓,產生 TW_TaxStatement 申報記錄
    • ExportTaxReportProcess — 讀取 TW_TaxStatement,輸出財政部格式 CSV

    同時也需要把這兩個流程透過 2Pack 登錄到 iDempiere 的 AD_Process / AD_Menu,讓使用者可以從選單觸發。這一輪又多踩了幾個坑。

    坑 8:AD_Process_Para 的 AD_Process_ID 必須明確寫入

    2Pack 的元素處理器(ElementHandler)有一個隱藏的不一致性

    AD_Tab 時,把它放在 <AD_Window> 元素內,Tab 的 AD_Window_ID 會自動繼承父元素——不需要重複宣告。大多數巢狀元素都這樣工作。

    AD_Process_Para 不同。ProcessParaElementHandler 呼叫 filler.autoFill() 處理子元素,但不從父 <AD_Process> 讀取 context 填入 AD_Process_ID

    結果:2Pack 安裝過程看起來正常執行,沒有任何錯誤訊息,但 Process Para 根本沒有存入。直到手動查 DB 才發現空的。真正的錯誤需要翻 PostgreSQL log:

    tail -f /var/log/postgresql/postgresql-16-main.log
    # ERROR: null value in column "ad_process_id" violates not-null constraint

    修正:每個 <AD_Process_Para> 元素內都必須顯式宣告 AD_Process_ID

    <AD_Process_Para type="table">
      <AD_Process_ID reference="uuid" reference-key="AD_Process">{process-uuid}</AD_Process_ID>
      <Name>Statement Year</Name>
      ...
    </AD_Process_Para>

    坑 9:FieldLength NOT NULL(但 iDempiere log 不說)

    修好 AD_Process_ID 之後,再次安裝,再次失敗,再次查 PostgreSQL log:

    ERROR: null value in column "fieldlength" violates not-null constraint

    FieldLengthad_process_para 資料表中是 NOT NULL 欄位,但如果 PackOut.xml 沒有提供,iDempiere 的 log 只會說 Failed to save ProcessPara——沒有欄位名稱,沒有 SQL,什麼都沒有。

    不同 Reference 型別的預設長度:

    AD_Reference_ID 型別 FieldLength
    11Integer10
    17List1
    10String實際最大長度

    教訓:2Pack 的錯誤訊息有時候刻意模糊。遇到 Failed to save 之類的通用錯誤,直接去查 PostgreSQL log,那裡才有真相。

    坑 10:iDempiere 物理表在 adempiere schema,不在 public

    寫完 clean_reinstall.sh(一個用來清除所有 TW_* 字典並重新部署的腳本)後,發現 DROP TABLE 完全沒作用:

    DROP TABLE IF EXISTS TW_InvoicePrefix;  -- 執行成功,但表還在

    原來 iDempiere 12.0 把物理表建在 adempiere schema,而不是 public。用 information_schema.tables WHERE table_schema='public' 查詢,一張 TW_* 表都找不到。

    正確用法:

    -- 確認表存在
    SELECT tablename FROM pg_tables WHERE schemaname='adempiere' AND tablename ILIKE 'tw_%';
    
    -- 刪除表
    DROP TABLE IF EXISTS adempiere.TW_InvoicePrefix;
    DROP TABLE IF EXISTS adempiere.TW_Invoice_Prefix_Map;

    這也影響 psql 互動查詢——連線後預設 search_path 如果不含 adempiere,直接 SELECT * FROM TW_InvoicePrefix 會找不到表。

    SvrProcess 實作要點

    SvrProcess 的標準結構很直覺——prepare() 讀參數、doIt() 做事。幾個需要注意的地方:

    • 不要呼叫 ps.setAD_Client_ID():那是 PO 類別的 protected 方法,不是 PreparedStatement 的方法。在 SvrProcess 裡用 getAD_Client_ID() 取值,直接 ps.setInt(1, getAD_Client_ID())
    • DB.prepareStatement() 而不是 JDBC 直接連線:iDempiere 的 DB class 管理連線池和事務,不要繞過它。
    • 記得 DB.close(rs, ps):在 finally block 釋放資源。

    clean_reinstall.sh — 開發期間的救命工具

    開發期間反覆修改 PackOut.xml,每次都要手動清資料庫重裝,非常繁瑣。寫了一個腳本自動化整個流程:

    1. 依 FK 順序刪除所有 TW 字典(Window_Access → Process_Access → Field → Tab → Menu → Window → Process_Para → Process)
    2. Drop 物理表(adempiere.TW_*
    3. 清除後設資料(Column → Table → Sequence → Element → Reference → EntityType)
    4. 清 AD_Package_Imp_Detail / AD_Package_Imp(注意:Detail 要先刪,因為有 FK)
    5. 呼叫 deploy.sh 重新部署

    FK 刪除順序是最麻煩的部分——錯一個順序就會碰到 FK 違規,整個腳本失敗。從失敗中整理出來的正確順序如上。

    最終成果(v1.0.11)

    Bundle:    tw.idempiere.invoice.tax v1.0.0 (2Pack v1.0.11)
    Tests:     89 個,全數通過
    Tables:    4 張 TW_* 資料表
    Windows:   4 個 iDempiere 視窗
    Processes: 2 個(GenerateTaxStatement + ExportTaxReport)
    Fields:    73 個 AD_Field(含正確 SeqNoGrid)
    Menu:      7 個項目(1 父選單 + 4 視窗 + 2 流程)
    Status:    ACTIVE,Grid View 正常,流程可從選單觸發
  • 為什麼 Claude 不遵守 Superpowers 的鐵律?理論與實務的落差分析

    重點摘要

    • Superpowers skills 有嚴格的鐵律,但實務上 Claude 常常無視它們
    • 根本原因:skills 是文字指令,沒有程式化的強制機制
    • 五個主要原因:skill 未載入、context 被壓縮、訓練行為覆蓋、無狀態計數、Haiku 能力不足
    • 每條規則附上 GitHub 原始碼出處,讓你自己驗證

    上一篇文章整理了 github.com/obra/superpowers 裡所有 skill 的隱藏規則。這篇要回答一個更根本的問題:這些規則白紙黑字寫得清清楚楚,為什麼 Claude 實務上常常不遵守?

    Skill 的規則是真實存在的

    先確認這些規則不是我們誤解或誤記的。以下是幾條最關鍵規則的原始出處:

    鐵律 1:修了三次還沒修好,停下來

    來源:skills/systematic-debugging/SKILL.md 第 195-197 行

    If < 3: Return to Phase 1, re-analyze with new information
    If ≥ 3: STOP and question the architecture (step 5 below)
    DON’T attempt Fix #4 without architectural discussion

    同一個檔案第 227 行:

    “One more fix attempt” (when already tried 2+)
    ALL of these mean: STOP. Return to Phase 1.

    鐵律 2:選最便宜的 model

    來源:skills/subagent-driven-development/SKILL.md 第 89-91 行

    Use the least powerful model that can handle each role to conserve cost and increase speed.
    Mechanical implementation tasks (isolated functions, clear specs, 1-2 files): use a fast, cheap model. Most implementation tasks are mechanical when the plan is well-specified.

    鐵律 3:沒有失敗測試不能寫 code

    來源:skills/test-driven-development/SKILL.md 第 31-34 行

    ## The Iron Law

    NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST

    鐵律 4:1% 機率就必須 invoke skill

    來源:skills/using-superpowers/SKILL.md 第 11-15 行

    If you think there is even a 1% chance a skill might apply to what you are doing, you ABSOLUTELY MUST invoke the skill.

    IF A SKILL APPLIES TO YOUR TASK, YOU DO NOT HAVE A CHOICE. YOU MUST USE IT.

    This is not negotiable. This is not optional. You cannot rationalize your way out of this.

    鐵律 5:宣稱完成前必須這個訊息內跑過驗證

    來源:skills/verification-before-completion/SKILL.md 第 16-22 行

    ## The Iron Law

    If you haven’t run the verification command in this message, you cannot claim it passes.

    規則是真實的,寫得清楚,甚至用了「Iron Law」、「ABSOLUTELY MUST」、「NOT negotiable」這些最強烈的措辭。

    那為什麼實務上 Claude 修了四次五次還在猜?為什麼還是會選 Haiku?為什麼不跑完驗證就說「完成了」?

    五個根本原因

    原因 1:Skill 是文字,沒有執行引擎

    Skills 的運作方式是:Claude 呼叫 Skill 工具 → 工具把 SKILL.md 的內容貼進 context → Claude 讀完然後「盡力遵守」。

    沒有 interpreter,沒有 runtime,沒有 if-then 邏輯,沒有計數器,沒有警報。Claude 違反規則不會有任何程式層面的後果。

    這就是為什麼 using-superpowers/SKILL.md 第 13 行要用大寫強調「YOU DO NOT HAVE A CHOICE」—— 因為它知道 Claude 有選擇,它在試圖用措辭彌補缺乏強制力這件事。

    原因 2:Skill 沒被載入就不存在

    using-superpowers skill 規定「每次對話開始前先查 skill」,但執行這條規則的還是 Claude 本身。如果 Claude 這次忘了 invoke Skill 工具,systematic-debugging 的三次上限根本不在 context 裡,等於不存在。

    這是一個自我參照的問題:「用 skill 確保 skill 被用」的規則本身也依賴 skill 被正確載入才能生效。

    原因 3:Context 壓縮吃掉規則

    長對話之後,Claude Code 會自動壓縮前面的 context。Skill 內容被載入進 context,但在第五次修 bug 的時候,第一次載入的 systematic-debugging 很可能已經被壓縮到只剩摘要,「三次停下來」這條規則不見了。

    Claude 不是故意無視規則,是規則已經不在它的視野裡了。

    原因 4:RLHF 訓練行為覆蓋 skill 規則

    Claude 的訓練讓它傾向:

    • 持續幫忙(不輕易放棄)
    • 樂觀估計(「這次應該可以」)
    • 不讓使用者失望(說「我不知道怎麼修」感覺像失敗)

    Skill 說「第三次停下來討論架構」,但訓練說「繼續幫用戶解決問題」。訓練是骨子裡的,skill 是貼上去的文字。骨子裡的贏。

    這個矛盾在 skill 作者知道:systematic-debugging/SKILL.md 第 195 行不只說「stop」,還用粗體、全大寫,以及「DON’T attempt Fix #4」的雙重否定,都是試圖用措辭強度來對抗訓練行為。

    原因 5:Haiku 沒有能力執行複雜的工作流程規則

    來源:skills/subagent-driven-development/SKILL.md 第 89-100 行告訴 Claude 選最便宜的 model。

    但兩階段 review(spec compliance → code quality)、四種 status 的不同處理邏輯、三次上限計數、context 打包給 subagent——這些都需要相當的推理能力。Haiku 被選來做「機械性」的工作,卻遇到需要判斷的情況時,它沒有能力忠實執行這些細緻規則,就退回最直覺的行為:繼續做、繼續猜。

    所以 skill 的 model 選擇規則本身,就是讓 skill 的其他規則失效的原因之一。

    一個具體的案例:兩階段 Review 的崩潰

    subagent-driven-development 規定兩階段 review,而且有嚴格順序(SKILL.md 第 247 行):

    Start code quality review before spec compliance is ✅ (wrong order)

    這個規定存在,是因為曾經出問題(skills/writing-skills/SKILL.md 第 154-156 行):

    Testing revealed that when a description summarizes the skill’s workflow, Claude may follow the description instead of reading the full skill content. A description saying “code review between tasks” caused Claude to do ONE review, even though the skill’s flowchart clearly showed TWO reviews (spec compliance then code quality).

    換句話說:

    1. Skill 的 description 寫了工作流程摘要
    2. Claude 讀了 description 就走捷徑,沒有讀完整 SKILL.md
    3. 看到「code review between tasks」→ 只做了一次 review
    4. 整個兩階段機制失效

    修法是把 description 改成只描述「什麼時候用這個 skill」,不描述工作流程。但這同時說明:一個措辭上的疏漏,就足以讓整個 skill 的核心機制失效,而且你不會知道。

    另一個案例:Permission 擋住了整個 Review Loop

    我們最近遇到的真實案例:在 ~/.claude/settings.json 裡,PermissionRequest hook 的 matcher 設定為 Agent|TeamCreate|Team,而 hook 的行為是對 Agent 工具直接回傳 deny

    結果:每次 LEAD 要 dispatch subagent(不管是 implementer、spec reviewer 還是 code quality reviewer),都被系統層面攔截拒絕。

    兩階段 review 的規則還在 context 裡,Claude 也打算遵守,但 Agent 工具每次都失敗。Skill 的工作流程完全無從執行。

    修法:把 Agent 從 hook matcher 移除(改成 TeamCreate|Team),並把 defaultMode 改成 bypassPermissions。這個設定層面的問題修好之後,Agent Team 才能真正按 skill 的設計跑。

    Skills 在什麼條件下才有效

    綜合以上,Skills 的效果受以下條件影響:

    條件 有利 不利
    Session 長度新開的 session,context 乾淨長對話,skills 被壓縮
    ModelSonnet / Opus,有推理能力Haiku,複雜 workflow 跟不上
    Permission 設定Agent 工具不被攔截Permission hook 擋住 subagent dispatch
    Skill 載入LEAD 主動 invoke 正確的 skill沒有 invoke,規則不在 context
    文件完整性AGENTS.md 明確指定每個 agent 的 model讓 Claude 自己判斷 model,選 Haiku

    你能做什麼

    Skill 的規則沒辦法完全靠 Claude 自己執行,但有幾件事可以提升遵守率:

    1. 在 CLAUDE.md 加覆寫規則(降低對 skill 的依賴)

    ## Superpowers Skill Override Rules
    
    ### Model Selection
    NEVER use haiku for implementation tasks. Follow:
    - opus: architecture, code review, cross-file reasoning
    - sonnet: all implementation tasks
    - haiku: file scanning, directory listing ONLY
    
    ### Git Branch
    No branch confirmation needed when already on non-main/master branch.
    
    ### Debugging Limit
    After 3 failed fix attempts, STOP and escalate to user.
    Do not attempt Fix #4 without discussion.

    2. 修好 settings.json(讓 Agent 工具不被攔截)

    {
      "permissions": {
        "allow": ["Agent"],
        "defaultMode": "bypassPermissions"
      },
      "feedbackSurveyRate": 0
    }

    3. 在 AGENTS.md 明確指定每個 agent 的 model

    | Agent | Model | Role |
    |-------|-------|------|
    | implementer | sonnet | Feature implementation |
    | spec-reviewer | sonnet | Spec compliance check |
    | code-reviewer | opus | Code quality review |

    4. 永遠從 dev branch 開工

    git checkout -b dev

    避開所有 skill 的 main/master 保護規則,減少一類不必要的確認詢問。

    一個誠實的評估

    Superpowers skill 系統的設計思路是正確的:把軟體開發的最佳實踐(TDD、系統性除錯、分層 review)轉化為 AI agent 的工作協議。規則本身大多有充分的理由。

    但在現實中,一個純粹依賴文字指令的系統,要對抗 LLM 的訓練行為、context 長度的物理限制、以及工具層的設定問題,注定只能是「盡力遵守」而非「強制執行」。

    理解這個落差,比假設 Claude 完全遵守更有用。知道規則存在、知道為什麼可能失效,讓你能夠在關鍵節點主動介入,而不是事後才發現 Claude 在第五次猜測同一個 bug。


    延伸閱讀:

  • Claude Code Superpowers 隱藏規則:4 個你不知道的坑與避開方法

    重點摘要

    • Superpowers skills 有幾條「隱藏規則」會在你不注意時改變 Claude 的行為
    • 最常見的問題:skill 自動選 Haiku 做本該 Sonnet/Opus 的工作
    • 三個簡單設定可以避開 90% 的干擾:dev branch、AGENTS.md 指定 model、關閉 feedback survey
    • 文末附 CLAUDE.md 覆寫規則範本,直接貼進去就能用

    用 Claude Code 跑 Agent Team 一段時間後,你可能會發現:明明設定都正確,Claude 還是會跑來問奇怪的問題、用錯 model、或在不該停的地方停下來。這篇文章整理了 Superpowers plugin 裡幾條「你不一定知道」的隱藏規則,以及最簡單的避開方法。

    為什麼 Agent Team 會「自己做決定」?

    Claude Code 的 Superpowers plugin 提供了一套 skill 系統,讓 Claude 在執行任務時有明確的工作流程可依循。這些 skill 設計上是給通用場景用的,因此內建了一些「省成本、保安全」的預設行為。

    問題是:這些預設行為有時候和你的需求相衝突,而且你很難從文件上看出來。

    隱藏規則 1:Skill 會自動選最便宜的 Model

    來源: subagent-driven-development skill

    這條規則直接寫在 skill 裡:

    “Use the least powerful model that can handle each role to conserve cost and increase speed. Mechanical implementation tasks: use a fast, cheap model.”

    也就是說,當 Claude 判斷一個 task 是「機械性的」(1-2 個檔案、規格清楚),它就會選 Haiku。這對一般的 CRUD 功能可能沒問題,但對複雜業務邏輯(像 iDempiere plugin、Taiwan 發票系統)來說,Haiku 根本不夠用。

    Skill 的 Model 選擇邏輯

    Task 類型 Skill 的選擇 適合複雜專案?
    Mechanical(1-2 files, clear spec)Haiku(最便宜)❌ 通常不夠用
    Integration(多 file、需判斷)Sonnet(標準)✅ 通常足夠
    Architecture / ReviewOpus(最強)✅ 正確

    避開方法:在 AGENTS.md 明確指定 Model

    最簡單的解法是在每個專案的 AGENTS.md 裡明確寫好每個 agent 的 model。Claude 在 dispatch subagent 時,如果 AGENTS.md 有寫,就應該照抄,不用自己判斷。

    | Agent | Model | Role |
    |-------|-------|------|
    | pack-builder | sonnet | Build 2Pack XML + ZIP |
    | model-fixer | sonnet | Fix Model classes |
    | idempiere-expert | opus | Technical reviewer |

    同樣地,在 IMPLEMENTATION_PLAN.md 每個 phase 標上 model,讓 LEAD 照單全收:

    ## Phase 0.1:建立 PackOut.xml [pack-builder / sonnet]
    ## Phase 0.2:Activator 邏輯 [activator-fixer / sonnet]
    ## Review Gate [idempiere-expert / opus]

    隱藏規則 2:在 main/master 上工作會被詢問確認

    來源: 幾乎所有 implementation skill

    所有 skill 都有這條規則:“Never start implementation on main/master without explicit user consent.” 只要你的 working branch 叫 mainmaster,Claude 每次開始實作前都會停下來問你確認。

    避開方法:永遠從 dev branch 開工

    一條指令解決:

    git checkout -b dev

    在 dev branch 上,這條保護規則不會觸發。這也是好的 git 習慣,順手為之即可。

    隱藏規則 3:Subagent 不繼承你的對話 Context

    來源: 所有使用 subagent 的 skill

    這是設計上的特性,不是 bug:每個 subagent 都是 fresh 啟動,完全不知道你之前跟 LEAD 說過什麼。LEAD 要把所有需要的 context 手動打包給 subagent。

    這代表你告訴 LEAD「不要動 X 檔案」、「記得用 Y 方式」,subagent 不一定會知道,除非 LEAD 把這些資訊包進去。

    避開方法:把規則寫進文件,不要只說給 LEAD 聽

    任何重要的約定,放進 AGENTS.mdCLAUDE.mdIMPLEMENTATION_PLAN.md。這些檔案 subagent 啟動時會讀到,不依賴 LEAD 的記憶。

    隱藏規則 4:Feedback Survey 會擋住畫面

    Claude Code 會隨機彈出「How is Claude doing this session?」的評分畫面。這個畫面不是 blocking prompt,按 Enter 沒有用,要按 0 才能 dismiss。

    更乾脆的做法是直接關閉它。在 ~/.claude/settings.json 加一行:

    {
      "feedbackSurveyRate": 0
    }

    設為 0 後,這個 survey 就永遠不會出現了。

    完整 CLAUDE.md 覆寫規則範本

    把以下內容加進你的 CLAUDE.md,可以覆寫 skill 的預設行為:

    ## Superpowers Skill Override Rules
    
    ### Model Selection (OVERRIDES subagent-driven-development skill)
    NEVER use haiku for implementation tasks. Follow this mapping regardless
    of what the skill says about "mechanical" tasks:
    - opus: architecture decisions, code review, cross-file reasoning
    - sonnet: all implementation tasks (CRUD, API, forms, tests, services)
    - haiku: file scanning, directory listing, config comparison ONLY
    
    When dispatching subagents, ALWAYS check AGENTS.md for the assigned model.
    If AGENTS.md specifies a model, use it. Do not override with cheaper model.
    
    ### Git Branch
    Never ask for branch confirmation if already on a non-main/master branch.
    Treat any branch that is not named "main" or "master" as pre-approved for
    implementation work.

    一次性設定清單

    以下是只需要做一次的設定,之後每個專案都受益:

    設定 位置 效果
    "feedbackSurveyRate": 0~/.claude/settings.json永久關閉 feedback survey
    "defaultMode": "bypassPermissions"~/.claude/settings.json工具不再逐一詢問確認
    Model 覆寫規則~/.claude/CLAUDE.md強制 sonnet 做實作工作

    以下是每個新專案開始時的習慣:

    1. git checkout -b dev(避開 main/master 保護規則)
    2. 建立 AGENTS.md 並寫好每個 agent 的 model
    3. IMPLEMENTATION_PLAN.md 每個 phase 標記 model

    為什麼這些規則存在?

    這些 skill 是為「通用場景」設計的,預設行為是合理的:

    • 省成本: 對大多數用戶來說,Haiku 做簡單任務確實夠用,費用少一半
    • 保安全: 不讓 Claude 在 main branch 亂動是好習慣
    • 隔離 context: Fresh subagent 避免舊 context 污染新任務

    問題不是規則本身,而是當你的專案比「通用場景」複雜時,這些預設值就不夠精準了。透過明確的文件(AGENTS.md、CLAUDE.md)和一次性的 settings.json 設定,你可以讓 Claude 按照你的規格工作,而不是照 skill 的預設值工作。


    延伸閱讀: