最近 GPT 5.6 系列出了，与Fable 5 在各大榜单打得不可开交，大家都想知道它俩到底谁强。
我也想知道，看榜单不如直接用，整点case实际测测这俩模型，看看谁的效果好。
多的不说，开测！
01. 模型实测
case 1 单文件网页
提示词：
制作一个「内容排期看板」，交付可直接运行的单个 index.html。
页面内置 12 条示例内容，字段包括标题、负责人、平台、发布日期和状态。需要实现：
- 按负责人、平台和状态筛选；
- 2. 搜索标题；
- 3. 在「草稿、待审核、已发布」三列之间拖动卡片；
- 4. 修改结果写入 localStorage，刷新后保留；
- 5. 支持撤销最近一次状态修改；
- 6. 桌面端和手机端都能正常使用；
- 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 和 Google 当前能力最接近的旗舰 API 模型。
只使用三家公司官网、开发者文档、帮助中心和系统卡。不要引用媒体、博客、聚合网站或搜索结果摘要。
核对以下信息：
– API 模型 ID；
– 输入和输出价格；
– 上下文窗口；
-最大输出长度；
– 支持的输入类型；
– 推理强度设置；
– 工具调用和计算机操作支持；
– 数据保留要求；
– 当前开放范围；
– 官方公布的代码、专业工作和工具调用评测。
每项信息附直接页面链接和访问日期。不同官方页面发生冲突时，列出冲突并说明采用哪一项。官网没有明确说明的内容写「官方未说明」。
最后分别针对仓库代码修改、长 PDF 审计、联网调查给出模型选择。把官方事实与个人判断分开。
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;
result: FormulaResult;
}
const EMPTY_RESULT: FormulaResult = { ok: true, value: null };
function collectDependencies(expression: Expression, output = new Set()): Set {
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();
private readonly dependents = new Map>();
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): void {
for (const dependency of dependencies) {
const addresses = this.dependents.get(dependency) ?? new Set();
addresses.add(address);
this.dependents.set(dependency, addresses);
}
}
private removeReverseEdges(address: string, dependencies: Set): 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 {
const affected = new Set();
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();
const stack: string[] = [];
const cycleMembers = new Set();
const recalculated = new Set();
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; // 本格依赖谁
dependents: Set; // 谁依赖本格
}
/** 列字母 <-> 数字 */
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();
/** 最近一次 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();
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([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();
for (const a of affected) {
const c = this.findCycle(a);
if (c) cyclic.set(a, c);
}
/* 3. 受影响子图内拓扑排序(依赖先算);环上的格子直接置错误 */
const order: string[] = [];
const indeg = new Map();
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，再决定主力模型。
我自己更推荐：一个模型做，一个模型查。
两个模型都值得用，适合的工作不太一样。对普通用户来说，能稳定做出想要的成品，就是当前最好用的模型。
