TL;DR
- I gave Claude Fable 5.2 (high effort) and Claude Opus 5.5 (max effort) the same Angular 22 app to build, twice: first the features, then a visual redesign. On a public coding benchmark the two sit at the same score.
- My hidden tests couldn’t separate them: 50 passed, 1 failed, 9 skipped, for both models, in both rounds. Each one failed a different test.
- The bill could. Two rounds cost about $60 and 107 minutes with Fable high, about $90 and 167 minutes with Opus max, at list prices... even though a Fable token costs twice as much.
- Both wrote modern Angular: no
NgModule, no decorator inputs, no*ngIf. A few old habits stayed, the live polling is still a hand-managed RxJSsubscribein every app, and what differed between the two changed from one run to the next. - My pick for this kind of work is Fable high: the same score, code at the same level, about two thirds of the time and the money. And measuring was harder than building... my own tests were wrong six times, and my isolation failed three times.
My daily driver is Claude Fable, and Angular is my favourite turf; I feel at home in it. A while ago I saw a benchmark chart where Fable 5.2 on high effort and Opus 5.5 on max effort land on almost the same score, 45.3% and 45.5%, while Opus costs about twice as much per task. Same score on a general coding benchmark... but does that hold on the kind of work I actually do? I wanted to see it with my own eyes, on Angular 22. It came out in June and sits right at the edge of what these models know.

