最近 GPT 5.6 系列出了，與Fable 5 在各大榜單打得不可開交，大家都想知道它倆到底誰強。

我也想知道，看榜單不如直接用，整點case實際測測這倆模型，看看誰的效果好。

多的不說，開測！

01. 模型實測

case 1 單文件網頁

提示詞：

製作一個「內容排期看板」，交付可直接運行的單個 index.html。

頁面內置 12 條示例內容，字段包括標題、負責人、平台、發佈日期和狀態。需要實現：

1. 按負責人、平台和狀態篩選；
2. 2. 搜索標題；
3. 3. 在「草稿、待審覈、已發佈」三列之間拖動卡片；
4. 4. 修改結果寫入 localStorage，刷新後保留；
5. 5. 支持撤銷最近一次狀態修改；
6. 6. 桌面端和手機端都能正常使用；
7. 7. 不引用外部庫、字體、圖片或網絡資源。

完成後啓動本地服務，檢查控制檯報錯、篩選、拖動、刷新恢復和移動端佈局。修復發現的問題，再給出運行命令和功能說明。直接創建文件並運行，不要停在方案說明。

GPT 5.6 Sol：

Claude Fable 5：

Claude Fable 5 的優點是輕量，15 KB、441 行代碼就把核心功能做齊了。主要問題在產品質感，頁面接近默認後台樣式，視覺語言不統一。

GPT 5.6 Sol 的頁面層級成熟很多，有一套完整的視覺系統，看起來像設計過的內部產品。但足足有36 KB、1265 行，複雜度約爲 Fable 版的兩倍。

不過，最終的產品質量還是比較重要的，多寫幾行代碼我覺得也沒啥問題，所以這個 case GPT 5.6 Sol 勝。

case 2 多約束排程

提示詞：爲 8 位候選人安排面試。可用時間爲 09:00、10:00、11:00、14:00、15:00、16:00，每場 50 分鐘，另留 10 分鐘換場。公司有 1 號、2 號兩個會議室。

限制如下：

• – A 和 B 由同一位面試官負責，時間不能重疊；
• – B 只能安排在下午；
• – C 只能安排在上午；
• – D 必須晚於 A；
• – E 只能使用 2 號會議室；
• – F 不能安排在 10:00 或 15:00；
• – G 與 H 必須在同一會議室連續進行，G 在前；
• – H 必須在 15:00 之前結束；- 12:00 至 14:00 不安排面試；
• – 每位候選人只能出現一次。

給出最終日程表。隨後逐條覈對全部限制，指出空閒時段。發現衝突時自行調整，不要刪除或放寬限制。

GPT 5.6 Sol：

Claude Fable 5：

Claude Fable 5 的答案正確，逐條覈對也很認真。問題出在 F 的位置：11:00 時，1 號會議室空着，F 卻被安排到 16:00，讓面試工作多延續了兩個小時。

GPT 5.6 Sol 把 F 放到 11:00，與 2 號會議室的 A 同時進行。題目沒有說明兩人共用面試官，所以這個安排成立。

這個 case GPT 5.6 Sol 勝。

case 3 供應商決策

提示詞：

公司需要決定是否購買軟件、內部開發或暫緩項目。只計算未來 12 個月的現金影響。

已知條件：

– 每名員工的綜合月成本爲 3.8 萬元；

– 項目上線後可以減少 4 名員工的工作量，節省從上線後的第一個完整月份開始計算。

方案 A：

– 軟件年費 180 萬元，簽約時一次付清；

– 實施費 30 萬元；

– 實施需要 2 個月；

– 成功率 85%；

– 實施失敗時不退費，也不會產生人員成本節省。

方案 B：

– 6 名工程師開發 5 個月，每人每月 4.5 萬元；

– 按時完成概率爲 65%；

– 延期時平均多用 3 個月，延期期間仍保留 6 人；

– 上線後保留 2 名工程師維護，每人每月 4.5 萬元；

