Claude Fable 5 vs. GPT 5.6 Sol - A Comprehensive Review

recent GPT The 5.6 series has been released, and it's been fiercely competing with the Fable 5 on various leaderboards. Everyone wants to know which one is stronger.

I'd also like to know. Instead of just looking at the rankings, let's use them directly and do some actual test cases to see which one performs better.

Case 1: Single-file webpage

Prompt words：

Create a "content scheduling dashboard" and deliver a single, ready-to-use index.html file.

The page includes 12 sample entries, with fields for title, responsible person, platform, publication date, and status. The following needs to be implemented:

1. Filter by responsible person, platform, and status;
2. 2. Search title;
3. 3. Drag the cards between the three columns: "Draft," "Pending Review," and "Published."
4. 4. Modified results are written to localStorage and retained after a refresh;
5. 5. Supports reversing the most recent status change;
6. 6. It works normally on both desktop and mobile devices;
7. 7. Do not reference external libraries, fonts, images, or online resources.

After completion, start the local service and check console errors, filtering, dragging, refresh and recovery, and mobile layout. Fix any issues found, then provide the running command and function description. Create the file and run it directly; do not stop at the solution description.

GPT 5.6 Sol：

Claude Fable 5：

Claude Fable 5's advantage is its lightweight nature; the core functionality is implemented in just 15 KB and 441 lines of code. The main issue lies in the product's overall feel; the page layout closely resembles the default backend style, resulting in an inconsistent visual language.

GPT Sol 5.6 has a much more mature page hierarchy and a complete visual system, making it look like a designed internal product. However, it is a whopping 36 KB and 1265 lines long, making it about twice as complex as the Fable version.

However, the final product quality is still quite important, and I don't think writing a few more lines of code is a problem, so this case... GPT 5.6 Sol wins.

Case 2: Scheduling with Multiple Constraints

Prompt wordsInterviews will be arranged for 8 candidates. Available times are 09:00, 10:00, 11:00, 14:00, 15:00, and 16:00, each lasting 50 minutes, with an additional 10-minute break between sessions. The company has two meeting rooms, No. 1 and No. 2.

The restrictions are as follows:

• – A and B should be interviewed by the same interviewer, and their interview times cannot overlap;
• – Option B can only be scheduled for the afternoon;
• – C can only be scheduled in the morning;
• – D must be later than A;
• – E can only use meeting room number 2;
• – F cannot be scheduled for 10:00 or 15:00;
• – G and H must be performed consecutively in the same meeting room, with G preceding H;
• – H must end before 15:00; - No interviews will be scheduled between 12:00 and 14:00;
• Each candidate may appear only once.

Provide the final schedule. Then, check all restrictions item by item and indicate available time slots. Adjust accordingly if conflicts are found; do not delete or relax restrictions.

GPT 5.6 Sol：

Claude Fable 5：

Claude Fable 5's answer was correct, and he checked each point carefully. The problem lay in F's position: at 11:00, meeting room number 1 was empty, but F was scheduled for 16:00, extending the interview by two hours.

GPT 5.6 Sol suggests scheduling F at 11:00 AM, simultaneously with A in meeting room 2. The question doesn't specify that the two interviewers share an interviewer, so this arrangement is valid.

This case GPT 5.6 Sol wins.

Case 3 Supplier Decision

Prompt words：

The company needs to decide whether to purchase the software, develop it internally, or postpone the project. Only the cash impact over the next 12 months is considered.

Given conditions:

– The total monthly cost per employee is 38,000 yuan;

– After the project goes live, it can reduce the workload of 4 employees, and the savings will be calculated from the first full month after the project goes live.

Option A:

– The annual software fee is 1.8 million yuan, payable in full upon signing the contract;

– Implementation cost: 300,000 yuan;

– Implementation will take 2 months;

– Success rate 85%;

- No refunds will be given if implementation fails, and no savings in personnel costs will be achieved.

Option B:

– Six engineers developed the product over five months, each receiving 45,000 yuan per month;

– The probability of on-time completion is 65%;

– The average usage time during the extension period is 3 months longer, and 6 people are still retained during the extension period;

– After launch, two engineers will be retained for maintenance, each receiving 45,000 yuan per month;

– Whether it goes live on time or is delayed, the project will eventually be launched.

Option C:

– A 12-month delay will not incur any additional costs or save on personnel costs.

Calculate the results for each of the three schemes:

1. Net cash impact in the event of on-time or successful completion;