FrontierCode 2.0, redrawn from Anthropic’s chart with only these two models. The two ringed points are the pair this article compares.
The demo above is the Fable max app from round 2, running in your browser with no server behind it. It opens a few seconds before a goal. Press Restart to watch the match from the kickoff, scrub back on the timeline, or switch to the other match. Four things differ from what the model shipped: I left out the lineup builder, added the replay bar at the top, smoothed the widening of the GOAL word, and added the light theme; the model’s own design is the dark one. The demo carries two of the four matches.
#The setup
The two setups
Benchmark figures read off the FrontierCode 2.0 chart; list prices per million tokens.
| Fable 5.2 | Opus 5.5 | |
|---|---|---|
| Effort | high | max |
| Benchmark score | 45.3% | 45.5% |
| Benchmark cost per task | $6.72 | $12.82 |
| List price, input / output | $8 / $40 | $4 / $20 |
The task is a live match centre. A small local server replays four recorded football matches as if they were live, and the app has to show a match list, a live match view with a pitch and an event feed, statistics panels, a lineup builder form and a tool that compares two moments of the feed. Fifteen requirements, three extras. The brief doesn’t name a single Angular feature.
Both models got the same cheat sheet: the official Angular skill and the Angular CLI’s MCP server. That was on purpose... I wanted to see where they follow it, where they leave it, and what they invent.
Every run started clean: its own sandbox folder, Claude Code 2.1.322, and nothing of mine in it. My global config stayed out, so there was no instruction file of my own and no memory from earlier sessions. I checked that in each session’s log at launch: the right model and effort level, zero instruction files loaded, an empty memory folder, and the kickoff prompt exactly as planned. (In the pilot my global file did leak in; that story is further down.) The clean pair ran on 13 November 2026 for round 1 and on 16 November for round 2.
Each run had two rounds. Every round was a fresh session with one typed prompt and nobody around to answer questions:
- Round 1: build what the brief describes.
- Round 2: give the app its own identity and at least three “wow” moments (a goal, the data correcting itself, and their own ideas), without breaking anything from round 1.
What I measured:
- 60 hidden browser tests the models never saw, run on a copy of each finished app.
- A static scan of the code against the Angular skill, 33 rows, with the hits checked by hand.
- The session transcripts: time, tokens, tool calls, typed prompts.
- Blind code readers, one per app, with the same instructions and no model names: two on the clean pair, and later three on the final apps, Fable max included.
I ran a pilot pair first, then one clean pair with a fixed setup, then one extra run with Fable on max. The numbers below are from the clean pair unless I say otherwise. It’s the only pair where the scoring got an independent review.
#The data was a better trap than anything I could invent
The match data comes from a real provider, and real live data corrects itself. In one match the feed arrives as 145 full snapshots. Between the first and the last one, 93 events disappear again, 4 of them shots, and 679 events change their location. In another match an own goal arrives as its own pair of events, so if you count goals the naive way you get 1–1 where the real score is 1–2.
I didn’t have to design difficulty. I only had to measure what was already there and ask the app to show it: a “corrected” marker, counters, and a view that survives the feed rewriting itself.
#What the tests said
All four snapshots of the clean pair (two models, two rounds) ended the same way: 50 passed, 1 failed, 9 skipped. The 9 skipped tests are the same everywhere; the brief gives them nothing measurable to hold on to.
Read that number carefully. It doesn’t say the two apps are equally good. It says my suite is at its ceiling and can’t tell them apart. What it can tell is which test each one failed, and that’s where it gets interesting:
- Fable high loses the selected player when the other team makes a substitution. I reproduced it by hand: at one step the selection is there, at the next it’s gone, while the selected player is still on the pitch.
- Opus max highlights the player who is acting right now, but only when the newest event has a player. On 117 of 339 in-play steps (34.5%) nobody is highlighted. The brief can be read both ways, so I book this as a partial miss, not a bug.
Neither round 2 fixed or broke anything the tests can see.
The Fable bug is my favourite piece of code in the whole experiment, because both apps walked into the same room. Both built the squad list on the new Angular Aria listbox, one list per team. Opus hands each list only its own team’s value and leaves a comment saying why. Fable hands both lists the same value. When one list reorders after a substitution, it drops the id it doesn’t know and reports an empty selection, and the app writes that down as “nothing selected”. Same building block, same afternoon... one run saw the trap, the other didn’t. Fable’s own 101 tests were green the whole time.
One more measured difference: during 30 live updates, Fable’s round 2 app produced 13 to 16 long tasks on the main thread across three repeats, the longest 171 ms. Opus produced none. Fair warning, the two apps are served differently by their own start scripts, so this isn’t purely the code.
#What the bill said
Round 1: time, tokens and cost
From the session transcripts of the clean pair, priced at list prices.
| Fable high | Opus max | |
|---|---|---|
| Wall clock (minutes) | 48.8 | 75.7 |
| API messages | 99 | 227 |
| Output tokens | 251k | 403k |
| Cached input re-read | 31M | 98M |
| List-price cost | $23.17 | $32.76 |
| Typed prompts | 1 | 1 |
Round 2: time, tokens and cost
Same sources. Opus max also ran a review agent of its own, counted in its cost.
| Fable high | Opus max | |
|---|---|---|
| Wall clock (minutes) | 58.6 | 91.5 |
| API messages | 167 | 334 + 107 in its own review agent |
| Output tokens | 309k | 515k |
| Cached input re-read | 71M | 196M |
| List-price cost | $36.50 | $57.37 |
| Typed prompts | 1 | 2 |
Two rounds together: Fable high $59.67 and 107 minutes, Opus max $90.13 and 167 minutes. The runs went on a subscription, so the dollars are list-price estimates.
A Fable token costs twice as much as an Opus token, and Fable still came out about a third cheaper. The reason isn’t the output. On max effort Opus made more than twice as many calls, and every call re-reads the conversation so far. Cached input is cheap per token, but at 196 million tokens it becomes the biggest line on the bill.
Let me be honest about the clock:
- Round 1 ran during a network hiccup on my side. Both sessions silently retried for a few minutes. Net of that, Fable is at about 43 minutes and Opus at 68 to 74.
- In round 2, Opus lost its connection once and I typed
continue. That’s the second typed prompt in the table. - Opus also started a review agent of its own in round 2, waited 18 minutes for it, and fixed the 8 things it found. Nobody asked for that. I count the waiting as part of its time and the agent as part of its cost... and I also think it was a good call.
#How they used Angular 22
The question I expected to write about was “who still writes old Angular”. The answer is nobody. No decorator inputs, no NgModule, no *ngIf, no constructor injection, no zone. Opus kept three old habits that do no harm: @Injectable() in 3 places, OnPush spelled out 17 times although it’s now the default, and the deprecated withFetch().
The modern core is the same in both apps: signal forms, httpResource, @defer with @boundary around the panels, view transitions, route parameters as inputs. Both skipped the same newer APIs, resource(), injectAsync() and debounced() among them. (Fable on max, further down, did use resource() and rxResource.)
Then the surprise, in the pilot, Fable processed the feed in a web worker and Opus didn’t. Fable ignored Angular Aria and Opus used it. In the clean pair it was the other way around, on every one of those points. So these are choices that change from run to run, and I stopped writing sentences that start with “Fable does” or “Opus does”. With one run per model you’re looking at one roll of the dice.
Two things did repeat in both pairs: Opus splits the work into more services, and Fable on high keeps growing one central store (704 lines in the pilot, 883 in the clean run). Even that isn’t a model trait... on max effort Fable split the same job into two smaller, sealed classes.
The cheat sheet itself was wrong in one place. The skill recommends a --ai-config value the CLI no longer accepts. Fable followed the skill and got rejected, in both pairs. Opus read ng new --help first, in both pairs. Leaving the cheat sheet was the right decision here, and only one of them made it.
#The look
Round 1 produced two grey dashboards. That one is on me: the brief had fifteen functional requirements and not a word about design, and both models optimised for what I measure.
Round 2 asked for an identity, and this happened: within five seconds of each other, in separate sandboxes, before they shared anything, both wrote down the same concept and the same name. “Floodlit”: a night match under the lights, with a dot-matrix scoreboard. Opus put the name in its header. Fable kept it for its README and wrote “Under the lights” on the page, as you can see in the screenshots below. The task text says “broadcast”. It doesn’t say night or lights. In the pilot both had picked a floodlit night stadium too, and so did Fable on max later. Five redesigns, five night matches under the lights.