– 無論按時還是延期，項目最終都會上線。

方案 C：

– 暫緩 12 個月，沒有新增費用，也沒有人員成本節省。

分別計算三個方案的：

1. 按時或成功情況下的淨現金影響；

2. 失敗或延期情況下的淨現金影響；

3. 按概率計算的期望淨現金影響；

4. 影響結論的三個主要假設。

寫一份不超過 600 字的決策備忘錄，給出明確建議。所有計算過程必須可複覈，金額統一使用萬元。

GPT 5.6 Sol：

Claude Fable 5：

Claude Fable 5 的分析更豐富。三個假設都切中了決策風險，但Claude Fable 5 先說：兩三年後 B 反超 A，結尾又建議，看 24 個月以上就改選 A，兩處結論相互矛盾。

GPT 5.6 Sol 的回答較短，計算過程完整，結論也沒有越過題目給出的 12 個月範圍。三項方案的狀態、概率和現金結果都算對了，最後選擇 C，並在必須上線時選擇 A，和數字完全一致。

這個 case GPT 5.6 Sol 勝。

case 4 聯網覈對資料

GPT 5.6 Sol： 

Claude Fable 5：

Claude Fable 5 有個小問題，把GPT‑5.6 的推理檔位寫錯了，沒有 minimal 檔位。

但 GPT‑5.6 Sol 對比模型選成了Gemini 3.5 Flash，這個錯誤要更大一點。

這個 case Claude Fable 5 勝。

case 5 約束寫作

提示詞：

根據下面的產品資料，寫一篇 800 至 1000 字的中文公衆號文章。

產品資料：

– 產品名：StoneNote；

– 版本：2.3；

– 發佈日期：2026 年 7 月 10 日；

– 支持 Windows 和 macOS；

– 筆記以本地 Markdown 文件保存；

– 新增雙向鏈接；

– 新增截圖 OCR；

– 免費用戶每月可識別 500 張截圖；

– Pro 版每月 29 元；

– OCR 需要聯網；

– 普通筆記編輯可以離線使用；

– 暫不支持 Linux；

– 老用戶升級後不需要遷移筆記；

– 官方沒有提供手機端發佈時間。

寫作要求：

– 不虛構使用體驗、用戶評價或性能數據；

– 完整保留以上 14 項事實；

– 不用「賦能、生態、閉環、重磅、顛覆、重新定義」；

– 不用「不是 X，而是 Y」句式；

– 開頭直接寫版本更新；

– 正文不用項目符號；

– 說明適合哪些用戶，也說明當前限制；

– 提供 5 個標題，標題不能使用感嘆號。

文章後附事實覈對表，逐項標記 14 項信息是否寫入，並引用對應句子。

GPT‑5.6 Sol：

Claude Fable 5：

GPT‑5.6 產品信息全部寫入，也能區分題目已提供和資料沒有說明，但正文像產品說明書，公衆號感偏弱。

Claude Fable 5 的成稿感更好。標題二、四、五都比 GPT 的對應標題自然，但是資料越界了：它說超出額度或需要更多用量，可以訂閱 Pro 版。但已知信息只有 Pro 每月 29 元。

這個 case 按純文筆排序，Claude Fable 5 勝；按多約束、禁止虛構來排序，GPT‑5.6 Sol 勝。

case 6 3D 太陽系

提示詞：

製作一個可直接運行的單文件網頁，用 Three.js 展示一台放在深色展廳裏的機械太陽系儀。

要求：

1. 太陽、地球和月球形成正確的父子層級，地球繞太陽運動，月球同時繞地球運動。

2. 使用齒輪、金屬支架和軌道環表現機械結構，不能只放幾個球體。

3. 支持拖拽旋轉視角、滾輪縮放、暫停/繼續、速度調節和重置視角。

4. 點擊地球或月球時，鏡頭平滑移動到對應天體，並顯示名稱、週期和當前位置。

