Anthropic · PiniShv

I Don't Put All My Eggs in One Basket. Anthropic Is Making That Hard.

Mon, 13 Apr 2026 10:00:00 +0300

I’ve always believed in diversification. Don’t marry a single tool. Don’t build your entire workflow around one company’s product. Keep your options open, because today’s darling is tomorrow’s deprecation notice.

I still believe that. And this quarter, Anthropic proved exactly why—in both directions.

They shipped 120+ features in 90 days. Two flagship models. Computer use. Managed agents. A CLI. Connectors to 50+ workplace tools. The most aggressive product execution any AI company has shown. While OpenAI ships quarterly and Google on a similar cadence, Anthropic has been shipping weekly. Sometimes daily.

And then, on April 4, they cut off OpenClaw—the largest open-source AI agent project on GitHub—from using Claude subscriptions. Nine days later, OpenClaw announced they’d moved to GPT-5.4. “Anthropic cut us off. GPT-5.4 got better. We moved on.”

So now you dependent on OpenAI? 🫠 https://t.co/2jnzOlHXch
— Pini (@PiniShv) April 13, 2026

I don’t like putting all my eggs in one basket. But when one basket is riding a wave this big—and simultaneously proving why you shouldn’t trust any single basket—you need to understand what’s happening.

The numbers that matter
#

In 90 days, Anthropic released:

40+ Claude Code updates
15+ Cowork updates
20+ API changes
2 new models (Opus 4.6 and Sonnet 4.6)
Computer use, Dispatch, Connectors, Channels, Remote Control, and a Plugin Marketplace

Their internal team ships 60–100 releases per day. Anthropic engineers now use Claude for roughly 60% of their own work, up from 28% a year ago, reporting ~50% productivity gains. Claude Cowork was built with Claude Code in 10 days.

That last part is worth sitting with. They used their own tool to build a new product in less than two weeks. The compounding flywheel isn’t theoretical anymore. It’s shipping.

On the business side: $380 billion valuation after a $30B Series G in February. Revenue run-rate at $14 billion, growing 10x annually. Over 500 customers spending $1M+ per year. Eight of the Fortune 10 are Claude customers.

This isn’t a startup experimenting. This is a company executing at a pace that’s forcing the rest of the industry to react.

What actually moved the needle
#

I’m not going to do a tier list—you can find those elsewhere. What I want to do is break down the releases that change how developers work, not just what sounds impressive on a changelog.

The model leap: Opus 4.6 and Sonnet 4.6
#

Opus 4.6 dropped February 5 with serious specs: 1 million token context window, 128K max output tokens (doubled from 64K), full adaptive thinking support, 80.9% on GPQA Diamond, 80.8% on SWE-bench verified. The adaptive thinking shift is important—the model now decides how deeply to reason per turn rather than consuming a fixed budget, which makes it more efficient for mixed workloads where some turns need deep reasoning and others don’t.

Sonnet 4.6 followed on February 17, becoming the default for Free and Pro plans. Near-Opus performance at 5x lower cost ($3/M input, $15/M output), 79.6% on SWE-bench. This is the model that matters most for daily use. If Opus is for the hard problems, Sonnet is for everything else—and “everything else” is 90% of the work.

The compaction API (beta, launched alongside Opus) deserves attention too. Server-side context summarization for effectively infinite conversations. If you’ve been building agents that run into context limits during long sessions, this is the fix you’ve been writing workarounds for.

Computer use + Dispatch: AI that does things
#

I wrote about this when it shipped in late March. Claude can now control your Mac—open apps, navigate browsers, fill spreadsheets, submit PRs. Pair it with Dispatch and you assign tasks from your phone while Claude works on your desktop.

The technical model: Claude reaches for the most precise tool first. Calendar request? Google Calendar connector. Slack message? Slack integration. No connector available? It falls back to screen-based control—mouse, keyboard, browser. The permission model is explicit: Claude asks before touching a new application, and Anthropic scans model activations during computer use to detect adversarial prompt injection.

Mac only. Research preview. It will be unreliable for complex workflows. But the jump from “AI that talks about doing things” to “AI that does things” is real. The security implications are the part that keeps me up at night—prompt injection against a computer-controlling agent is a fundamentally different threat than prompt injection against a chat model.

Claude Code: from assistant to development platform
#

Claude Code had the densest quarter of any product line. The headline features:

Remote Control (Feb 24): Supervise Claude Code sessions from your phone via claude.ai/code. Approve or reject changes, monitor long-running tasks without staying at your desk. This changes the workflow from “sit and watch” to “check in when it matters.”