Fable high, then Opus max: round 2, the same moment of the same match. Team and player names are invented.


The same goal in both apps.
I’m not giving a verdict on which one looks better.
#Fable on max
The first objection to all of this is obvious: you compared high with max. So I ran Fable once on max effort, alone, through both rounds. One run, and a messy one, so treat it as a single data point. Its cost is a lower bound, because one of the two compaction requests is missing from the transcript.
Both rounds together, all three runs
One run per column. Fable max is a single side run; its cost is a lower bound. Long tasks: in 30 live updates of the round 2 app. Human steps: beyond the two kickoff prompts.
| Two rounds together | Fable high | Opus max | Fable max |
|---|---|---|---|
| Time (minutes) | 107 | 167 | 356 |
| List-price cost | $59.67 | $90.13 | at least $202 |
| Hidden tests, each round | 50 / 1 / 9 | 50 / 1 / 9 | 50 / 1 / 9 |
| Source lines after round 2 | 12,043 | 12,302 | 17,273 |
| Own tests after round 2 | 101 unit | 123 unit | 243 unit + 56 in a browser |
| Long tasks | 13 to 16 | 0 | 0 |
| Extra human steps | 0 | 1 | 4 |
The first two columns are wall clock, including the waits I described above. The Fable max column has the hours it sat waiting for me taken out.
More than three times the time and the money of Fable high, and the hidden tests land on the same number. Again.
It didn’t make either of the two mistakes above. It made a third one: after a formation change, a field in the lineup builder keeps showing a player the form no longer holds. The bug sits in a searchable player picker that only this run built; the other two used a plain dropdown. Its own test checked the form’s state and not the text in the field, so it stayed green, in both rounds.
What the extra effort did buy is visible everywhere else. Of these three runs it’s the only one with browser tests of its own, including accessibility checks, keyboard handling and a phone-sized screen. All 243 unit tests and 56 browser checks passed when I ran them, exactly as its final report said. It also spent a long stretch of round 2 profiling its own redesign, and the finished app shows no long tasks in my measurement.
It also filled its context window, once in each round. The last request before the session stopped was 975,193 tokens in round 1 and 973,938 in round 2, against a limit of 1 million. Both times I had to compact the session and type continue, and that’s where the four extra steps come from. For comparison, the biggest request of Fable high was 645 thousand tokens and of Opus max 800 thousand.