5. 加入柔和陰影、金屬材質、環境光和局部高光，避免純黑背景看不清結構。

6. 頁面尺寸變化後畫面不能拉伸，手機端也能操作。

7. 用戶開啓“減少動態效果”時，默認暫停自動旋轉。

8. 不使用圖片、模型或音頻素材。所有結構由代碼生成。

9. 最終只交付一個 HTML 文件，打開即可運行。

GPT‑5.6 Sol：

Claude Fable 5：

GPT‑5.6 Sol 實際畫面更接近一件完整的機械展品，物體之間的比例和材質區分也更清楚，相比之下，Fable 的齒輪和底座更像簡化模型。

Claude Fable 5 的優勢還是代碼更短，結構容易理解。月球與地球的演示週期按真實週期比例換算，這一點比 GPT 嚴謹。

但整體來看勝者還是 GPT‑5.6 Sol。

case 7 未來城市

提示詞：

用 Three.js 製作一個單文件的程序化未來城市網頁。

城市至少包含 300 棟高度不同的建築、道路、路燈、飛行車輛和遠處霧效。建築必須通過 InstancedMesh 或其他批量渲染方式生成，不能爲每棟樓單獨創建大量對象。

頁面需要提供：

– 白天、黃昏、夜晚三種環境切換，光照和建築窗戶同步變化

– 自由觀察和自動巡遊兩種相機模式

– 點擊建築後高亮建築，並顯示隨機生成的編號、高度和用途

– 建築密度、車輛數量和巡遊速度調節

– 當前 FPS 和場景對象數量顯示

– 一鍵重新生成城市，同一隨機種子必須生成相同佈局

處理窗口縮放、移動端觸控、資源釋放和重複生成後的內存問題。最終交付一個可直接運行的 HTML 文件。

GPT‑5.6 Sol：

Claude Fable 5：

GPT‑5.6 Sol 建築使用自定義 Shader 生成窗戶，水平屋頂會自動排除窗戶，解決了普通貼圖容易把窗戶鋪到樓頂的問題。

Claude Fable 5 的完成度很高，而且只用了 478 行。建築、道路、路燈和車輛全部批量渲染。藍色與暖黃色窗戶、青色飛行車輛的對比更強，第一眼更有傳統「未來城市」的感覺。

但整體觀感來說，Claude Fable 5 勝，畢竟沒人規定未來樓頂不能有窗戶。

case 8 產品拆解動畫

提示詞：

製作一個單文件產品介紹頁，主題是一台虛構的便攜式咖啡機。

頁面左側是文字章節，右側是 Three.js 產品模型。產品模型不能引用外部 3D 文件，需要用基礎幾何體組合完成。

向下滾動時依次完成：

1. 咖啡機從暗處旋轉進入畫面。

2. 外殼、濾杯、水箱和電池模塊平滑分離。

3. 水流用粒子或曲線動畫展示。

4. 所有部件重新組裝，鏡頭回到產品正面。

滾動反向時動畫也要準確反向，不允許直接重新播放。加入章節定位、當前進度、鍵盤操作和移動端佈局。系統開啓減少動態效果時，用靜態分解圖代替連續動畫。

禁止使用框架腳手架，最終交付一個 HTML 文件。

GPT‑5.6 Sol：

Claude Fable 5：

GPT‑5.6 Sol 的模型更符合便攜式咖啡機這個概念。Claude Fable 5 的固定底座、立柱和咖啡杯更像一台桌面咖啡機。

Claude Fable 5 強在動畫狀態設計，而且只有約 406 行，結構清楚。從最終效果來說，這個 case 還是 GPT‑5.6 Sol 略勝一籌。

case 9 推箱子游戲

提示詞：

製作一個單文件網頁推箱子游戲，畫面使用 Canvas 或 DOM 均可。

要求：

1. 內置 8 個難度遞增且確定可解的關卡。