2. Net cash impact in the event of failure or delay;

3. Expected net cash impact calculated on a probability basis;

4. The three main assumptions that affect the conclusion.

Write a decision memo of no more than 600 words, providing clear recommendations. All calculations must be verifiable, and all amounts must be expressed in ten thousand yuan.

GPT 5.6 Sol：

Claude Fable 5：

Claude Fable 5's analysis is more comprehensive. All three assumptions address the risks of decision-making, but...Claude Fable 5 states that B will overtake A in two or three years, but then suggests at the end that if you wait more than 24 months, you should switch to A. These two conclusions contradict each other.

GPT 5.6 Sol's answer was shorter, the calculation process was complete, and the conclusion did not exceed the 12-month range given in the question. The states, probabilities, and cash results of the three options were all calculated correctly. In the end, C was chosen, and A was chosen when it was necessary to go online, which was completely consistent with the numbers.

This case GPT 5.6 Sol wins.

Case 4: Online verification of data

Prompt words：

As of today, comparison GPT-5.6 Sol、Claude Fable 5 is the closest flagship API model to Google's current capabilities.

Use only the three company websites, developer documentation, help center, and system card. Do not cite media, blogs, aggregator websites, or search result summaries.

Please verify the following information:

– API Model ID;

– Input and output prices;

– Context window;

-Maximum output length;

– Supported input types;

– Inference intensity settings;

– Tool access and computer operation support;

– Data retention requirements;

– Current open area;

– Officially released code, professional work, and tool usage evaluations.

Each piece of information should include a direct page link and the date of access. In case of conflicting information from different official pages, list the conflicting information and explain which version to use. For information not explicitly stated on the official website, write "Not stated by the official website".

Finally, model selection is provided for repository code modification, long PDF auditing, and online surveys. Official facts are separated from personal judgments.

Claude Fable 5：

Claude Fable 5 has a minor issue...GPTThe -5.6 inference setting is incorrect; there is no minimal setting.

but GPT-5.6 Sol comparison model selectedGemini 3.5 Flash, this error is a bit bigger.

This case Claude Fable wins 5.

Case 5: Constraints in Writing

Prompt words：

Based on the product information below, write a Chinese WeChat official account article of 800 to 1000 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;

– freeUsers can recognize 500 screenshots per month;

– Pro version: 29 yuan per month;

– OCR requires an internet connection;

– Regular note editing can be used offline;

Linux is not currently supported.

– Existing users do not need to migrate their notes after upgrading;

– The official release date for the mobile app has not been provided.

Writing requirements:

– Do not fabricate user experiences, user reviews, or performance data;

– Retain all 14 facts listed above;

– Without using terms like "empowerment, ecosystem, closed loop, blockbuster, disruption, or redefinition";

– Avoid using the phrase "It's not X, but Y";

– Start by stating the version update;

– Do not use bullet points in the body text;

– This explains which users this service is suitable for, and also outlines the current limitations;

– Provides 5 headings, and headings cannot use exclamation marks.

The article includes a fact checklist, which marks each of the 14 items of information as being included and quotes the corresponding sentences.

GPT‑5.6 Sol：

Claude Fable 5：

GPT-5.6 All product information is included, and it can distinguish between information provided in the title and information not mentioned in the materials, but the main text reads like a product manual and lacks the feel of a WeChat official account.

Claude Fable 5 has a better finished look. Headings two, four, and five are all better than... GPT The corresponding title is natural, but the information goes too far: it says that if you exceed your limit or need more usage, you can subscribe to the Pro version. However, the only known information is that the Pro version costs 29 yuan per month.

This case is sorted by pure writing style.Claude Fable wins 5; sorted by multiple constraints and prohibition of fictitiousness.GPTSol wins with a score of -5.6.

Case 6 3D Solar System

Prompt words：

Create a single-file webpage that can be run directly, using... Three.js A mechanical solar system instrument is on display in a dark-colored exhibition hall.

Require:

1. The Sun, Earth, and Moon form the correct parent-child hierarchy, with the Earth revolving around the Sun and the Moon simultaneously revolving around the Earth.

2. Use gears, metal brackets, and track rings to represent mechanical structures; do not simply use a few spheres.

3. Supports dragging to rotate the view, scrolling to zoom, pausing/resume, adjusting speed, and resetting the view.

4. When you click on the Earth or the Moon, the camera will smoothly move to the corresponding celestial body and display its name, period, and current position.