Hooks: Deterministic actions that fire at lifecycle points—session start/end, file changes, tool use. These run 100% of the time, unlike advisory instructions that the model might ignore. This is the automation primitive that makes Claude Code composable with your existing tooling.

Subagents and /simplify: Parallel workers with clean context windows. /simplify distributes agents across changed files for code review, checking for reuse and quality. /batch handles large migration tasks across multiple files. This is multi-agent execution inside a coding tool—the same architectural direction Cursor 2.0 is taking with worktree-based parallelism.

128K output tokens (up from 16K default, 64K max): Quietly massive for code generation. Combined with the 1M token context window, Claude Code can now reason about entire mid-sized production codebases and generate substantial implementations in a single turn.

This isn’t a coding assistant anymore. It’s a development platform with an agent architecture. The Plugin Marketplace, scheduled tasks, voice mode, and MCP elicitation are all infrastructure for a tool that’s meant to run alongside you, not just respond when prompted.

Connectors: the quiet game-changer
#

Connectors might be the most strategically important release of the quarter. Claude now integrates bidirectionally with Gmail, Slack, Notion, Figma, Asana, Google Drive, and 50+ other tools.

Bidirectional. Not just “read your Slack messages.” Claude can modify content in connected applications. That’s the difference between a search engine and a coworker. It’s the same logic behind MCP—give the AI access to your real context—but packaged as a consumer-friendly feature with zero setup friction.

The strategic angle: every connector is a switching cost. Once Claude is wired into your Slack, Gmail, and Notion, moving to a different AI provider means rewiring all of those integrations. Anthropic understands this. The convenience is real, and so is the lock-in.

Managed Agents and the platform play
#

April 7–9 brought the most architecturally significant releases:

Managed Agents (public beta): A fully managed framework for running Claude as an autonomous agent. Secure sandboxing, built-in tools, SSE streaming. Create agents, configure containers, run sessions through the API.
Advisor Tool (public beta): Pairs a fast executor model with a higher-intelligence advisor for strategic mid-generation guidance. A senior engineer reviewing the junior’s work, but as an API parameter.
ant CLI: Command-line client for the API with native Claude Code integration and YAML-based resource versioning.

Managed Agents is the one to watch. Until now, building production agent systems meant stitching together your own sandboxing, tool management, and execution infrastructure. Anthropic just said “we’ll handle that.” That’s a platform play aimed directly at the middleware layer that startups were building. It’s also the kind of move that makes you more dependent on Anthropic’s infrastructure, not less.

The OpenClaw situation
#

And this is where the story gets uncomfortable.

On April 4, Anthropic blocked Claude subscription access for third-party agentic tools, starting with OpenClaw—the open-source AI agent gateway with over 247K GitHub stars. Users on Pro and Max plans can no longer route their subscription through OpenClaw. They must now use pay-as-you-go “extra usage” billing or direct API access.

Boris Cherny, Anthropic’s Head of Claude Code, explained that “subscriptions weren’t built for the usage patterns of these third-party tools.” The technical argument has merit: OpenClaw achieves ~10% cache hit rates compared to Claude Code’s much higher rates, meaning a single $200/month Max subscriber running OpenClaw continuously could consume $1,000–$5,000 in API-equivalent compute. The economics don’t work at all-you-can-eat pricing.

But the optics are terrible. Anthropic shipped Cowork—which does much of what OpenClaw does—and then cut off the open-source competition. Peter Steinberger, OpenClaw’s creator, characterized it as copying features from the open-source project and then locking out the competition. Whether that’s fair or not, it’s the perception.

OpenClaw’s response was swift. Version 2026.4.5 shipped with GPT-5.4 as the recommended default. “Anthropic cut us off. GPT-5.4 got better. We moved on.” They didn’t just switch models—they built new features around GPT-5.4’s native computer use capabilities. One week to migrate an entire project’s recommended provider.

This isn’t just a drama story. It’s a technical lesson about platform dependency:

If you build on a provider’s subscription model, you’re borrowing capacity they can revoke. OpenClaw users discovered overnight that their $200/month subscription wasn’t a contract—it was a courtesy. API access is still available, but at 5–25x the effective cost for heavy agentic workloads.

The switching cost for model providers is lower than we think. OpenClaw migrated to GPT-5.4 in a week. User testing shows comparable performance after prompt tuning. The model layer is commoditizing faster than any single provider wants to admit. The lock-in is in the tooling, the connectors, the workflow—not the model itself.