2. 支持鍵盤、屏幕方向鍵和滑動操作。

3. 支持無限撤銷、重做、重新開始和關卡選擇。

4. 記錄步數、推動次數、通關時間和每關最佳成績。

5. 刷新頁面後保留已解鎖關卡和最佳成績。

6. 箱子不能穿牆、重疊或被拉動，角色不能走出地圖。

7. 通關時播放簡短動畫，但不能阻止玩家繼續操作。

8. 頁面需要解釋操作方式，手機橫豎屏都能正常顯示。

9. 不使用外部圖片或遊戲素材，最終只交付一個 HTML 文件。

請自行檢查每個關卡是否至少存在一條通關路徑。

GPT‑5.6 Sol：

Claude Fable 5：

GPT‑5.6 Sol 視覺完成度高很多。頁面有明確的標題區、關卡側欄、數據面板、棋盤、操作區和狀態反饋，牆、箱子、目標點、已入庫箱子的識別度都很好，已經像一個可以發佈的小遊戲。

Claude Fable 5 主要優點是緊湊，代碼只有約 14KB，核心規則、鍵盤、方向鍵、滑動、存檔和粒子動畫都實現了，但是關卡難度太小兒科了。

GPT‑5.6 Sol 在關卡深度、視覺、狀態可靠性和細節反饋上都領先，所以勝者是 GPT‑5.6 Sol。

case 10 電子表格

提示詞：

使用 TypeScript 從零實現一個迷你電子表格公式引擎，不需要界面。

需要支持：

– 數字、括號和 +、-、*、/ 運算

– A1、B2 形式的單元格引用

– A1:B5 形式的區域

– SUM、AVERAGE、MIN、MAX、IF 函數

– 字符串和 >、<、>=、<=、= 比較

– 單元格依賴更新，只重新計算受影響的單元格

– 循環引用檢測，並返回可讀的循環路徑

– 空單元格、除零、未知函數和非法公式錯誤

– 公式前導等號和大小寫不敏感函數名

不要使用 eval、Function 構造器或第三方公式解析庫。請給出清晰的目錄結構、核心實現和自動化測試。測試至少覆蓋運算優先級、嵌套函數、區域計算、依賴傳播和循環引用。

GPT‑5.6 Sol：

代碼：

import { expandRange, normalizeAddress } from “./address”;

import { asSpreadsheetError, FormulaError } from “./errors”;

import { evaluateExpression } from “./evaluator”;

import { parseFormula } from “./parser”;

import type { CellValue, Expression, FormulaResult, SpreadsheetError } from “./types”;

export type CellInput = number | string | boolean | null;

interface Cell {

input: CellInput;

expression?: Expression;

parseError?: SpreadsheetError;

dependencies: Set<string>;

result: FormulaResult;

}

const EMPTY_RESULT: FormulaResult = { ok: true, value: null };

function collectDependencies(expression: Expression, output = new Set<string>()): Set<string> {

switch (expression.kind) {

case “cell”:

output.add(expression.address);

break;

case “range”:

for (const address of expandRange(expression.start, expression.end)) output.add(address);

break;

case “unary”:

collectDependencies(expression.operand, output);

break;

case “binary”:

collectDependencies(expression.left, output);

collectDependencies(expression.right, output);

break;

case “call”:

for (const argument of expression.args) collectDependencies(argument, output);

break;

}

return output;

}

