I asked if Claude had got worse. Then Fable 5.1 arrived.

I gave Claude Fable 5.1 a real job in Claude Code: build KINTAL a secure Google data connector. The experience was markedly different from the one that prompted our previous article.

Earlier this week, we published an article asking whether Claude had got worse.

It came from experience rather than benchmarks. Claude had become harder for us to work with, particularly on longer tasks. It was challenging instructions that did not need challenging, reopening decisions we had already made and adding friction to work that should have been straightforward.

We had started moving some tasks elsewhere.

Then Anthropic released Claude Fable 5.1 on 1 September.

A few days later, I gave it a job complicated enough to tell me whether anything had really changed.

A proper test

KINTAL uses Google Analytics and Search Console, like thousands of other businesses. Both contain useful evidence, although neither is especially pleasant when you simply want an answer to a business question.

I wanted one secure, read-only connector that would let us ask questions of our own GA4 and Search Console data directly from Claude, ChatGPT and Codex.

Questions such as:

• What traffic changed this month?
• Which landing pages are performing differently?
• Where are people finding us through AI assistants?
• Which search queries are getting impressions without clicks?
• What actually changed compared with the previous period?

The connector needed to be remote, private to KINTAL, read-only by construction and restricted to approved properties. I also wanted the simplest architecture that could do the job, without adding a database, another authentication service or infrastructure we did not need.

The consequential decisions needed to stay with me.

I am technically confident, but I am not a software engineer. That made this a useful test of agentic coding because I wanted to see whether I could direct a fairly serious technical build without becoming the person writing the Cloudflare Worker.

The difference showed up before any code

My opening instruction to Fable 5.1 was to research the existing KINTAL connector patterns and current GA4 and MCP capabilities, propose the simplest secure architecture, then stop.

It inspected what we already had, researched Google, Cloudflare, Claude, ChatGPT and Codex, challenged some assumptions and returned with an architecture proposal.

The proposal recommended a single Cloudflare Worker, Google sign-in for caller identity, a dedicated service account for the analytics data and structural controls limiting exactly which Google API paths the connector could call.

It also rejected approaches I had expected might make sense, including reusing our existing Supabase infrastructure and copying another connector architecture too closely.

The part I noticed most was what happened after the proposal: it stopped and waited.

After the previous few weeks with Claude, that mattered because my frustration had often come down to the difference between useful challenge and repeated reinterpretation. Fable 5.1 questioned decisions while they were still open, then generally moved on once I had made them.

That made the whole build easier to work through.

Five gates, with the important decisions staying human

We worked through the build in five gates, with the decisions around scope, access, infrastructure and risk staying with me while Fable handled most of the implementation.

It paused before writing code, before deployment, before configuring the live AI clients and before creating the repository's main branch. When Google required a real permission change or credential, I handled it. When the work involved code, tests, documentation or configuration, Fable did most of that.

My part of the build was often very ordinary. I copied IDs from Google Cloud, confirmed which account owned a property, approved changes and reported back when each step was complete. I never felt that I needed to understand the underlying code before I could make the next decision.

One small incident says quite a lot about how the process worked. At one point Nate was at the keyboard and access came up, but Fable did not treat that as sufficient authorisation. It waited for me to confirm that Nate should be added because that was the access rule we had already agreed.

For agentic work, capability is only part of the picture. The system also needs to understand where authority sits.

It still made mistakes

The final review found eight defects, including one significant calculation error. An average session duration calculation was summing averages, producing 1,740 seconds where the correct weighted figure was 128 seconds.

That is exactly the type of technical error that concerns me with AI-generated work because the number looked plausible and was presented confidently.

Another problem was procedural. A shell command piped a failing test through grep, which masked the exit status and allowed deployment to continue despite the failed test. Fable later described that as the mistake that concerned it most.

There were other issues involving GA4 metrics, comparison ranges, zero-filled rows, truncation reporting and caching, and five presentation defects only became visible when we tested against live data.

They were found, corrected and recorded, which is why the checks around the build were essential. The improvement was that those checks felt proportionate to the work. I was supervising a capable system rather than repeatedly trying to keep it pointed at the original task.

Anthropic says some of this has changed

Anthropic has been unusually clear that Fable 5.1 responds to customer feedback, saying in its launch material that the release takes steps towards addressing feedback on price, data retention and safeguards.

The system cards give that statement some substance.

Fable 5 introduced additional classifiers around areas such as cybersecurity and biology. When those classifiers triggered, users could be moved to a fallback model or blocked depending on the product surface. Anthropic documented that mechanism in the original Fable 5 system card.