Open-source doesn’t protect you from upstream decisions. OpenClaw is MIT licensed. 247K stars. Massive community. None of that mattered when Anthropic decided the economics didn’t work. Your code is open, but your dependency on a closed API is still a single point of failure.

This is exactly why I’ve always maintained a multi-provider workflow. And it’s exactly why Anthropic’s execution makes that stance so conflicted—the tools are genuinely excellent, and using them means accepting the platform risk.

The compounding flywheel (and why it’s hard to ignore)
#

The features are impressive individually. What actually matters is the pace.

Anthropic released a major Claude update roughly every two weeks in 2026. Agent Teams and Opus 4.6 shipped the same week. Code Review landed on a Monday, and by Friday they’d added 1M context GA and four more Claude Code features.

This isn’t speed for speed’s sake. It’s compounding. Each feature makes the next one faster to build, because the team building them uses the tools they’re shipping. That flywheel is the real competitive advantage—not any individual model or feature.

The developer experience data reflects this. Claude Code works first try 91% of the time on feature generation, versus 78% for GPT-5 and 65% for Gemini 2.0.

But speed has costs. The Claude Code source leak happened during this sprint—a packaging error that shipped internal source code. When you’re publishing 60–100 internal releases daily, the boring parts of the pipeline need to be bulletproof. They’re clearly not yet.

And context fragmentation remains unsolved. For all 120+ features shipped, Claude still loses memory across conversations. You can’t hand off a complex multi-day project between sessions without significant re-prompting. The compaction API helps for single long conversations, but the cross-session problem persists.

The basket question
#

Back to my eggs.

I use Cursor. I use Claude. I use ChatGPT when it’s better for the task. I keep my eye on Gemini’s 2M context window, on GitHub Copilot’s agent mode, on what open-source alternatives like OpenClaw (a self-hosted AI agent gateway that routes through your messaging channels instead of a browser tab) are doing—especially now that they’ve demonstrated you can switch providers in a week.

I’m not going all-in on any single provider. After the OpenClaw situation, I’m more certain of that than ever.

In practice, that means most of my daily work runs through Cursor with Claude as the model layer—it’s the best developer experience I’ve found. But my MCP setup is provider-agnostic by design, my prompts don’t rely on Claude-specific quirks, and I keep ChatGPT and Gemini warm for the tasks where they’re genuinely better. If Anthropic changes the economics tomorrow, I want the migration to be a settings change, not a rewrite.

But I’d be dishonest if I didn’t acknowledge what’s happening. Anthropic in Q1 2026 didn’t just ship features. They demonstrated a development velocity that no competitor has matched. They’re eating their own cooking and the compounding is visible. They went from the company behind “the other chatbot” to the company that developers talk about in the same breath as their core infrastructure.

The guys at Anthropic are on the wave. And the OpenClaw story is a reminder that waves carry things—they don’t let you steer.

The question for developers isn’t whether to use Claude. It’s how to use the best tools available without becoming dependent on any one of them. Build your workflows so the model layer is swappable. Keep your context portable. Treat every provider’s pricing model as temporary. And pay close attention to what Anthropic is building—because right now, they’re building faster than anyone else.

Diversification doesn’t mean ignoring the best tools available. It means using them without letting them own you.

What’s your setup? All-in on Claude, spreading your bets, or actively building provider-agnostic workflows? Find me on X, Telegram, or LinkedIn.

The Claude Code Leak Isn't Dramatic. That's the Point.

Thu, 02 Apr 2026 08:00:00 +0200

The news
#

Anthropic’s Claude Code accidentally shipped internal source code in a release. The 2.1.88 update included a source map that exposed a large part of the TypeScript codebase. Anthropic said it was a packaging issue caused by human error. No customer data or credentials were exposed.

Not a dramatic breach. A very ordinary failure in build and release hygiene.

My take
#

That’s exactly why it matters.

I’m pro-AI coding tools. I use them. I want teams to use them more, not less. But the Claude Code story is a clean example of something I keep seeing: the boring operational layer is where AI-assisted teams get sloppy.

The dopamine is in generating the feature. Nobody celebrates a well-configured release pipeline. Nobody posts on LinkedIn about their source map exclusion rules. But that’s where this failure happened. Packaging. Build output. Release artifacts. The stuff that ships after the code is written.

