强强对抗，Claude Fable 5 与 GPT 5.6 Sol 谁更胜一筹

AI 知识库23小时前发布 K姐Koi

717 0 0

大家好，这里是K姐。一个帮助你把AI真正用起来的女子。

最近 GPT 5.6 系列出了，与Fable 5 在各大榜单打得不可开交，大家都想知道它俩到底谁强。我也想知道，看榜单不如直接用，整点case实际测测这俩模型，看看谁的效果好。多的不说，开测！

模型实测

case 1 单文件网页

提示词：制作一个「内容排期看板」，交付可直接运行的单个 index.html。
页面内置 12 条示例内容，字段包括标题、负责人、平台、发布日期和状态。需要实现：
1. 按负责人、平台和状态筛选；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<string, Set>();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; // 非公式单元格为 nullvalue: 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 胜。

测试总结

10 个 case 测下来，GPT‑5.6 Sol 明确赢了 6 项，Claude Fable 5 赢了 3 项，公众号写作各有一项优势。

做网页、3D 动画和小游戏时，GPT‑5.6 Sol 通常会多写不少代码，但页面结构、视觉细节、操作反馈和异常处理也更完整。尤其是推箱子，关卡更有难度，界面也接近可以直接发布的小游戏。

Claude Fable 5 写代码更短，思路也更利落。未来城市只用了约 478 行代码，就完成了批量建筑、道路、路灯、车辆、环境切换和城市重新生成，画面也更有传统科幻城市的味道，文字也更自然。

一些分享

10 个 case 跑完，我的感受是：模型榜单只能帮我们缩小范围，真正决定体验的，还是手里的任务。GPT‑5.6 Sol 这轮赢得更多。完成度确实高，很多结果稍微改改就能拿来用，但代价也很明显，代码更长，有时会把简单任务做得偏重。Fable 5 成果更轻量化。代码通常短一些，文字读起来也自然。想快速做出一个能看、能点、能演示的网页或小游戏，可以先试 GPT‑5.6 Sol。更在意文字自然度、代码简洁度、资料核对和公式处理，可以把 Fable 5 放在前面。正式项目多跑几个 case，再决定主力模型。我自己更推荐：一个模型做，一个模型查。两个模型都值得用，适合的工作不太一样。对普通用户来说，能稳定做出想要的成品，就是当前最好用的模型。

作者：yuye&K姐投稿邮箱：tougao@kseek.ai