5. Add soft shadows, metallic textures, ambient light, and localized highlights to avoid obscuring the structure against a pure black background.

6. The screen does not stretch after the page size changes, and it can be operated on mobile devices.

7. When the user enables "Reduce Motion Effects", it will be paused by default.automaticRotate.

8. No images, models, or audio materials are used. All structures are generated by code.

9. The final deliverable is just a single HTML file that can be opened and run.

GPT‑5.6 Sol：

Claude Fable 5：

GPT-5.6 Sol's actual image is closer to a complete mechanical exhibit, and the proportions and material distinctions between objects are clearer. In contrast, Fable's gears and base look more like a simplified model.

Claude Fable 5's advantages lie in its shorter code and easier-to-understand structure. The demonstration of the lunar and Earth cycles is converted to the scale of real cycles, which is a significant improvement over previous versions. GPT rigorous.

But overall, the winner is still... GPT‑5.6 Sol。

Case 7 Future Cities

Prompt words：

Create a single-file programmatic webpage for a future city using Three.js.

The city must contain at least 300 buildings of varying heights, roads, streetlights, flying vehicles, and distant fog effects. Buildings must be generated using InstancedMesh or other batch rendering methods; you cannot create a large number of objects for each building individually.

The page needs to provide:

– The lighting and building windows change synchronously with the switching between daytime, dusk, and nighttime environments.

– Free observation andautomaticTwo camera modes for cruise

Clicking on a building will highlight it and display a randomly generated number, height, and purpose.

– Adjustment of building density, number of vehicles, and cruise speed

- Current FPS and number of scene objects displayed

– One-clickTo regenerate the city, the same random seed must generate the same layout.

Handle window scaling, mobile touch input, resource release, and memory issues after repeated generation. The final deliverable is a directly executable HTML file.

GPT‑5.6 Sol：

Claude Fable 5：

GPT-5.6 Sol Buildings use custom shaders to generate windows; horizontal roofs will...automaticBy excluding windows, the problem of ordinary textures easily extending to the rooftop is solved.

Claude Fable 5 is highly polished and only used 478 lines of code. Buildings, roads, streetlights, and vehicles were all rendered in batches. The contrast between the blue and warm yellow windows and the cyan flying vehicles is stronger, giving it a more traditional "futuristic city" feel at first glance.

But overall,Claude Fable wins 5, after all, no one says there can't be windows on rooftops in the future.

Case 8 Product Disassembly Animation

Prompt words：

Create a single-file product introduction page with the theme of a fictional portable coffee machine.

The left side of the page contains text sections, while the right side displays a Three.js product model. The product model cannot reference external 3D files; it must be constructed using basic geometric shapes.

As you scroll down, the following steps will be performed sequentially:

1. The coffee machine rotates into the frame from the darkness.

2. The outer casing, filter cup, water tank, and battery module can be smoothly separated.

3. Water flow is displayed using particle or curve animation.

4. All parts are reassembled, and the lens is returned to the front of the product.

When scrolling reverses, the animation must also be accurately reversed; direct replay is not allowed. Include chapter positioning, current progress, keyboard input, and mobile layout. When the system is set to reduce dynamic effects, use static breakdown diagrams instead of continuous animations.

The use of scaffolding is prohibited; the final delivery should be an HTML file.

GPT‑5.6 Sol：

Claude Fable 5：

GPTThe -5.6 Sol model is more in line with the concept of a portable coffee machine.Claude The Fable 5's fixed base, column, and coffee cup make it resemble a desktop coffee machine.

Claude Fable 5 excels in animation state design, and with only about 406 lines, its structure is clear. In terms of the final effect, this case is still... GPT-5.6 Sol is slightly better.

Case 9: Sokoban game

Prompt words：

Create a single-file web-based Sokoban game; the graphics can be created using either Canvas or DOM.

Require:

1. Includes 8 levels of increasing difficulty, all of which are guaranteed to be solvable.

2. Supports keyboard, on-screen arrow keys, and swipe gestures.

3. Supports unlimited undo, redo, restart, and level selection.

4. Record the number of steps, pushes, completion time, and best score for each level.

5. Refreshing the page will retain unlocked levels and best scores.

6. Boxes cannot pass through walls, overlap, or be pulled, and characters cannot leave the map.

7. A short animation plays when the player completes the level, but it does not prevent the player from continuing to play.

8. The page needs to explain how to operate it, and it should display correctly in both portrait and landscape orientations on mobile phones.

9. Do not use external images or game assets; deliver only one HTML file in the final product.