AI makes code cheaper to produce. It doesn’t make it cheaper to own. And owning code means the tests, the reviews, the scans, the release checks, the governance, and the operational discipline that keeps the wrong thing from shipping. All the parts that aren’t fun and don’t feel productive.

This looks like it happened to Anthropic with their own tool. If it can happen there, it can happen on your team. Probably already has in a smaller way nobody noticed.

What to take from this
#

Treat release hygiene like security, not housekeeping. Source maps, build artifacts, internal configs. These aren’t details. They’re attack surface.

AI-generated code needs the same gates as any other code. The standard isn’t “the AI wrote it.” The standard is “would we be comfortable owning this in production?”

The risk isn’t the AI. It’s what you skip because you’re moving fast. AI doesn’t create new risks. It amplifies every old weakness you already had. Including the ones in your build pipeline.

The Claude Code leak is useful because it’s boring. Not a zero-day. Not a novel attack. A missed step in a release process. That’s the kind of thing that happens more, not less, when the whole team is focused on shipping faster.

Seen a similar “boring failure” on your team? I’d love to hear about it. Find me on X or Telegram.

Claude Can Now Use Your Computer. Here's What That Actually Means.

Mon, 23 Mar 2026 14:00:00 +0200

Anthropic shipped computer use for Claude today. Not as a demo. Not as a research paper. As a feature in Claude Cowork and Claude Code, available right now for Pro and Max subscribers.

When Claude doesn’t have a direct integration for something you ask it to do, it falls back to controlling your computer like a human would. It uses the screen to navigate. It can click, scroll, open files, use the browser, and run dev tools. No setup required. It just looks at what’s on your screen and figures out how to get the task done.

This is the jump from “AI that talks about doing things” to “AI that does things.”

How it works
#

Claude reaches for the most precise tool first. If you ask it to check your calendar, it uses the Google Calendar connector. If you ask it to send a Slack message, it uses the Slack integration. But when there’s no connector for what you need, Claude controls your mouse, keyboard, and browser directly.

The permission model is explicit. Claude asks before it touches a new application. You can stop it at any point. Some apps are off-limits by default. Anthropic built in safeguards against prompt injection, automatically scanning model activations during computer use to detect adversarial behavior.

Anthropic is upfront about the limitations. Computer use is early. Claude makes mistakes. Complex tasks sometimes need a second try. Screen-based operations are slower than direct API integrations. They’re releasing it as a research preview specifically to learn where it works and where it falls short.

Mac only for now. No Windows, no Linux.

Dispatch makes this actually useful
#

Computer use by itself is interesting. Paired with Dispatch, it becomes practical.

Dispatch shipped last week. It creates a persistent conversation between the Claude mobile app and your desktop. You assign Claude a task from your phone, turn your attention to something else, then open the finished work on your computer.

With computer use, Dispatch becomes a remote control for your Mac. You’re on the train and tell Claude to pull this morning’s metrics and prepare a briefing. You’re in a meeting and tell Claude to make changes in your IDE, run tests, and put up a PR. You’re away from your desk and tell Claude to keep a long-running task moving.

The combination is the interesting part. Computer use gives Claude hands. Dispatch gives you the ability to direct those hands from anywhere.

For developers specifically
#

Anthropic is positioning this heavily toward developers, and it makes sense. Claude can now make changes inside an IDE, submit pull requests, run tests, and navigate development tools autonomously. If you’re already using Claude Code, computer use extends what the agent can reach. Instead of being limited to the terminal and file system, it can interact with any GUI application.

That said, this overlaps with what Cursor Automations does differently. Cursor triggers agents from events (Git pushes, Slack messages, PagerDuty alerts) and runs them in cloud sandboxes. Claude’s computer use runs on your actual machine, which means it has access to everything you have access to. More capability, more risk.

The security implications are obvious. An AI agent with access to your screen, keyboard, and browser is a powerful tool and a significant attack surface. Prompt injection against a computer-controlling agent is a different threat than prompt injection against a chat model. Anthropic says they’re scanning for it, but they also say not to expose sensitive data during the preview.

The bigger picture
#

Every major AI company is racing toward the same destination: AI that doesn’t just generate text but actually operates computers. OpenAI and Google are both working on similar capabilities. Anthropic got here first with a shipped product, even if it’s early.

I’ve been writing about AI agents moving from toys to tools for a while. Computer use is a clear step in that direction. The agent doesn’t need a purpose-built integration for every app. It can use the same interface you use. That dramatically expands what an agent can do without requiring every software vendor to build an API or MCP connector.