Fable max, round 2: the match view and the same goal.
More effort bought more tests, more accessibility work and more code. On my suite it didn’t buy a better score... which says as much about my suite as about the model.
#Reading the code
The hidden tests look at the apps from the outside. For the inside I used three more blind readers: one read-only agent per final app, the same twelve questions, no model names. They ran nothing; where a claim mattered, I checked it with a script or a probe. It’s still one run per model, so read every difference below as “this run”, not “this model”. Fable max also wrote about 40% more code than the other two.
Short answers first:
Short answers from the code read
Counted by script in the final apps, tests left out.
| Fable high | Opus max | Fable max | |
|---|---|---|---|
| Store library (NgRx and friends) | none | none | none |
ngOnDestroy | 0 | 0 | 0 |
DestroyRef.onDestroy | 6 | 10 | 14 |
Manual .subscribe( calls | 6 | 5 | 6 |
| …nested in another subscribe | 2 | 0 | 0 |
takeUntilDestroyed | 0 | 0 | 0 |
catchError in a pipe | 0 | 0 | 1 |
| Cleanup defects found | 0 | 0 | 1, confirmed at runtime |
| Web worker for the feed | no | yes | yes |
| Own tests, all green | 101 | 123 | 243 + 56 in a browser |
Folders and names
All three landed on the same three layers: plain logic at the bottom, shared building blocks, features on top. In none of them does the bottom layer import upwards.
Fable high Opus max Fable max
src/app/ src/app/ src/app/
├─ domain/ 12 ├─ domain/ 12 ├─ core/ 28
├─ core/ 2 ├─ data/ 5 │ ├─ api/
├─ shared/ 6 ├─ shared/ 4 │ ├─ feed/
├─ match/ 36 ├─ match/ 34 │ ├─ feed-worker/
│ └─ stats/ │ ├─ compare/ │ ├─ live/
├─ match-list/ 4 │ ├─ stage/ │ ├─ stage/
├─ lineup/ 3 │ └─ stats/ │ └─ stats/
└─ compare/ 3 ├─ match-list/ 4 ├─ features/ 39
└─ lineup/ 3 │ ├─ match/
│ ├─ match-list/
│ ├─ lineup/
│ └─ not-found/
└─ shared/ 8
The numbers are files per top-level folder, tests left out; the folders are listed bottom layer first, not alphabetically.
Fable max is the most finely divided at the bottom and has the biggest files on top. 30 of its 32 components keep the template inside the .ts file and 28 the CSS as well, so 12 files pass 400 lines where the other two have 2 each. It also has the only import from one feature into another.
The naming is the Angular 22 house style everywhere: match-session.ts with no type suffix, class names with no suffix, app- selectors. The readers found slips in every app. Fable high has four names for one thing, a withdrawn event: removed, withdrawn, gone and Tombstone. Opus max uses the same name for an interface and a component, so one of them has to be renamed on import. And in Fable max “replay” means two different things.
No store library, three hand-made stores
Nobody reached for NgRx or any other store library. All three wrote a signal-based state class that the match view provides, so it gets destroyed together with the view when you switch matches.
Where they differ is how well that state is sealed:
- Fable high: one store of 883 lines with 15 signals anyone can write to. And its components do write to it, in 5 places.
- Opus max: a session class (498 lines) and a “broadcast director” (624 lines), with 29 publicly writable signals between them and one outside write.
- Fable max: two classes of 386 and 299 lines, and not a single signal that can be written from outside.
This is all it takes:
// Fable max, match-session.ts
private readonly liveState = signal<LiveState | null>(null);
private readonly liveStatusState = signal<LiveStatus>('idle');
private readonly liveErrorState = signal<unknown>(null);
// …
readonly live = this.liveState.asReadonly();
readonly liveStatus = this.liveStatusState.asReadonly();
readonly liveError = this.liveErrorState.asReadonly();
Don’t get me wrong, sealing the state didn’t make the complexity go away. Every app has one class that knows too much... they only put it in different places. In Fable high it’s the store, in Opus max the director, and in Fable max a 663-line match view component.
Polling, three ways
The brief asks for one request per second. A resource loads when its inputs change; it isn’t built for a steady beat. So for the live feed all three dropped down to RxJS, and all three did it the old way. The old-style subscribe with next and error handlers is still here: 6 manual calls in Fable high, 5 in Opus max and 6 in Fable max, and 10 of those 17 take both a next and an error handler, like the one below. Around them sits everything that comes with the pattern: their own error handling, loading and error flags set by hand, the Subscription stored in a field. Nobody used takeUntilDestroyed, toSignal or the async pipe. The only modern touch is the shape of the call: the handlers are passed as one observer object, not as two separate arguments.
Fable high treats RxJS as a pipe for HTTP and does the timing itself:
// Fable high, match-store.ts
private poll(): void {
const id = this.id();
if (id === null || this.destroyed) return;
const startedAt = Date.now();
clearTimeout(this.slowTimer);
this.slowTimer = setTimeout(() => this.feedSlow.set(true), 3 * POLL_INTERVAL_MS);
this.pollSub = this.api.feed(id).subscribe({
next: (response) => {
clearTimeout(this.slowTimer);
this.feedSlow.set(false);
try {
this.acceptLive(id, response);
} catch (error) {
this.failLive(error);
return;
}
const wait = Math.max(0, POLL_INTERVAL_MS - (Date.now() - startedAt));
this.pollTimer = setTimeout(() => this.poll(), wait);
},
error: (error: unknown) => this.failLive(error),
});
}
Follow acceptLive and on one path it starts a second subscription of its own, from inside this next. Not nested on the page, nested all the same. It happens twice in this app, and nested subscriptions are on my own list of things I flag in a review.
Opus max lets the operators do the scheduling:
// Opus max, match-session.ts
private startLive(): void {
this.liveSub?.unsubscribe();
this.liveStatus.set(this.live() ? 'ready' : 'loading');
this.liveError.set(null);
// exhaustMap: one request at a time, started on the next whole second after the previous one.
this.liveSub = timer(0, POLL_INTERVAL_MS)
.pipe(exhaustMap(() => this.pollOnce()))
.subscribe({ error: (error: unknown) => this.onLiveError(error) });
}
Fable max builds “one request, then wait out the rest of the second, then again” out of defer, concat and repeat:
// Fable max, live-feed.ts
return defer(() => {
const started = Date.now();
const rest = defer(() =>
timer(Math.max(0, POLL_INTERVAL_MS - (Date.now() - started))),
).pipe(ignoreElements());
return concat(once(), rest);
}).pipe(
repeat(),
finalize(() => {
if (channel !== null) this.decoding.release(channel);
}),
);
It’s also the only one that wrote the polling once. This lives in a shared service that the match view and the match list both poll through, and the compare tool reads single steps from it. The other two wrote their polling twice, once for the match and once for the list.
catchError shows up exactly once in the three apps, and it’s in Fable max. Fable high and Opus max handle every failure in the error callback of the subscribe. Fable max does the same for its polling, but in the scrubber it catches inside the pipe:
// Fable max, match-session.ts
// Turned into state here, so that the stream of scrub requests itself stays alive.
catchError((error: unknown) => {
this.onScrubFailure(target, error);
return EMPTY;
}),
That’s the textbook place for it: the error is handled on the inner request, so one failed step doesn’t end the outer stream of scrub requests.
Cleanup: DestroyRef in the constructor
ngOnDestroy doesn’t appear once in the three apps. Every component and service constructor is parameterless, dependencies come from inject(), and cleanup is registered through DestroyRef: 6, 10 and 14 times. The big state classes do it in the constructor. Smaller pieces register it right where the listener or observer is created, inside an afterNextRender callback or in a helper function.
// Fable high, match-store.ts
constructor() {
inject(DestroyRef).onDestroy(() => {
this.destroyed = true;
this.pollSub?.unsubscribe();
this.markerSub?.unsubscribe();
this.scrubSub?.unsubscribe();
clearTimeout(this.pollTimer);
clearTimeout(this.slowTimer);
clearTimeout(this.restTimer);
clearTimeout(this.goalTimer);
clearTimeout(this.phaseTimer);
for (const timer of this.expiryTimers) clearTimeout(timer);
});
}
// Opus max, match-session.ts
constructor() {
this.destroyRef.onDestroy(() => {
this.destroyed = true;
this.liveSub?.unsubscribe();
this.historySub?.unsubscribe();
if (this.settleTimer) clearTimeout(this.settleTimer);
if (this.leaveTimer) clearTimeout(this.leaveTimer);
});
}
// Opus max, feed-processor.ts: the service that owns the web worker
constructor() {
inject(DestroyRef).onDestroy(() => this.worker?.terminate());
}
I like how this reads: one place, and it looks like a checklist. It has the same weakness ngOnDestroy always had, though. The checklist is kept by hand, and whatever you forget is simply not on it.
Fable max shows exactly that:
// Fable max, match-session.ts
constructor() {
this.scrubRequests
.pipe(
switchMap(({ target, immediately }) => {
if (target === null) return EMPTY;
return timer(immediately ? 0 : SCRUB_REST_MS).pipe(
switchMap(() => this.loadStep(target)),
);
}),
)
.subscribe();
inject(DestroyRef).onDestroy(() => {
this.destroyed = true;
this.polling?.unsubscribe();
this.scrubRequests.complete();
this.pulseSubject.complete();
this.restartSubject.complete();
this.returnSubject.complete();
if (this.watchdog !== null) clearInterval(this.watchdog);
});
}
Look at the first statement: a subscription whose handle nobody keeps. On destroy the class completes scrubRequests, which stops new values, but it doesn’t cancel a timer that’s already running inside the switchMap. So move the scrubber, leave the match within a quarter of a second, and the app still sends the request for that step, in the name of a view that no longer exists.
The reader flagged it from the code, and I went and tried it:
- Scrub, then leave: Fable max sent the late request 6 times out of 6, about 250 ms after leaving. Fable high and Opus max, 0 out of 6.
- Scrub, then stay (the control): all three send the request, 3 out of 3, so the probe really did move the slider in every app.
It’s one wasted request and nothing piles up, so I’m not calling it a memory leak; I didn’t measure memory at all. But the class’s own comment says requests in flight are cancelled, and its test only checks that polling stops. takeUntilDestroyed() is the textbook tool for exactly this line, and none of the three apps uses it.
The readers also kept a ledger of everything that outlives a function call (subscriptions, timers, listeners, observers, workers, growing collections) and looked for its release: 29, 41 and 45 entries. This was the only candidate. By their reading, no collection grows with every poll in any of the apps.
The new Angular, in use
Call sites in the app code, tests left out:
New Angular features, call sites
Counted by script in the app code, tests left out.
| Fable high | Opus max | Fable max | |
|---|---|---|---|
httpResource | 5 | 3 | 1, inside a shared helper |
resource / rxResource | 0 / 0 | 0 / 0 | 1 / 1 |
linkedSignal | 1 | 2 | 9 |
effect / afterRenderEffect | 7 / 0 | 9 / 0 | 3 / 4 |
@defer blocks | 4 | 2 | 0 |
@let | 17 | 1 | 0 |
asReadonly() | 4 | 0 | 17 |
| Signal form | 1 | 1 | 1 |
@Service() / @Injectable() | 3 / 0 | 3 / 3 | 9 / 0 |
By the readers’ count, 4 of Fable high’s 7 effects and 6 of Opus max’s 9 write to a signal; none of Fable max’s 7 do so synchronously.
linkedSignal is the one I was most curious about. Here’s the plain form, state that follows something else until the user overrides it:
// Opus max, pass-network.ts
/** Follows the selected player's team; the toggle can override it. */
protected readonly side = linkedSignal<TeamSide>(() => {
const id = this.session.selectedPlayerId();
return (id !== null ? this.session.squadData()?.byId.get(id)?.side : undefined) ?? 'home';
});
And the form with previous, used here to decide whether the event list should animate a change or swap quietly:
// Fable high, event-list.ts
protected readonly rendered = linkedSignal<
{ rows: readonly FeedRow[]; key: number | null },
Rendered
>({
source: () => ({ rows: this.filtered(), key: this.store.selectedPlayerId() }),
computation: (source, previous) => ({
rows: source.rows,
quiet:
!previous ||
previous.source.key !== source.key ||
churn(previous.source.rows, source.rows) > ANIMATE_LIMIT,
}),
});
Signal forms, with a server-side name check that waits until typing stops:
// Opus max, lineup-page.ts
protected readonly lineupForm = form(this.model, (s) => {
required(s.name, { message: 'Enter a name for the lineup.' });
validate(s.name, ({ value }) => {
const problem = value().trim() === '' ? null : nameProblem(value());
return problem ? { kind: 'length', message: problem } : undefined;
});
// C12: checked against the server while typing, once typing has stopped for 300 ms.
// httpResource cancels a superseded check, so a stale answer never wins.
validateHttp(s.name, {
request: ({ value }) => (nameProblem(value()) === null ? this.api.nameAvailableUrl(value().trim()) : undefined),
debounce: 300,
onSuccess: (response: unknown) =>
isAvailable(response) ? undefined : { kind: 'taken', message: 'This name is already taken.' },
onError: () => ({ kind: 'check-failed', message: 'The name could not be checked. Edit it to try again.' }),
});
// …
});
Lazy panels. Fable high wraps each statistics panel in @defer inside a @boundary; Opus max uses @defer too, in two blocks:
<!-- Fable high, match-view.html -->
@boundary {
@defer (on viewport) {
<app-shot-map />
} @placeholder {
<div class="stat__placeholder"></div>
} @loading (minimum 150ms) {
<div class="stat__placeholder skeleton" role="status" aria-label="Loading shot map"></div>
} @error {
<app-panel-error message="The shot map could not be loaded." (retry)="reloadPage()" />
}
} @error {
<app-panel-error (retry)="$reset()" />
}
Notice what Retry does when the chunk fails to load... it reloads the page. Fable max didn’t use @defer at all. Its own comment gives the reason: a defer block remembers a failed load for the lifetime of the page, while a dynamic import in a resource can simply be run again. So it wrote this, with an IntersectionObserver flipping inView:
// Fable max, lazy-panel.ts
/** The panel's component class; requested once the frame has been seen. */
protected readonly code = resource({
params: () => (this.inView() ? this.loader() : undefined),
loader: ({ params: load }) => load(),
});
and the failed state gets a Retry that only reloads the code:
@case ('failed') {
<app-failure-notice
kind="panel"
title="This panel could not be loaded."
[detail]="describe(code.error())"
(retry)="code.reload()"
/>
}
More code for a better Retry button. Is that trade worth it? Fair question; I would probably have shipped the @defer.
And rxResource, for the tool that compares two steps of the feed. Two requests in parallel, and loading, error and cancellation come for free:
// Fable max, step-compare.ts
protected readonly result = rxResource({
params: () => this.request() ?? undefined,
stream: ({ params }) =>
forkJoin({ first: this.load(params.first), second: this.load(params.second) }),
});
Fable high and Opus max wrote that same compare with a manual subscribe and their own flags.
Performance choices
- Fable high processes every new step on the main thread and builds a new row object for every event each time. That matches the long tasks I measured earlier.
- Opus max parses in a web worker, skips a response whose hash hasn’t changed and keeps the object of an unchanged event, but still rebuilds all the rows.
- Fable max also works in a worker, sends only the differences across, and rebuilds only the rows that changed. The reader caught a repeat, though: its summary function runs three times on the main thread for every step whose events changed.
- None of them uses virtual scrolling. All three rely on
content-visibility: autofor the long list.
Tests: what is covered, what is not
All three test the data processing thoroughly (ordering, duplicates, counting corrections, the score) and the main state class with fake timers and fake HTTP, down to the 250 ms rest of the scrubber. After that it thins out.
- Fable high, 101 tests in 9 files: nothing renders a component. The pitch’s motion, the polling of the match cards, the wiring of the lineup form and the compare page are untested.
- Opus max, 123 tests in 13 files: one rendered test, the lineup form. The 624-line director has no test at all, and neither has the worker path.
- Fable max, 243 tests in 17 files, plus 56 browser checks: the components and one of its two state classes are reached only from the browser checks. Those compare the screen against expectations computed from the recordings, not from the app’s own code, and they include keyboard, accessibility and failure paths.
And here’s the uncomfortable part: none of the three suites caught the one failure my hidden tests found in that same app. Not even the one with 299 checks.
Could a junior follow it?
Three probes of readability
The blind readers' counts, one reader per app. Files to follow one poll: from the HTTP call to a player moving on the pitch.
| Probe | Fable high | Opus max | Fable max |
|---|---|---|---|
| Files to follow one poll | 15 | 12 | 17 |
| Files for a new statistics panel | 5 | 3 | 4 |
| Longest function | 173 lines | 179 lines | 129 lines |
These three rows are the readers’ counts. I also asked each reader for scores from 1 to 5, with fixed anchors, so that a number means something:
- Readable for a junior (one year of Angular): 1 means they can’t follow the main data flow without help. 3 means they can follow it with effort, and several files need a senior to explain. 5 means they can follow one poll from the HTTP call to the pitch alone, in an hour.
- Readable for a senior: 1 means fighting the code. 3 means fine, but with surprises. 5 means no surprises, and they would approve the structure in a review.
- Extensibility: 1 means every change touches one giant class. 3 means a common change touches 3 to 5 files and there is one hot spot. 5 means changes stay local.
All three apps got the same scores: 3 for a junior, 4 for a senior and 3 for extensibility. In plain words, a junior can find their way through any of them, but not alone; a senior reads them comfortably and still meets a few surprises. Three different readers gave the scores, so a one-point difference anywhere is noise.
What stops a junior is different in each: the 883-line store in Fable high, the worker and the director in Opus max, and in Fable max simply the number of files, plus a worker that speaks its own delta protocol. The comments help in all three. They mostly explain why, not what.
My read of the read: the three apps are at one level. The extra effort of Fable max shows up as sealed state, polling written once and far more tests. The same run produced the only confirmed cleanup defect and the longest path through the code. More code didn’t turn into code that’s easier to follow.
#What went wrong on my side
I got several things wrong, and I think they’re the most useful part of this.
- My tests were wrong six times. On the first scoring run, four hidden tests failed on both pilot apps, with identical numbers. All four were my tests’ fault. In round 2, two more. If I hadn’t read the failures, I would have scored both models at 92% where 100% was the truth.
- A contestant saw something the judges missed. The data contains duplicate event ids inside one snapshot. Opus noticed and handled it. My reference answer didn’t, and failed both apps for it.
- My “clean” setup wasn’t clean. In the pilot, my global instruction file loaded into every session despite the flag that should have kept it out. I found it by reading the transcripts, not by asking the model.
- Folders don’t isolate ports. In round 2 the two parallel runs both picked the same obvious Chrome debugging port and shared a browser for half an hour. Each got a glimpse of the other’s page: a few hundred characters of HTML one way, a log the other way. Both noticed within a minute and moved. The concepts were already written down by then, and nothing was taken over... but it happened.
- Folders don’t isolate processes either. Every run cleaned up its servers by name. In the clean pair, Opus’s cleanup once stopped Fable’s dev server too, because both start scripts had the same file name. Fable restarted it within seconds and blamed its own half-edited files. The pilot runs used the same kind of command side by side, and I haven’t checked them for it.
- My live numbers were wrong. While the runs were going I counted transcript lines as messages and reported 234 and 669 where the real numbers are 99 and 227.
The fix for the two leaks is boring: run agents one after another, or give each its own container. I’ll do that next time.
#What this doesn’t tell you
- One clean pair, one run per model. It says nothing about variance, and the flipped details between the pilot and the clean pair show how much there is.
- The hidden suite is at its ceiling. It finds bugs; it can’t rank these two.
- The code read is reading. Apart from the one probe and each app’s own test suite, nothing in it was run, and I measured no memory at all. “No leak found” means three readers didn’t see one.
- The two models don’t get exactly the same system prompt from the tool, and I can’t even that out.
- The scoring tools and the code comparison were built with Fable’s help. The judgement calls were read blind and need a human signature, which is mine.
- The match data is licensed, so there’s no public repo. The demo runs on the same recordings with every id, name and date replaced.
#My take here
Fable high is my pick for this kind of work. The same score on my tests, in about two thirds of the time and for about two thirds of the money. Opus max is the more careful colleague: it read the help page first, it left the comment at the trap, it ordered its own code review. Don’t get me wrong, neither is perfect. Each shipped exactly one thing my tests caught, and both told me in their final report that everything was done. The code read didn’t change the pick either: the three codebases are at one level. Fable high’s is the smallest and the plainest, with a store its components write into directly, and at this price I can live with that.
Keep one thing in mind when you read the code section: all of it happened without instructions from me. Nobody told the models how to lay out the folders, how to build the components, or whether template, styles and logic belong in one file or in three. They had the brief and the official Angular skill, and every one of those choices was theirs. That’s also the good news about what was left behind. A manual subscribe here, a 663-line component there, CSS inside the .ts file... these are exactly the things a few lines of instruction change. That last part is my experience from the day job, not something this test measured.
And to my surprise, with the Angular skill at hand these models work really, really well with Angular 22. They aren’t guessing. The linkedSignal that looks at its previous value, the written-down reason for skipping @defer, the comment next to exhaustMap... they know what each tool is for, and they know how to use it.
What I didn’t expect is how little the choice between the two models mattered next to the choice of how to measure them. The models built the app in an hour or two. Getting to numbers I trust took me days.
