Recently GPT 5.6 series came out, and withFable 5 they are battling it out on all the major leaderboards, and everyone wants to know which of the two is stronger.
I want to know too. Rather than looking at leaderboards, it's better to just use them directly. Put together some cases to actually test these two models and see which one performs better.
Without further ado, let's start testing!
01. Model hands-on testing
case 1 Single-file webpage
Prompt:
Create a "Content Scheduling Board" and deliver a single index.html that can be run directly.
The page has 12 built-in sample content items, with fields including title, owner, platform, publish date, and status. You need to implement:
- Filter by owner, platform, and status;
- 2. Search titles;
- 3. Drag cards between the three columns "Draft, Pending Review, Published";
- 4. Write modification results to localStorage and retain them after refresh;
- 5. Support undoing the most recent status change;
- 6. Work properly on both desktop and mobile;
- 7. Do not reference external libraries, fonts, images, or network resources.
After finishing, start a local service, check for console errors, filtering, dragging, refresh recovery, and mobile layout. Fix any issues found, then provide the run command and feature description. Create the file and run it directly; do not stop at a plan explanation.
GPT 5.6 Sol：
Claude Fable 5：
Claude Fable 5's advantage is that it is lightweight: 15 KB and 441 lines of code fully cover the core functionality. The main issue is product polish; the page is close to a default admin style, and the visual language is not unified.
GPT 5.6 Sol's page hierarchy is much more mature, with a complete visual system, and it looks like a designed internal product. But it is a full 36 KB and 1,265 lines, about twice the complexity of the Fable version.
However, final product quality still matters more, and I think writing a few more lines of code is not a problem, so GPT 5.6 Sol wins this case.
case 2 Multi-constraint scheduling
Prompt: Schedule interviews for 8 candidates. Available times are 09:00, 10:00, 11:00, 14:00, 15:00, 16:00, each session is 50 minutes, with another 10 minutes for room changes. The company has Meeting Room 1 and Meeting Room 2.
The constraints are as follows:
- – A and B are handled by the same interviewer, and their times cannot overlap;
- – B can only be scheduled in the afternoon;
- – C can only be scheduled in the morning;
- – D must be later than A;
- – E can only use Meeting Room 2;
- – F cannot be scheduled at 10:00 or 15:00;
- – G and H must be consecutive in the same meeting room, with G first;
- – H must end before 15:00; - No interviews from 12:00 to 14:00;
- – Each candidate can appear only once.
Provide the final schedule. Then verify all constraints one by one and point out the idle time slots. When conflicts are found, adjust them yourself; do not delete or relax the constraints.
GPT 5.6 Sol：
Claude Fable 5：
Claude Fable 5's answer was correct, and the item-by-item verification was also very careful. The problem was F's position: at 11:00, Meeting Room 1 was empty, but F was scheduled for 16:00, extending the interview work by two extra hours.
GPT 5.6 Sol put F at 11:00, at the same time as A in Meeting Room 2. The problem did not state that the two share an interviewer, so this arrangement is valid.
GPT 5.6 Sol wins this case.
case 3 Vendor decision
Prompt:
The company needs to decide whether to buy software, develop in-house, or defer the project. Count only the cash impact over the next 12 months.
Known conditions:
– The fully loaded monthly cost per employee is 38,000 yuan;
– After the project goes live, it can reduce the workload of 4 employees, with savings counted starting from the first full month after go-live.
Option A:
– Annual software fee of 1.8 million yuan, paid in full at signing;
– Implementation fee of 300,000 yuan;
– Implementation takes 2 months;
– Success rate 85%;
– If implementation fails, fees are not refunded, and no personnel cost savings are generated.
Option B:
– 6 engineers develop for 5 months, at 45,000 yuan per person per month;
– Probability of on-time completion is 65%;
– If delayed, it takes an average of 3 more months, and all 6 people are retained during the delay;
– After go-live, 2 engineers are retained for maintenance, at 45,000 yuan per person per month;
– Whether on time or delayed, the project will eventually go live.
Option C:
– Defer for 12 months, with no new costs and no personnel cost savings.
Calculate for each of the three options:
1. The net cash impact under the on-time or success scenario;
2. The net cash impact under the failure or delay scenario;
3. The probability-weighted expected net cash impact;
4. The three main assumptions behind the conclusion.
Write a decision memo of no more than 600 words and give a clear recommendation. All calculation steps must be auditable, and all amounts must be stated uniformly in ten-thousand yuan.
GPT 5.6 Sol：
Claude Fable 5：
Claude Fable 5's analysis is richer. All three assumptions hit decision risks, but Claude Fable 5 first says: after two or three years B overtakes A, and at the end again recommends that if looking at more than 24 months, switch to A. The two conclusions contradict each other.
GPT 5.6 Sol's answer is shorter, the calculation process is complete, and the conclusion does not go beyond the 12-month scope given in the question. The states, probabilities, and cash results of the three options are all calculated correctly, and in the end it chooses C, and chooses A when go-live is mandatory, fully consistent with the numbers.
In this case GPT 5.6 Sol wins.
case 4 Online fact-checking materials
GPT 5.6 Sol：Prompt:
As of today, compare GPT-5.6 Sol, Claude Fable 5, and Google's current flagship API model with the closest capabilities.
Use only the three companies' official websites, developer documentation, help centers, and system cards. Do not cite media, blogs, aggregator sites, or search result summaries.
Verify the following information:
– API model ID;
– Input and output prices;
– Context window;
- Maximum output length;
– Supported input types;
– Reasoning effort settings;
– Tool calling and computer use support;
– Data retention requirements;
– Current availability;
– Officially published evaluations for coding, professional work, and tool calling.
Attach a direct page link and access date to each item of information. If different official pages conflict, list the conflict and state which item is adopted. For content not clearly stated on the official website, write "officially not stated".
Finally, give model choices separately for repository code modification, long PDF auditing, and online investigation. Separate official facts from personal judgment.
Claude Fable 5：
Claude Fable 5 has a small issue: it wrote the reasoning tiers for GPT-5.6 incorrectly, and there is no minimal tier.
But GPT-5.6 Sol had the comparison model selected as Gemini 3.5 Flash, which is a bigger mistake.
This case goes to Claude Fable 5.
case 5 Constrained Writing
Prompt:
Based on the product information below, write a Chinese WeChat public account article of 800 to 1,000 words.
Product information:
– Product name: StoneNote;
– Version: 2.3;
– Release date: July 10, 2026;
– Supports Windows and macOS;
– Notes are saved as local Markdown files;
– Added bidirectional links;
– Added screenshot OCR;
– Free users can recognize 500 screenshots per month;
– Pro version costs 29 yuan per month;
– OCR requires an internet connection;
– Regular note editing can be used offline;
– Linux is not supported for now;
– Existing users do not need to migrate notes after upgrading;
– The official release date for the mobile app has not been provided.
Writing requirements:
– Do not fabricate usage experiences, user reviews, or performance data;
– Fully retain all 14 facts above;
– Do not use “empower, ecosystem, closed loop, blockbuster, subvert, redefine”;
– Do not use the “not X, but Y” sentence pattern;
– Start directly with the version update;
– Do not use bullet points in the body;
– Explain which users it is suitable for, and also explain the current limitations;
– Provide 5 titles, and the titles must not use exclamation marks.
After the article, attach a fact-check table, marking item by item whether the 14 pieces of information were included, and quote the corresponding sentences.
GPT‑5.6 Sol：
Claude Fable 5：
GPT-5.6 wrote in all the product information and could also distinguish between what the prompt provided and what the materials did not state, but the body reads like a product manual and feels weak as a WeChat public account article.
Claude Fable 5's finished draft feels better. Titles two, four, and five are all more natural than GPT's corresponding titles, but it went beyond the materials: it said that if the quota is exceeded or more usage is needed, one can subscribe to the Pro version. But the only known information is that Pro costs 29 yuan per month.
For this case, ranked purely by writing quality, Claude Fable 5 wins; ranked by multiple constraints and prohibition of fabrication, GPT-5.6 Sol wins.
case 6 3D Solar System
Prompt:
Create a directly runnable single-file webpage, using Three.js to display a mechanical orrery placed in a dark exhibition hall.
Requirements:
1. The Sun, Earth, and Moon form the correct parent-child hierarchy, with Earth moving around the Sun and the Moon simultaneously moving around Earth.
2. Use gears, metal supports, and orbital rings to express the mechanical structure; do not just place a few spheres.
3. Support drag-to-rotate the view, scroll-wheel zoom, pause/resume, speed adjustment, and reset view.
4. When Earth or the Moon is clicked, the camera smoothly moves to the corresponding celestial body and displays its name, period, and current position.
5. Add soft shadows, metallic materials, ambient light, and local highlights, avoiding a pure black background that makes the structure hard to see.
6. After the page size changes, the image must not stretch, and it must also be operable on mobile.
7. When the user enables “reduce motion,” automatic rotation is paused by default.
8. Do not use image, model, or audio assets. All structures are generated by code.
9. In the end, deliver only one HTML file that runs when opened.
GPT‑5.6 Sol：
Claude Fable 5：
The actual visuals of GPT‑5.6 Sol are closer to a complete mechanical exhibit, and the proportions and material distinctions between objects are also clearer. In comparison, Fable's gears and base look more like simplified models.
Claude Fable 5's advantage is still that the code is shorter and the structure is easy to understand. The demonstration period of the Moon and Earth is converted according to real orbital period ratios, which is more rigorous than GPT.
But overall, the winner is still GPT‑5.6 Sol.
case 7 Future City
Prompt:
Use Three.js to create a single-file procedural future city webpage.
The city must contain at least 300 buildings of different heights, roads, streetlights, flying vehicles, and distant fog effects. The buildings must be generated through InstancedMesh or other batch rendering methods; a large number of separate objects must not be created for each building.
The page needs to provide:
– Switching between three environments: day, dusk, and night, with lighting and building windows changing in sync
– Two camera modes: free observation and automatic tour
– After clicking a building, highlight the building and display a randomly generated number, height, and purpose
– Adjustment of building density, vehicle count, and tour speed
– Display of the current FPS and scene object count
– One-click regeneration of the city; the same random seed must generate the same layout
Handle window resizing, mobile touch, resource disposal, and memory issues after repeated generation. Finally, deliver an HTML file that can run directly.
GPT‑5.6 Sol：
Claude Fable 5：
GPT‑5.6 Sol buildings use custom shaders to generate windows, and horizontal rooftops automatically exclude windows, solving the problem where ordinary textures easily spread windows onto the roof.
Claude Fable 5's level of completion is very high, and it used only 478 lines. Buildings, roads, streetlights, and vehicles are all batch rendered. The contrast between blue and warm yellow windows and cyan flying vehicles is stronger, giving a stronger first impression of a traditional "future city."
But in terms of overall look, Claude Fable 5 wins; after all, no one says future rooftops cannot have windows.
case 8 Product Teardown Animation
Prompt:
Create a single-file product introduction page, with the theme being a fictional portable coffee machine.
The left side of the page is text sections, and the right side is a Three.js product model. The product model must not reference external 3D files and needs to be completed by combining basic geometries.
When scrolling down, complete the following in sequence:
1. The coffee machine rotates into the frame from the dark.
2. The shell, filter cup, water tank, and battery module separate smoothly.
3. The water flow is displayed with particle or curve animation.
4. All parts reassemble, and the camera returns to the front of the product.
When scrolling in reverse, the animation must also accurately reverse, and directly replaying is not allowed. Add section positioning, current progress, keyboard operation, and mobile layout. When the system has reduced motion enabled, use a static exploded view instead of continuous animation.
The use of framework scaffolding is prohibited. Finally, deliver one HTML file.
GPT‑5.6 Sol：
Claude Fable 5：
GPT‑5.6 Sol's model is more in line with the concept of a portable coffee machine. Claude Fable 5's fixed base, column, and coffee cup look more like a desktop coffee machine.
Claude Fable 5 is strong in animation state design, and it's only about 406 lines with a clear structure. In terms of the final result, GPT‑5.6 Sol still comes out slightly ahead in this case.
Case 9 Sokoban game
Prompt:
Create a single-file web Sokoban game; the visuals can use Canvas or DOM.
Requirements:
1. Include 8 built-in levels of increasing difficulty that are guaranteed to be solvable.
2. Support keyboard, on-screen arrow keys, and swipe controls.
3. Support unlimited undo, redo, restart, and level selection.
4. Track the number of moves, pushes, completion time, and the best record for each level.
5. After refreshing the page, retain unlocked levels and best records.
6. Boxes cannot pass through walls, overlap, or be pulled, and the character cannot leave the map.
7. Play a brief animation upon completion, but it must not prevent the player from continuing to interact.
8. The page needs to explain the controls, and display properly in both portrait and landscape on mobile.
9. Do not use external images or game assets; deliver only one HTML file in the end.
Please check on your own that each level has at least one completion path.
GPT‑5.6 Sol：
Claude Fable 5：
GPT‑5.6 Sol is much more polished visually. The page has a clear title area, level sidebar, data panel, board, control area, and status feedback; walls, boxes, target points, and boxes already on targets are all very recognizable, and it already feels like a small game ready to publish.
Claude Fable 5's main advantage is compactness: the code is only about 14KB, and core rules, keyboard, arrow keys, swiping, save data, and particle animation are all implemented, but the level difficulty is too trivial.
GPT‑5.6 Sol leads in level depth, visuals, state reliability, and detailed feedback, so the winner is GPT‑5.6 Sol.
Case 10 spreadsheet
Prompt:
Implement a mini spreadsheet formula engine from scratch in TypeScript; no UI is needed.
It needs to support:
– numbers, parentheses, and +, -, *, / operations
– cell references in the form A1, B2
– ranges in the form A1:B5
– SUM, AVERAGE, MIN, MAX, IF functions
– strings and comparisons with >, <, >=, <=, =
– cell dependency updates, recalculating only affected cells
– circular reference detection, returning a readable cycle path
– errors for empty cells, division by zero, unknown functions, and invalid formulas
– leading equals sign in formulas and case-insensitive function names
Do not use eval, the Function constructor, or third-party formula parsing libraries. Please provide a clear directory structure, core implementation, and automated tests. Tests must at least cover operator precedence, nested functions, range calculations, dependency propagation, and circular references.
GPT‑5.6 Sol：
Code:
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：
Code:
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 for non-formula cells
value: Value;
deps: Set<string>; // what this cell depends on
dependents: Set<string>; // what depends on this cell
}
/** Column letters <-> numbers */
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("Invalid address: " + addr);
return [m[1], parseInt(m[2])];
}
export class Sheet {
private cells = new Map<string, Cell>();
/** Cells actually recalculated by the most recent set operation (for incremental recalculation tests) */
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 a cell: formulas start with =; otherwise treat as number/stringliteral */
set(addr: string, raw: string): void {
addr = addr.toUpperCase();
const cell = this.cell(addr);
/* Remove old dependencies */
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);
}
/** Cycle detection: starting from addr along deps, can it return to addr; returns a readable path */
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);
}
/** Collect the affected subgraph (itself + transitive dependents), sort by dependency topology, then recompute only these */
private recalc(changed: string, selfIsError = false): void {
/* 1. Affected set */
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. Cycle detection: who in the affected set is on a cycle */
const cyclic = new Map<string, string[]>();
for (const a of affected) {
const c = this.findCycle(a);
if (c) cyclic.set(a, c);
}
/* 3. Topological sort within the affected subgraph (dependencies computed first); cells on cycles are directly set to error */
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. Evaluation */
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 has a very serious problem: as long as a formula references cells like A10 and B20 whose row numbers contain 0, it will report a formula error, and once the spreadsheet uses row 10 or beyond, many calculations may go wrong.
Claude Fable 5 successfully finished computing 100 cells, and after modifying the first number, all subsequent results are updated as well.
So Claude Fable 5 wins this round.
02. Test Summary
Across 10 test cases, GPT‑5.6 Sol clearly won 6 items, Claude Fable 5 won 3 items, and each had an advantage in one item for WeChat official account writing.
When building web pages, 3D animations, and mini-games, GPT‑5.6 Sol usually writes quite a bit more code, but the page structure, visual details, operation feedback, and exception handling are also more complete. Especially for Sokoban, the levels are more difficult, and the interface is close to a mini-game that can be published directly.
Claude Fable 5 writes shorter code, and its approach is also more concise. For the future city, it used only about 478 lines of code to complete batch buildings, roads, streetlights, vehicles, environment switching, and city regeneration, and the visuals also have more of the flavor of a traditional sci-fi city, with more natural text as well.
03. Some Sharing
After running all 10 cases, my feeling is: model leaderboards can only help us narrow things down; what really determines the experience is still the task in hand.
GPT‑5.6 Sol won more this round. Its completeness is indeed high, and many results can be used with only slight modifications, but the cost is also obvious: the code is longer, and sometimes it makes simple tasks feel heavy.
Fable 5's results are more lightweight. The code is usually shorter, and the text reads more naturally.
If you want to quickly make a web page or mini-game that looks good, is clickable, and can be demoed, you can try GPT‑5.6 Sol first. If you care more about naturalness of text, conciseness of code, fact-checking, and formula handling, you can put Fable 5 first. For formal projects, run a few more cases before deciding on your main model.
I myself would recommend: one model does it, one model checks it.
Both models are worth using; the work they are suited for is not quite the same. For ordinary users, being able to stably produce the finished product they want is what makes a model the best one to use right now.
Original link:Head-to-head showdown: Claude Fable 5 vs GPT 5.6 Sol, who comes out on top?