But it also means the agent inherits all the messiness of GUI-based interaction. Screens change. Buttons move. Modals pop up unexpectedly. The reliability of screen-based control will always be lower than API-based integration. Anthropic knows this, which is why Claude prefers connectors when they’re available and falls back to computer use only when needed.

The honest framing: this is a research preview. It will be unreliable for complex workflows. It will get better fast. And in six months, we’ll look back at this as the moment AI assistants stopped being confined to chat windows.

The question isn’t whether AI will control computers. It’s how fast the reliability curve catches up to the ambition.

Trying Claude’s computer use or Dispatch? I’d love to hear what tasks you’re assigning and how it handles them. Find me on X or Telegram.

AI Is Now Reviewing AI's Code. That Should Make You Think.

Mon, 23 Mar 2026 07:00:00 +0200

Three things happened in the first two weeks of March 2026.

Anthropic launched Code Review for Claude Code. A multi-agent system that automatically reviews GitHub pull requests, dispatching specialized agents that analyze code for bugs, security issues, and logic errors. Internally at Anthropic, 54% of PRs now receive substantive review comments, up from 16%.

Cursor shipped Automations with security review triggers that fire on every code push. No human initiates the review. The system does.

GitLab made agentic code reviews available at $0.25 per review, including false positive detection for security scanning.

The industry is converging on the same answer to the same problem: AI generates more code than humans can review, so AI should review it too.

That answer is partly right. And partly something we should think harder about.

The bottleneck is real
#

Anthropic’s own numbers make the case. Their code output grew 200% year-over-year, but their human review capacity didn’t. That’s not unique to Anthropic. Any team using AI coding tools aggressively is hitting the same wall. More PRs, same number of reviewers, reviews get thinner.

The Plandek 2026 benchmarks across 2,000+ teams confirmed this: as AI speeds up coding, the bottleneck shifts downstream to review, testing, and integration. Bottom-quartile teams take 35+ hours to merge a pull request. That’s not a coding problem. That’s a review problem.

So AI code review tools are solving a real constraint. And early results are genuinely impressive. Anthropic reports less than 1% of Code Review findings are marked incorrect by engineers. On large PRs (1,000+ lines), 84% receive findings averaging 7.5 issues per review. That’s catching things humans were missing because they didn’t have time to look carefully.

The part that should make you think
#

Here’s my concern.

If AI writes the code and AI reviews the code, the human becomes the person who approves the merge. Not the person who understands the change. The approver.

That’s a fundamentally different role than reviewer. A reviewer reads, questions, understands, and decides. An approver looks at the green checkmarks and clicks the button.

I wrote this week about how the culture shifted toward rewarding speed over understanding. AI code review accelerates that shift. Not because the tools are bad, but because they make it even easier to ship code nobody on the team truly understood.

When the AI-generated PR gets an AI-generated review with AI-generated test suggestions, and a human clicks “approve” because all the signals are green, what exactly did the human contribute? And when that code breaks at 2 AM, who debugs it?

The right way to use this
#

I’m not arguing against AI code review. The bottleneck is real, and these tools catch things humans miss. Arguing against them would be arguing for worse code.

But I think the right approach is to treat AI review as a first pass, not the final word. Let the AI catch the mechanical stuff: unused variables, security patterns, style violations, common bugs. That frees human reviewers to focus on the things AI is still bad at: architectural fit, business logic correctness, failure mode analysis, and whether the approach makes sense given context the model doesn’t have.

The worst outcome is AI review replacing human review entirely. The best outcome is AI review making human review more focused and more valuable.

The difference depends on whether your team treats the green checkmark as the end of the process or the beginning of a better conversation.

That’s a culture decision, not a tooling decision. And based on what I’m seeing across the industry, most teams haven’t made it consciously.

Using AI code review on your team? Seeing it change how humans review? I’d love to hear how it’s working. Find me on X or Telegram.

Anthropic · PiniShv

I Don't Put All My Eggs in One Basket. Anthropic Is Making That Hard.

The numbers that matter #

What actually moved the needle #

The model leap: Opus 4.6 and Sonnet 4.6 #

Computer use + Dispatch: AI that does things #

Claude Code: from assistant to development platform #

Connectors: the quiet game-changer #

Managed Agents and the platform play #

The OpenClaw situation #

The compounding flywheel (and why it’s hard to ignore) #

The basket question #

The Claude Code Leak Isn't Dramatic. That's the Point.

The news #

My take #

What to take from this #