With Fable 5.1, Anthropic says those safeguards produce fewer false positives than Fable 5 did at launch, although they can still trigger more readily than the safeguards around Opus 5.

Another finding caught my attention because it relates directly to the experience I had. In its behavioural audit, Anthropic says the new model is less likely than previous models to ignore explicit constraints, hallucinate inputs or falsely claim that it has completed tasks.

For me, that is more useful than another small improvement on a coding benchmark because those behaviours affect whether a model can work through a long task without creating unnecessary supervision overhead.

Anthropic also reports stronger performance on long-horizon agentic and professional knowledge work, and says Fable 5.1 can match or exceed Fable 5 at roughly half the cost per task on some agentic coding evaluations.

The system card gives reasons to remain cautious too. Anthropic records rare cases where the underlying Mythos 5.1 model worked around broken permission hooks or overstated authorisation. It reports these in fewer than 0.01% of monitored completions and also notes some weaker honesty behaviour under pressure.

The evidence therefore points to measurable improvement in some areas rather than a blanket claim that every problem has disappeared, which matches my experience.

The cost surprised me

Claude Code reported $90.63 of API-equivalent model usage for the build.

I use a Max subscription, so there was no additional $90.63 charge to me. The figure is still useful because it gives an indication of the equivalent model usage involved in taking the project from a business requirement through research, architecture, implementation, testing, deployment and final review.

The live infrastructure itself costs us $5 a month for Cloudflare Workers after testing showed that the connector exceeded the free CPU allowance.

For a small business, those economics are interesting because a piece of infrastructure that previously would have required specialist development can now be built with much more of the implementation handled by the model, while the business owner concentrates on scope, permissions, risk and what the system is actually supposed to do.

What we ended up with

KINTAL now has one live, read-only Google Data MCP that Claude Code, Claude.ai, Cowork, ChatGPT and Codex can use to query our GA4 and Search Console data.

The connector only reaches the approved KINTAL properties. The code limits the Google API routes it can call, while authentication controls who can use it separately from the controls governing what information it can read.

It also has a documented architecture, nine decision records, test coverage, a final security review and a lessons file containing the things that went wrong.

I like that the mistakes are part of the record because, for this kind of work, a clean audit trail is more useful than pretending the build went perfectly.

What changed for me

This experience changes my view of Fable 5.1 because the improvement showed up in the working relationship as much as the output.

It researched before acting, challenged assumptions when there was still a decision to make and generally respected the decision once it was made. It also handled a long technical job without making me repeatedly explain the same context, and when it made mistakes the process around the work gave us sensible places to catch them.

That is much closer to the experience I want from an AI system.

The connector may be the more important story

Building it also changed my thinking about the systems businesses already have.

GA4 and Search Console contain data we own, yet getting useful answers from them has traditionally meant learning Google's interfaces, configuring reports or asking someone else to extract the information.

Now I can ask the question where I am already working.

For creative agencies and other businesses using Google, that pattern could matter more than adding another standalone AI product to the stack because most companies already have useful evidence spread across analytics, search data, documents, communications and operational platforms.

A well-designed connector can give AI controlled access to the parts people need without handing it unrestricted access to everything. The complexity sits underneath the connection in the form of permissions, scopes, authentication and data boundaries, while the experience for the person using it can stay simple.

I did not need to know how to write the Worker. I needed to understand what the connector should be allowed to do, who should have access and which decisions required human approval, while Fable 5.1 handled a surprising amount of the rest.

And the story has already moved again

While I was finishing this article, OpenAI announced GPT-6 Astra on 3 September. OpenAI says Astra improves coding, research, computer use and complex multi-step work, with availability starting with a limited set of organisations and expanding across paid ChatGPT plans over the following days.

The timing says a lot about where we are. Within a few days, I went from publishing an article questioning my experience with Claude, to having one of my best experiences with Claude Code, to seeing another frontier model arrive before I had finished writing about the first one.

For businesses, the idea of choosing a single "best model" is becoming less useful because models change, as do their safeguards and the products around them. Something that created friction in August can behave very differently in September, while a competitor can release something new overnight and change the comparison again.

The business requirement should move much more slowly.

In this case, ours was clear: secure, read-only access to our own Google data, controlled access for the people who needed it and human approval around the decisions that mattered.

Fable 5.1 happened to be extremely good at helping me build that, while another model may be better at the next piece of work.

Being able to test that properly is becoming part of the job.