Please check for at least one path to complete each level.

GPT‑5.6 Sol：

Claude Fable 5：

GPT-5.6 Sol has a much higher level of visual completion. The page has a clear title area, level sidebar, data panel, chessboard, operation area and status feedback. The walls, boxes, target points and boxes in the warehouse are all very easy to recognize. It already looks like a mini game that can be published.

Claude Fable 5's main advantage is its compact size; the code is only about 14KB. It implements core rules, keyboard controls, arrow keys, swipe controls, save functionality, and particle animations. However, the level difficulty is too simplistic.

GPT-5.6 Sol leads in level depth, visuals, state reliability, and detailed feedback, therefore the winner is... GPT‑5.6 Sol。

Case 10 Spreadsheet

Prompt words：

Implement a mini spreadsheet formula engine from scratch using TypeScript, without requiring a user interface.

Support required:

– Numbers, parentheses, and operations with +, -, *, /

Cell references in the form of A1, B2

– Area in the form of A1:B5

– SUM, AVERAGE, MIN, MAX, IF functions

– String comparison with >, <, >=, <=, =

- Cell-dependent updates only recalculate the affected cells.

- Detects circular references and returns a readable circular path.

- Empty cell, division by zero, unknown function, and illegal formula errors

– Leading equal sign in formulas and case-insensitive function names

Do not use eval, Function constructors, or third-party formula parsing libraries. Please provide a clear directory structure, core implementation, and...automaticTesting should cover at least the following: operator precedence, nested functions, locale computation, 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;

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 = evaluate => {

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; // Non-formula cells are null

value: Value;

deps: Set// Who does the original work depend on?

dependents: Set// Who depends on the original?

}

/** List 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) throws new Error("Illegal address: " + addr);

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

}

export class Sheet {

private cells = new Map();

/** The cells that were actually recalculated in the most recent SET operation (for testing incremental recalculation) */

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 cell formulas to begin with =; the rest should be numbers/strings */Literal quantity */

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);

}

/** Loop check: Check if it's possible to return to addr along deps, and return a readable path */

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);

}

/** Collect affected subgraphs (self + transitive dependencies), sort by dependency topology, and recalculate only these */

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

/* 1. Affected set */

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. Cycle detection: Which members of the affected set are on the cycle? */

const cyclic = new Map();

for (const a of affected) {

const c = this.findCycle(a);

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

}

/* 3. Topological sorting within the affected subgraph (dependencies are calculated first); cells on cycles are directly set to error */

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. 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 serious problem: if a formula references a cell with a row number like A10 or B20, it will show a formula error. After the table reaches the 10th row, many calculations may have problems.

Claude Fable 5 successfully completed 100 calculations. After modifying the first number, all subsequent results will also be updated.

So this round Claude Fable wins 5.

After testing 10 cases,GPT-5.6 Sol clearly won 6 items.Claude Fable 5 won 3 out of 5 categories, and WeChat official account writing had one advantage in each category.

When creating web pages, 3D animations, and mini-games,GPTVersion 5.6 of Sol typically requires more code, but offers a more complete page structure, visual details, user feedback, and exception handling. This is especially true for Sokoban, where the levels are more challenging and the interface is closer to a ready-to-play mini-game.

Claude Fable 5 allows for shorter code and a more streamlined workflow. The Future City application used only about 478 lines of code to complete the batch switching of buildings, roads, streetlights, vehicles, environments, and city regeneration. The visuals also have a more traditional sci-fi city feel, and the text is more natural.

After running 10 cases, my feeling is that the model leaderboard can only help us narrow down the scope. What really determines the experience is the task at hand.

GPT-5.6 Sol won more this round. The completion level is indeed high; many results can be used with slight modifications. However, the cost is also obvious: the code is longer, and sometimes...SimpleThe task was done too heavily.

Fable 5 results in a more lightweight design. The code is typically shorter, and the text reads more naturally.

thinkfastTo create a webpage or small game that can be viewed, clicked, and demonstrated, you can first try it out. GPT-5.6 Sol. If you prioritize natural text, concise code, data verification, and formula handling, you can place Fable 5 first. Run several test cases in a production project before deciding on the primary model.

I myselfrecommendOne model is used for data processing, and another model is used for data lookup.

Both models are worth using, but they are suitable for different tasks. For ordinary users, the best model currently available is the one that can consistently produce the desired final product.

Original link:A clash of titansClaude Fable 5 and GPT 5.6 Sol: Who is better?