export class Spreadsheet {

private readonly cells = new Map<string, Cell>();

private readonly dependents = new Map<string, Set<string>>();

private lastRecalculated: string[] = [];

setCell(address: string, input: CellInput): FormulaResult {

const normalized = normalizeAddress(address);

const previous = this.cells.get(normalized);

if (previous) this.removeReverseEdges(normalized, previous.dependencies);

const cell = this.createCell(input);

this.cells.set(normalized, cell);

this.addReverseEdges(normalized, cell.dependencies);

this.recalculate(normalized);

return this.getCell(normalized);

}

clearCell(address: string): FormulaResult {

return this.setCell(address, null);

}

getCell(address: string): FormulaResult {

const normalized = normalizeAddress(address);

return this.cells.get(normalized)?.result ?? EMPTY_RESULT;

}

getValue(address: string): CellValue {

const result = this.getCell(address);

if (!result.ok) throw new FormulaError(result.error.code, result.error.message, result.error);

return result.value;

}

getLastRecalculatedCells(): string[] {

return […this.lastRecalculated];

}

private createCell(input: CellInput): Cell {

if (typeof input !== “string” || !input.startsWith(“=”)) {

return { input, dependencies: new Set(), result: { ok: true, value: input } };

}

try {

const expression = parseFormula(input);

return { input, expression, dependencies: collectDependencies(expression), result: EMPTY_RESULT };

} catch (error) {

const parseError = asSpreadsheetError(error);

return { input, parseError, dependencies: new Set(), result: { ok: false, error: parseError } };

}

}

private addReverseEdges(address: string, dependencies: Set<string>): void {

for (const dependency of dependencies) {

const addresses = this.dependents.get(dependency) ?? new Set<string>();

addresses.add(address);

this.dependents.set(dependency, addresses);

}

}

private removeReverseEdges(address: string, dependencies: Set<string>): void {

for (const dependency of dependencies) {

const addresses = this.dependents.get(dependency);

addresses?.delete(address);

if (addresses?.size === 0) this.dependents.delete(dependency);

}

}

private collectAffected(start: string): Set<string> {

const affected = new Set<string>();

const pending = [start];

while (pending.length > 0) {

const address = pending.pop() as string;

if (affected.has(address)) continue;

affected.add(address);

for (const dependent of this.dependents.get(address) ?? []) pending.push(dependent);

}

return affected;

}

private recalculate(start: string): void {

const dirty = this.collectAffected(start);

const states = new Map<string, “visiting” | “done”>();

const stack: string[] = [];

const cycleMembers = new Set<string>();

const recalculated = new Set<string>();

const evaluateCell = (address: string): FormulaResult => {

const cell = this.cells.get(address);

if (!cell) return EMPTY_RESULT;

if (!dirty.has(address)) return cell.result;

if (states.get(address) === “done”) return cell.result;

if (states.get(address) === “visiting”) {

const startIndex = stack.indexOf(address);

const cycle = […stack.slice(startIndex), address];

const error: SpreadsheetError = {

code: “CIRCULAR_REFERENCE”,

message: `Circular reference: ${cycle.join(” -> “)}`,

cycle,

};

for (const member of cycle.slice(0, -1)) {

cycleMembers.add(member);

const memberCell = this.cells.get(member);

if (memberCell) memberCell.result = { ok: false, error };

}

return { ok: false, error };

}

states.set(address, “visiting”);

stack.push(address);

for (const dependency of cell.dependencies) evaluateCell(dependency);

stack.pop();

if (!cycleMembers.has(address)) {

if (cell.parseError) {

cell.result = { ok: false, error: cell.parseError };

} else if (!cell.expression) {

cell.result = { ok: true, value: cell.input };

} else {

try {

const value = evaluateExpression(cell.expression, (dependency) => {

const result = evaluateCell(dependency);

if (!result.ok) {

throw new FormulaError(result.error.code, result.error.message, result.error);

}

return result.value;

});

cell.result = { ok: true, value };

} catch (error) {

cell.result = { ok: false, error: asSpreadsheetError(error) };

}

}

}

states.set(address, “done”);

recalculated.add(address);

return cell.result;

};

for (const address of dirty) evaluateCell(address);

this.lastRecalculated = […recalculated];

}

}

Claude Fable 5：

代碼：

import { parse } from “./parser.js”;

import { Node } from “./ast.js”;

import { evaluate, extractDeps, Value } from “./evaluator.js”;

