Claude Opus 4.8, a $65B Raise, and the Quiet Normalization of AI-Written Code

TLDR: Anthropic shipped Opus 4.8 with self-correcting code generation and cross-task memory persistence, then confirmed a $65B funding round at a $200B+ valuation. Meanwhile, Google let slip that AI now authors more than 25% of their new code, which is either exciting or terrifying depending on how much you love code review.

Summary:

Opus 4.8 is the most interesting release Anthropic has put out in a while, and not just because of the headline "deep thinking" mode. The part that actually matters for day-to-day work is that the model can now catch and correct its own coding mistakes mid-stream. That is a different category of improvement. Previous models would confidently produce broken code and wait for you to notice. Now the model backtracks on its own. I have been burned enough times by plausible-looking but subtly wrong generated code that this feels like a real shift in how much I need to babysit the output.

The persistent memory across agentic tasks is the other thing worth paying attention to. Multi-step workflows are where current AI tools fall apart the fastest. You set up context, it forgets context, you rebuild context, repeat. If Opus 4.8 genuinely maintains coherent state across a longer agent loop, that changes what you can reasonably delegate to it. We are not talking about chat memory here; we are talking about a model that can pick up a task, set it down, and return to it without losing the thread. That is the capability gap between a useful assistant and something that can actually own a workflow.

Then there is the money. Anthropic raised $65B at over $200B valuation, and the coverage has started to treat that number with the same casual energy as a Series B. The normalization of these figures is its own story. The companies landing this capital are not just buying GPUs; they are positioning to own the infrastructure layer of software development for the next decade. Whether that happens through model APIs, agent runtimes, or something we have not seen yet, the bets being placed are enormous and the timeline is short.

Google's disclosure that more than 25% of their new code is now AI-generated is the number I keep coming back to. Google employs some of the best engineers on the planet. If AI is writing that proportion of new code at that level of engineering culture, the conversation about AI as a "junior assistant" is already outdated. And with Perplexity launching an AI-native browser to replace the address-bar paradigm, and AI testing tools being used to validate AI-written code, the recursion is only going deeper.

Key takeaways:

Opus 4.8's self-correction during code generation is a qualitative improvement over previous models, reducing the supervision burden on developers significantly
Persistent memory across agentic tasks is the capability that makes longer, more autonomous workflows realistic rather than aspirational
Google's 25% AI code generation figure signals that AI-assisted development has crossed from experiment to standard practice at the industry's highest engineering levels

Why do I care: The self-correcting code generation in Opus 4.8 is the thing I will actually test this week, because my current workflow still involves too many loops of "generate, review, catch the subtle bug, regenerate." If the model genuinely catches its own logical errors before I see them, that changes the review contract. I stop being a bug hunter and start being an architect reviewing intent. The memory persistence piece matters just as much for anyone building agents or automation pipelines, because stateless context windows are the single biggest source of frustration in that work right now. The Google stat is a gut-check: if you are still treating AI code generation as an experiment or a curiosity, you are behind where the industry already is.

Claude Opus 4.8 Just Raised the Bar for AI Coding