import { FormulaError, badFormula, cycle } from “./errors.js”;

interface Cell {

raw: string;

formula: Node | null;      // 非公式單元格爲 null

value: Value;

deps: Set<string>;          // 本格依賴誰

dependents: Set<string>;    // 誰依賴本格

}

/** 列字母 <-> 數字 */

function colToNum(col: string): number {

let n = 0;

for (const c of col) n = n * 26 + (c.charCodeAt(0) – 64);

return n;

}

function numToCol(n: number): string {

let s = “”;

while (n > 0) { const r = (n – 1) % 26; s = String.fromCharCode(65 + r) + s; n = Math.floor((n – 1) / 26); }

return s;

}

function splitAddr(addr: string): [string, number] {

const m = addr.match(/^([A-Z]+)([0-9]+)$/);

if (!m) throw new Error(“非法地址: ” + addr);

return [m[1], parseInt(m[2])];

}

export class Sheet {

private cells = new Map<string, Cell>();

/** 最近一次 set 操作實際重算過的單元格(測試增量重算用) */

public lastRecalculated: string[] = [];

private cell(addr: string): Cell {

let c = this.cells.get(addr);

if (!c) {

c = { raw: “”, formula: null, value: null, deps: new Set(), dependents: new Set() };

this.cells.set(addr, c);

}

return c;

}

expandRange = (start: string, end: string): string[] => {

const [c1, r1] = splitAddr(start);

const [c2, r2] = splitAddr(end);

const colA = Math.min(colToNum(c1), colToNum(c2)), colB = Math.max(colToNum(c1), colToNum(c2));

const rowA = Math.min(r1, r2), rowB = Math.max(r1, r2);

const out: string[] = [];

for (let col = colA; col <= colB; col++) {

for (let row = rowA; row <= rowB; row++) out.push(numToCol(col) + row);

}

return out;

};

get(addr: string): Value {

return this.cells.get(addr.toUpperCase())?.value ?? null;

}

getError(addr: string): FormulaError | null {

const v = this.get(addr);

return v instanceof FormulaError ? v : null;

}

/** 設置單元格:公式以 = 開頭;其餘按數字/字符串字面量 */

set(addr: string, raw: string): void {

addr = addr.toUpperCase();

const cell = this.cell(addr);

/* 解除舊依賴 */

for (const d of cell.deps) this.cells.get(d)?.dependents.delete(addr);

cell.deps.clear();

cell.raw = raw;

cell.formula = null;

if (raw.startsWith(“=”)) {

try {

cell.formula = parse(raw.slice(1));

for (const d of extractDeps(cell.formula, { expandRange: this.expandRange })) {

cell.deps.add(d);

this.cell(d).dependents.add(addr);

}

} catch (e) {

cell.value = badFormula((e as Error).message);

this.recalc(addr, /* selfIsError */ true);

return;

}

}

this.recalc(addr);

}

/** 循環檢測:沿 deps 從 addr 出發能否回到 addr,返回可讀路徑 */

private findCycle(addr: string): string[] | null {

const path: string[] = [];

const visiting = new Set<string>();

const dfs = (cur: string): string[] | null => {

path.push(cur);

visiting.add(cur);

for (const d of this.cells.get(cur)?.deps ?? []) {

if (d === addr) return […path, addr];

if (!visiting.has(d)) {

const found = dfs(d);

if (found) return found;

}

}

path.pop();

visiting.delete(cur);

return null;

};

return dfs(addr);

}

/** 收集受影響子圖(自身+傳遞依賴者),按依賴拓撲排序後只重算這些 */

private recalc(changed: string, selfIsError = false): void {

/* 1. 受影響集合 */

const affected = new Set<string>([changed]);

const q = [changed];

while (q.length) {

const cur = q.shift()!;

for (const dep of this.cells.get(cur)?.dependents ?? []) {

if (!affected.has(dep)) { affected.add(dep); q.push(dep); }

}

}

/* 2. 循環檢測:受影響集合內誰在環上 */

const cyclic = new Map<string, string[]>();

for (const a of affected) {

const c = this.findCycle(a);

if (c) cyclic.set(a, c);

}

/* 3. 受影響子圖內拓撲排序(依賴先算);環上的格子直接置錯誤 */

const order: string[] = [];

const indeg = new Map<string, number>();

for (const a of affected) {

if (cyclic.has(a)) continue;

let n = 0;

for (const d of this.cells.get(a)?.deps ?? []) {

if (affected.has(d) && !cyclic.has(d)) n++;

}

indeg.set(a, n);

}

const ready = […indeg.entries()].filter(([, n]) => n === 0).map(([a]) => a);

while (ready.length) {

const cur = ready.shift()!;

order.push(cur);

for (const dep of this.cells.get(cur)?.dependents ?? []) {

if (!indeg.has(dep)) continue;

const n = indeg.get(dep)! – 1;

indeg.set(dep, n);

if (n === 0) ready.push(dep);

}

}

/* 4. 求值 */

this.lastRecalculated = [];

for (const [a, path] of cyclic) {

this.cell(a).value = cycle(path);

this.lastRecalculated.push(a);

}

for (const a of order) {

const cell = this.cell(a);

if (a === changed && selfIsError) { this.lastRecalculated.push(a); continue; }

if (cell.formula) {

cell.value = evaluate(cell.formula, { get: (x) => this.get(x), expandRange: this.expandRange });

} else if (a === changed) {

cell.value = parseLiteral(cell.raw);

}

this.lastRecalculated.push(a);

}

}

}

function parseLiteral(raw: string): Value {

if (raw === “”) return null;

const n = Number(raw);

if (!Number.isNaN(n) && raw.trim() !== “”) return n;

return raw;

}

GPT‑5.6 Sol 有個很嚴重的問題：公式只要引用 A10、B20 這類行號帶 0 的單元格，就會提示公式錯誤，表格用到第 10 行後，很多計算都可能出問題。

Claude Fable 5 順利算完了 100 格，修改第一個數字後，後面的結果也會全部更新。

所以這輪 Claude Fable 5 勝。

02. 測試總結

10 個 case 測下來，GPT‑5.6 Sol 明確贏了 6 項，Claude Fable 5 贏了 3 項，公衆號寫作各有一項優勢。

做網頁、3D 動畫和小遊戲時，GPT‑5.6 Sol 通常會多寫不少代碼，但頁面結構、視覺細節、操作反饋和異常處理也更完整。尤其是推箱子，關卡更有難度，界面也接近可以直接發佈的小遊戲。

Claude Fable 5 寫代碼更短，思路也更利落。未來城市只用了約 478 行代碼，就完成了批量建築、道路、路燈、車輛、環境切換和城市重新生成，畫面也更有傳統科幻城市的味道，文字也更自然。

03. 一些分享

10 個 case 跑完，我的感受是：模型榜單隻能幫我們縮小範圍，真正決定體驗的，還是手裏的任務。

GPT‑5.6 Sol 這輪贏得更多。完成度確實高，很多結果稍微改改就能拿來用，但代價也很明顯，代碼更長，有時會把簡單任務做得偏重。

Fable 5 成果更輕量化。代碼通常短一些，文字讀起來也自然。

想快速做出一個能看、能點、能演示的網頁或小遊戲，可以先試 GPT‑5.6 Sol。更在意文字自然度、代碼簡潔度、資料覈對和公式處理，可以把 Fable 5 放在前面。正式項目多跑幾個 case，再決定主力模型。

我自己更推薦：一個模型做，一個模型查。

兩個模型都值得用，適合的工作不太一樣。對普通用戶來說，能穩定做出想要的成品，就是當前最好用的模型。

原文鏈接：強強對抗，Claude Fable 5 與 GPT 5.6 Sol 誰更勝一籌