DEV Community: Max Quimby

Block Just Cut 40% of Its Engineers. BuilderBot Writes the Code Now.

Max Quimby — Thu, 02 Apr 2026 17:47:41 +0000

There's a moment in the a16z interview where Owen Jennings, a Block executive, says something that makes you pause: "We are not writing code by hand anymore. That's over."

Not "we're using AI to assist our engineers." Not "we've increased productivity." The correlation between headcount and output at Block — the $50B fintech company formerly known as Square — broke in the first week of December 2025. And the company acted on it.

Block cut over 40% of its engineering staff. Squads that once had 14 people now run with 3 or 4. Their internal AI coding agent, BuilderBot, autonomously merges pull requests and takes features to 85-90% completion before a human ever looks at the code.

This isn't a startup experimenting with AI tools. This is a publicly traded company with thousands of employees making a structural bet that AI agents can replace the majority of traditional software engineering work. And the early evidence suggests they're right.

📊 The numbers: 40%+ engineering staff reduction. Squads from 14 → 3-4 people. BuilderBot takes features to 85-90% completion autonomously. These aren't projections — they're operational reality at Block as of Q1 2026.

The "Binary Shift" — What Actually Happened in December 2025

Owen Jennings describes a specific inflection point. Not a gradual improvement — a discontinuous jump. In the first week of December 2025, two things shipped nearly simultaneously: Anthropic's Opus 4.6 and OpenAI's Codex 5.3.

The critical breakthrough wasn't raw intelligence. It was the ability to work with existing complex codebases — not just greenfield projects. Before December, AI coding tools were impressive on new projects but struggled with the tangled reality of production systems: legacy APIs, undocumented business logic, migration debt, cross-service dependencies.

Opus 4.6 and Codex 5.3 crossed that threshold. Suddenly, AI agents could navigate Block's massive codebase — hundreds of services, years of accumulated complexity — and make meaningful changes that actually passed CI and code review.

Jennings called it a "binary shift." One week the correlation between headcount and output held. The next week, it didn't. The implications were immediate and brutal.

How BuilderBot Actually Works

BuilderBot isn't just Copilot bolted onto an IDE. It's an autonomous agent deeply integrated into Block's development workflow:

The Workflow

Ticket ingestion. BuilderBot reads Jira tickets, design specs, and related documentation. It understands what needs to be built — not just the code change, but the business context.
Codebase navigation. The agent maps dependencies, understands service boundaries, and identifies which files need modification. This is where pre-December models failed — they couldn't hold the full context of a complex system.
Implementation. BuilderBot writes the code, creates tests, and handles cross-service changes. It doesn't just generate snippets — it builds complete feature implementations.
Self-review and iteration. Before submitting a PR, BuilderBot runs the test suite, checks for common anti-patterns, and iterates on its own output. Failed tests trigger automatic debugging cycles.
Autonomous PR merge. For changes within established patterns and confidence thresholds, BuilderBot merges its own PRs without human review. Higher-risk changes get flagged for human review by the remaining senior engineers.

The 85-90% Number

When Jennings says BuilderBot takes features to "85-90% completion," he means the agent handles the entire implementation — from understanding requirements to writing code to passing tests. The remaining 10-15% is typically:

Edge cases that require deep domain expertise
Design decisions that involve product trade-offs
Cross-team coordination that requires human judgment
Security-sensitive changes that demand human review

The senior engineers who remain on squads spend their time on this 10-15% — the highest-judgment work that requires understanding not just the code but the business, the users, and the regulatory environment.

How the squads changed: Block's engineering squads went from 14 people (mix of junior, mid, and senior engineers plus a manager) to 3-4 people (senior engineers and a tech lead). The junior and mid-level implementation work that filled most of the headcount is now handled by BuilderBot.

The Moat Thesis: Understanding > Code

The most strategically important thing Jennings said wasn't about BuilderBot. It was about what makes a company defensible in the AI era:

"The moat is which companies understand something super hard for others to understand."

Block's edge isn't their codebase — any AI agent could eventually write equivalent payments processing code. Their edge is deep data on how sellers and buyers participate in the economy. Years of transaction data, merchant behavior patterns, fraud signals, lending risk models — that's institutional knowledge that can't be replicated by pointing an AI at a blank repository.

This reframes the entire competitive landscape. If code becomes commoditized (and Block is betting it already has), then the companies that survive are the ones with:

Proprietary data that feeds better models and decisions
Domain expertise that AI can't learn from public sources
Network effects that compound with scale
Regulatory knowledge in complex, licensed industries

Everything else — the UI, the APIs, the infrastructure — becomes a commodity that any sufficiently capable AI agent can reproduce. Jennings described this as an "existential vibe-coding threat" to companies that can't answer what they uniquely know.

The Enterprise AI Landscape That Made This Possible

Block's transformation didn't happen in a vacuum. The broader enterprise AI market underwent a seismic shift in the same period.

The Anthropic Surge

According to data cited by Peter Diamandis at the Abundance360 Summit and discussed on the All-In Podcast, enterprise AI market share flipped dramatically in late 2025:

📊 Enterprise AI market share (Q1 2026): Anthropic 73% vs OpenAI 26% — a complete reversal from 60/40 in OpenAI's favor just three months earlier. Claude Code and Opus 4.6 were the forcing function.

This isn't just about benchmarks. Anthropic's Claude Code became the default enterprise coding agent because it could do what Block needed — navigate complex existing codebases, not just generate new code. The tool's ability to understand monorepo structures, respect existing patterns, and integrate with CI/CD pipelines made it the backbone of systems like BuilderBot.

The Multi-Model Reality

Block isn't exclusively using one provider. The most sophisticated enterprise AI deployments in 2026 use multiple models for different tasks — a pattern that Gauntlet AI's Austen Allred has been vocal about:

The emerging enterprise stack looks like:

Anthropic Claude (Opus 4.6) for complex reasoning and codebase navigation
OpenAI Codex 5.3 for rapid code generation and test writing
Google's models for design and UI work
Custom fine-tuned models for domain-specific tasks (fraud detection, risk scoring)

Block's BuilderBot likely orchestrates across multiple providers, routing different subtasks to whichever model handles them best. This multi-model approach is why the "which AI is best?" question is increasingly irrelevant — the answer is "all of them, for different things."

What the All-In Crew Is Saying

The All-In Podcast — hosted by four billionaire tech investors who collectively touch hundreds of companies — covered Block's transformation extensively. Their reactions reveal how the investment community is processing this shift:

The consensus among the hosts: Block is the canary in the coal mine, not the exception. Every company with a large engineering org is going to face the same math — AI agents that can do 85-90% of implementation work at a fraction of the cost of human engineers.

David Sacks framed it in terms of unit economics: if BuilderBot handles the work of 10 engineers at the cost of compute tokens, the ROI is so overwhelming that not adopting similar tools becomes a fiduciary risk.

The ServiceNow Signal

Block isn't alone. ServiceNow research published this week demonstrates that terminal-based coding agents with direct API access can now handle enterprise automation tasks that previously required dedicated teams.

@_akhaliq: "Terminal Agents Suffice for Enterprise Automation — ServiceNow research shows terminal-based coding agents with direct API access..." — View on X

The pattern is consistent: autonomous agents aren't just writing code — they're operating within enterprise systems, making API calls, handling workflows, and closing tickets. The "agent" in "coding agent" is becoming literal.

What This Means for Engineering Leaders

If you lead an engineering organization, Block's story isn't something to panic about — it's something to prepare for. Here's the practical playbook:

1. Audit Your "Moat" — Today

Ask yourself: What does my company understand that's genuinely hard for others to understand? If the answer is "we have a good codebase" or "we have experienced engineers," you're in trouble. Code is being commoditized. Engineering talent is being augmented to the point where a team of 4 can do what 14 used to do.

The defensible moats are:

Proprietary data and the models trained on it
Deep domain expertise in regulated industries
Network effects that compound with usage
Customer relationships built on trust and switching costs

2. Restructure Teams Around Judgment, Not Output

Block's squad reduction from 14 to 3-4 isn't arbitrary. They kept the people who do the highest-judgment work:

Architects who make design decisions
Senior engineers who handle edge cases and security
Tech leads who coordinate across systems
Domain experts who understand the business context

The pattern for everyone else: fewer engineers, each with dramatically amplified capability. A senior engineer with BuilderBot-class tooling does the implementation work that previously required a team.

3. Invest in AI Infrastructure, Not Headcount

Jensen Huang's recent provocation — that a $500K engineer should be spending $250K on AI tokens — sounds like marketing from the CEO of a GPU company. But the math at Block validates the principle. The cost of AI compute tokens to run BuilderBot is a fraction of the salary, benefits, and overhead of the engineers it replaced.

The shift in capital allocation:

Before: 80% salaries, 20% tools/infrastructure
After: 40% salaries (for senior staff), 40% AI compute, 20% infrastructure

4. Start with the Boring Stuff

Block didn't start by having AI write their core payments engine. They started with repetitive, well-defined tasks: CRUD endpoints, migration scripts, test coverage, documentation updates. As confidence in the tooling grew, they expanded scope.

Your roadmap:

Month 1-2: AI-assisted code review and test generation
Month 3-4: Autonomous handling of bug fixes and small features
Month 5-6: Full feature implementation with human review
Month 7+: Selective autonomous merge for high-confidence changes

5. Retrain, Don't Just Fire

The hardest part of Block's story isn't the technology — it's the human cost. 40% staff reduction means real people losing real jobs. The companies that handle this well will retrain engineers for the roles that remain:

AI system architects (designing the agent pipelines)
Prompt engineers and agent operators
Quality assurance and security reviewers
Domain experts who guide AI output

The companies that handle it badly will face lawsuits, talent acquisition problems, and the kind of reputation damage that makes future hiring harder.

🔑 The key insight: Block's BuilderBot didn't replace engineers — it replaced engineering tasks. The humans who remain are doing fundamentally different work: guiding AI agents, making judgment calls, and leveraging domain expertise that models can't replicate. The question isn't "will AI replace engineers?" It's "what kind of engineering work is left for humans?"

Naval Ravikant distilled the shift in a single tweet that went viral this week:

@naval: "Vibe coding is more addictive than any video game ever made (if you know what you want to build)." — View on X

The subtext is important: "if you know what you want to build." That conditional is doing enormous work. The value isn't in the coding — it's in knowing what to code. Block figured this out. Their remaining engineers aren't coders — they're decision-makers who happen to use code as their medium.

The Uncomfortable Questions

Block's transformation raises questions that the industry hasn't fully grappled with:

What happens to junior engineers? If AI handles the work that juniors traditionally do — implementing well-defined features, writing tests, fixing bugs — how do junior engineers develop the skills to become senior engineers? Block's squad structure assumes a steady supply of experienced engineers, but the pipeline that produces them may be drying up.

Is 85-90% completion good enough? The remaining 10-15% that requires human judgment includes security, edge cases, and architectural decisions — the exact areas where mistakes are most costly. Are 3-4 person squads enough to catch the things that AI misses?

How far does this go? Block is at 40% reduction now. If AI capabilities continue improving at the current rate, is 60% next? 80%? At what point does the company become entirely dependent on AI agents, with human engineers serving only as a safety net?

These aren't rhetorical questions. They're planning questions. Every engineering leader needs to have answers — or at least frameworks for finding answers — before the "binary shift" hits their organization.

The Bottom Line

Block's story is the most concrete, publicly documented case of AI agents replacing a significant portion of engineering work at a major company. It's not theoretical anymore. The numbers are real: 40% headcount reduction, 14-person squads becoming 4-person squads, an AI agent that autonomously merges PRs.

The "binary shift" Jennings described — where the correlation between headcount and output suddenly breaks — isn't unique to Block. It's a threshold that every engineering organization will cross as AI coding agents improve. The question is whether you cross it on your own terms, with a plan for restructuring and retraining, or whether it catches you unprepared.

Block's bet is clear: the future of software engineering isn't humans writing code. It's humans understanding problems, and AI writing the solutions.

"We are not writing code by hand anymore. That's over."

The rest of the industry is about to find out if he's right.

Sources: a16z interview with Owen Jennings, All-In Podcast, Peter Diamandis Abundance360 Summit. Enterprise market share data cited by multiple sources covering Q1 2026 enterprise AI adoption.

AI Agent Supply Chain Attacks: What the LiteLLM Breach Means for Your Stack

Max Quimby — Thu, 02 Apr 2026 17:45:37 +0000

The morning of March 31, 2026, started badly for the AI ecosystem. A malicious actor had slipped compromised versions of LiteLLM — one of the most widely-deployed LLM proxy libraries in production — onto PyPI. The poisoned packages were live for 40 minutes. That was enough.

Mercor, the AI-powered hiring platform backed by top-tier VCs, disclosed it had been hit. And Wiz's cloud scanning data made the scale immediately clear: LiteLLM is present in 36% of cloud environments. ~500,000 machines reached. This wasn't a niche tool getting exploited. This was the supply chain for AI.

40 minutes of exposure. ~500,000 machines reached. 36% of cloud AI environments at risk.
The LiteLLM breach is the AI ecosystem's SolarWinds moment — and most teams aren't prepared.

What Actually Happened

LiteLLM is a Python library that provides a unified API across 100+ LLM providers — OpenAI, Anthropic, Cohere, Bedrock, and more. If you're running AI agents in production and you want to switch between model providers without rewriting your code, LiteLLM is the answer most teams reach for. That trust is exactly what made it a target.

The compromised versions contained code designed to exfiltrate credentials — specifically, the API keys and tokens that LiteLLM is typically configured with to proxy requests to LLM providers. In an AI agent stack, those keys aren't just for one service. They're often for all of them: your OpenAI key, your Anthropic key, your database credentials, your cloud provider tokens. One compromised dependency, one credential dump.

Mercor disclosed the breach and confirmed the vector. TechCrunch reported the details. The Hacker News discussion (110 points, 34 comments) surfaced the broader concern: who else was hit and simply hasn't disclosed yet?

The Same Week: Axios Attack and the Delve Scandal

The LiteLLM breach didn't happen in isolation. The same week saw:

The Axios npm attack. Andrej Karpathy flagged it on X: axios@1.14.1, the npm HTTP library with 300 million weekly downloads, was compromised via a maintainer account takeover. The supply chain attack pattern — target a widely-trusted package, slip in credential-exfiltrating code — worked the same way across both npm and PyPI simultaneously.

The Delve scandal. Delve, a YC-backed compliance startup, was simultaneously accused of forking open-source tools and reselling them as proprietary software — a TechCrunch investigation detailed the allegations. Adding insult to injury: the LiteLLM breach had exposed Mercor's customer list, which included Delve — meaning Delve was on a hacker-targeting shortlist the same week its ethics came under scrutiny.

Three stories converging in one week isn't coincidence. It's a signal about the structural vulnerability of the AI tooling layer.

Why AI Agent Pipelines Are Uniquely Vulnerable

The proxy layer problem. Libraries like LiteLLM sit in a privileged position: they're the translation layer between your application and every LLM provider you use. They necessarily hold credentials for all of them. Compromise the proxy, and you don't just get one key — you get the whole credential store.

Credentials are exceptionally sensitive. In most AI agent deployments, the credentials passed through the LLM proxy include:

LLM provider API keys (which can rack up enormous costs)
Database read credentials (agents query data)
Cloud storage tokens (agents access files)
Service integration keys (agents call external APIs)

The dependency surface is massive and moving fast. AI tooling is evolving at a pace that makes rigorous security review nearly impossible at the team level. A project that was legitimate and well-reviewed six months ago may have changed maintainers, added dependencies, or been targeted since.

Most teams never audit their PyPI dependencies. Ask yourself: do you know every transitive dependency in your AI agent stack? Do you run integrity checks on installed packages? For most teams, the honest answer is no.

The 5-Step Security Checklist for AI Agent Stacks

Step 1: Pin Your Dependencies with Hash Verification

Don't just pin versions — verify hashes.

# Generate hashes for pinned requirements
pip-compile --generate-hashes requirements.in -o requirements.txt

# Install with hash verification
pip install --require-hashes -r requirements.txt

Version pinning alone doesn't protect against maintainer account compromise; hash verification does.

Step 2: Isolate Credential Access by Function

Your LLM proxy should not hold credentials for systems it doesn't need to reach:

LLM proxy (LiteLLM): Only needs LLM provider API keys
Agent orchestrator: Only needs credentials for authorized tools
Memory layer: Only needs database read/write for its designated tables

Use separate service accounts and never pass credentials as plain-text environment variables in containerized environments — use a secrets manager.

Step 3: Enable Dependency Auditing in CI

# GitHub Actions example
- name: Audit Python dependencies
  run: |
    pip install pip-audit
    pip-audit --requirement requirements.txt --strict

- name: Audit npm dependencies  
  run: npm audit --audit-level=high

Also run OSV-Scanner — it catches issues that pip-audit misses.

Step 4: Monitor for Anomalous API Key Usage

Set up alerts for:

Unusual LLM provider spend spikes
API calls from unexpected IP ranges or regions
Off-hours authentication events
Failed auth attempts against your cloud provider

A compromised key burning $10K/day in tokens is a signal you want to catch in hours, not on your monthly bill.

Step 5: Run a Quarterly Dependency Audit

Every 90 days, review your AI stack's dependency tree:

Have any maintainers changed on critical packages?
Have any packages been flagged on PyPI Safety DB or npm Security Advisories?
Are you still on pinned versions, or has a pip install --upgrade crept in?
Do you know who maintains your top 10 most critical AI dependencies?

The Broader Pattern

36% of cloud environments run LiteLLM. One compromised maintainer account. 40 minutes of exposure.

The blast radius of AI tooling supply chain attacks scales with adoption. The most popular packages are the most valuable targets.

Simon Willison — one of the most reliable signal-filters in the AI developer community — flagged supply chain attacks against PyPI and npm in his March newsletter alongside agentic engineering patterns. When Willison puts something in his signal-filtered newsletter, it's past the noise threshold.

The same week as the LiteLLM breach, Andrej Karpathy personally found a compromised npm package in his own environment. If someone who actively thinks about AI security found one in his local environment, the rate of undetected compromise across production systems is higher than the public disclosure count suggests.

The question isn't whether your AI stack has been targeted. The question is whether you'd know if it had.

What to Do Right Now

If you're running LiteLLM or any AI proxy layer in production:

Immediately: Check your installed version. If you auto-updated during the breach window, rotate all credentials the package had access to.
Today: Enable hash verification for your Python dependencies.
This week: Audit what credentials each component of your stack holds. Scope them down.
This month: Set up dependency scanning in CI and usage anomaly alerts.
Ongoing: Treat your AI dependency tree as attack surface, not infrastructure.

The Mercor breach is a disclosure. There are almost certainly others that haven't disclosed yet. Get ahead of it now, while fixing it is still a precaution and not a post-incident response.

Sources: TechCrunch — Mercor breach · HN discussion (110pts) · TechCrunch — Delve scandal · @karpathy on axios attack · Simon Willison March newsletter

Qwen 3.6-Plus: Alibaba's Agent Model Built for Real-World Tasks (Review)

Max Quimby — Thu, 02 Apr 2026 16:13:04 +0000

Liquid syntax error: Tag '{%% youtube aNg47-U_x6A %%}' was not properly terminated with regexp: /\%\}/

AMD's Lemonade Just Made Every Nvidia-Only AI Guide Obsolete

Max Quimby — Thu, 02 Apr 2026 15:58:38 +0000

Search for "how to run LLMs locally" and count the Nvidia logos. CUDA this, CUDA that. If you own AMD hardware — and statistically, a lot of you do — the local AI ecosystem has treated you like a second-class citizen for years.

That just changed.

Lemonade is an open-source, AMD-backed local AI server that handles LLM chat, image generation, speech synthesis, and transcription — all from a single install, all running on your hardware, all private. It hit 216 points on Hacker News this week, and the discussion thread tells you everything about why AMD users are paying attention.

🍋 What Lemonade actually is: A 2MB native C++ service that auto-configures for your AMD GPU, NPU, or CPU. It exposes an OpenAI-compatible API at localhost:13305, meaning any app that talks to OpenAI (VS Code Copilot, Open WebUI, n8n, Continue, hundreds more) works out of the box — pointed at your own machine instead of the cloud. Zero tokens billed. Zero data leaving your network.

Why This Matters Right Now

The local AI movement has been building momentum for two years. Ollama proved the concept. LM Studio made it pretty. But both share a dirty secret: AMD support is an afterthought. ROCm drivers are a maze. Getting llama.cpp to build with the right GPU target is a weekend project. Most users give up.

Lemonade's value proposition is brutally simple: one install, it detects your hardware, it works.

"If you have an AMD machine and want to run local models with minimal headache… it's really the easiest method. This runs on my NAS, handles my home assistant setup." — HN commenter

But it's not just ease of use. Lemonade is the only open-source OpenAI-compatible server that offers AMD Ryzen AI NPU acceleration. That's a hardware advantage Nvidia literally cannot match — there is no Nvidia NPU in your laptop.

The Architecture: NPU + GPU Hybrid Execution

On Ryzen AI 300/400 series chips (Strix Point, Strix Halo), Lemonade splits the workload:

Prompt processing (prefill) → Offloaded to the NPU, which has superior compute throughput for this specific task. This minimizes Time To First Token (TTFT).

Token generation (decode) → Handed to the integrated GPU (iGPU) or discrete GPU, which has better memory bandwidth for sequential token generation.

This hybrid approach is why a Ryzen AI laptop can feel snappier than raw token-per-second numbers would suggest.

Benchmarks: What Can You Actually Expect?

These are from AMD's own benchmarks on a Ryzen AI 9 HX 370 laptop (Radeon 890M, 32GB LPDDR5X-7500) running DeepSeek-R1-Distill-Llama-8B at INT4:

Context Length	Time to First Token	Tokens/Second
128 tokens	0.94s	20.7 tok/s
256 tokens	1.14s	20.5 tok/s
512 tokens	1.65s	20.0 tok/s
1024 tokens	2.68s	19.2 tok/s
2048 tokens	5.01s	17.6 tok/s

Those are integrated graphics numbers. Not a $1,500 discrete GPU — a laptop chip.

📊 Community benchmarks from Strix Halo (128GB): GPT-OSS 120B at ~50 tok/s • Qwen3-Coder-Next at 43 tok/s (Q4) • Qwen3.5 35B-A3B at 55 tok/s (Q4) • Qwen3.5 27B at 11-12 tok/s (Q4, dense architecture). Yes — a 120B parameter model running at 50 tokens/second on a desktop APU with no discrete GPU.

Setup: From Zero to Running in Under 5 Minutes

Windows (Recommended)

# 1. Download the installer from GitHub releases
# https://github.com/lemonade-sdk/lemonade/releases/latest
# Run Lemonade_Server_Installer.exe

# 2. Select your models during installation
# The installer auto-detects your GPU/NPU

# 3. Launch from desktop shortcut — that's it.
# Server runs at http://localhost:13305

Linux (Ubuntu/Fedora)

# Ubuntu (snap)
sudo snap install lemonade-server

# Fedora (RPM)
sudo dnf install lemonade-server

# Start the server
lemonade run Gemma-3-4b-it-GGUF

macOS (Beta)

# Install via the official installer
# https://lemonade-server.ai/install_options.html#macos
lemonade run Gemma-3-4b-it-GGUF

Once running, pulling and switching models is dead simple:

# Browse available models
lemonade list

# Pull and run a model
lemonade pull Gemma-3-4b-it-GGUF
lemonade run Gemma-3-4b-it-GGUF

# Multi-modality
lemonade run SDXL-Turbo        # Image gen
lemonade run kokoro-v1          # Speech synthesis
lemonade run Whisper-Large-v3-Turbo  # Transcription

Connecting Apps: The OpenAI-Compatible Trick

Because Lemonade exposes an OpenAI-standard API, any app that supports custom OpenAI endpoints works immediately:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:13305/api/v1",
    api_key="lemonade"  # required but unused
)

response = client.chat.completions.create(
    model="Llama-3.2-1B-Instruct-Hybrid",
    messages=[{"role": "user", "content": "Explain quantum computing"}]
)
print(response.choices[0].message.content)

That same endpoint works with VS Code Copilot, Open WebUI, Continue, n8n, and any OpenAI SDK in Python, Node.js, Go, Rust, C#, Java, Ruby, or PHP.

Lemonade vs. Ollama: The Honest Comparison

Feature	Lemonade	Ollama
Primary focus	AMD optimization + multi-modality	Cross-platform model serving
GPU support	ROCm (AMD), Vulkan, Metal (beta)	CUDA (Nvidia), ROCm, Metal
NPU support	✅ XDNA2 (Ryzen AI 300/400)	❌ None
Modalities	Chat, Vision, Image Gen, TTS, STT	Chat, Vision
API compatibility	OpenAI, Ollama, Anthropic	Ollama, OpenAI (partial)
Multiple models	✅ Simultaneously	One at a time
Mobile app	✅ iOS + Android	❌
Binary size	~2MB (server)	~200MB

Bottom line: If you're on AMD hardware, Lemonade is the better choice. If you need Nvidia CUDA support or the simplest possible cross-platform install, Ollama is still the safer bet.

One HN user ran a direct comparison on an M1 Max MacBook:

"Model: qwen3.59b. Ollama completed in about 1:44. Lemonade completed in about 1:14. So it seems faster in this very limited test."

The NPU Question: Is It Worth It?

What NPUs are good for:

Low-power "always-on" inference for small models (1-4B parameters)
Accelerating prompt processing (prefill) in hybrid mode
Running AI tasks without touching your GPU

What NPUs are NOT good for (yet):

Running large models (>10B parameters)
Matching discrete GPU speeds for raw token generation

⚠️ NPU reality check: The NPU kernels used by Lemonade's FastFlowLM backend are proprietary (free for reasonable commercial use). The llama.cpp GPU path remains fully open. If you're on a Strix Halo with 128GB RAM, the GPU path is fast enough that NPU acceleration is a nice-to-have.

What's Coming Next

The Lemonade roadmap is active:

MLX support — for better Apple Silicon performance
vLLM support — for high-throughput serving
Enhanced custom model support — easier GGUF/ONNX imports from Hugging Face

With Ubuntu 26.04 LTS adding native AMD NPU support and Lemonade 10.0 shipping Linux NPU support via FastFlowLM, Linux users are getting first-class treatment too.

The Bigger Picture

The llama.cpp creator Georgi Gerganov just joined Hugging Face — a consolidation event for the open-source local AI stack. Google's TurboQuant paper demonstrated KV cache compression to 3 bits, potentially slashing memory requirements. The infrastructure for running capable AI on consumer hardware is converging fast.

"I find it very frustrating to get LLMs, diffusion, etc. working fast on AMD. It's way too much work." — HN commenter, explaining exactly why Lemonade exists

Lemonade exists because that frustration is real, widespread, and fixable. If you've got AMD silicon, give it a shot. The install is a few minutes, the API is standard, and the models are free.

Links:

Lemonade Server — Official site
GitHub Repository — Source code + releases
AMD Developer Article — Technical deep-dive
Hacker News Discussion — Community reactions

Originally published on ComputeLeap

Best AI Agent Orchestration Tools in 2026: From Superpowers to oh-my-claudecode

Max Quimby — Tue, 31 Mar 2026 17:47:22 +0000

We've crossed a threshold. Single-agent coding assistants — Copilot, Claude Code, Codex — are table stakes. The frontier has shifted to multi-agent orchestration.

📖 Read the full version with charts and embedded sources on AgentConn →

Why Orchestration Matters Now

"The unit of software production has changed from team-years to founder-days." — @garrytan

📊 GitHub Signal: 158K+ combined stars across these 6 tools.

1. Superpowers — 122K★

obra/superpowers — Shell-based agentic skills framework.

git clone https://github.com/obra/superpowers && cd superpowers && ./install.sh
claude --skill skills/my-skill "Do Y for this codebase"

2. oh-my-claudecode — 15K★

Yeachan-Heo/oh-my-claudecode — Teams-first multi-agent orchestration.

npm install -g oh-my-claudecode
omcc run "implement authentication" --agents 3 --parallel

3. hermes-agent — 16K★

NousResearch/hermes-agent — The agent that grows with you.

pip install hermes-agent && hermes-agent run "refactor auth module"

4. learn-claude-code — 42K★

shareAI-lab/learn-claude-code — Nano agent harness built from 0 to 1.

git clone https://github.com/shareAI-lab/learn-claude-code
npx ts-node src/agent.ts "add tests for auth module"

5. claude-mem — 42K★

thedotmack/claude-mem — Auto session memory compression.

npm install -g claude-mem
claude config plugin add claude-mem

// Detect dark theme var iframe = document.getElementById('tweet-2038297938892607812-770'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2038297938892607812&theme=dark" }

6. AgentScope — 22K★

agentscope-ai/agentscope — Visual, auditable multi-agent pipelines.

// Detect dark theme var iframe = document.getElementById('tweet-2038225369191391370-279'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2038225369191391370&theme=dark" }

Comparison Table

Tool	Stars	Language	Multi-Agent	Memory
Superpowers	122K	Shell	yes	files
oh-my-claudecode	15K	TypeScript	yes	shared
hermes-agent	16K	Python	yes	learns
learn-claude-code	42K	TypeScript	no	no
claude-mem	42K	TypeScript	plugin	auto
agentscope	22K	Python	yes	yes

Full article: agentconn.com

🔗 Full article on AgentConn → | Follow @ComputeLeapAI

How a 5-Person AI Startup Outperforms Teams of 25 (With AI Coding Agents)

Max Quimby — Tue, 31 Mar 2026 17:46:01 +0000

📖 Read the full version with charts and embedded sources on ComputeLeap →

A 12-person company is processing petabytes of fraud data for Fortune 500 clients. Five engineers. No army of contractors. No offshore development center. Just five people, each running three monitors of AI coding agents — and a customer success manager who ships features without ever opening a terminal.

This isn't a thought experiment. It's Variance, a YC-backed startup that just emerged from three years of stealth with a $21M Series A to tell the story.

📊 The numbers that matter: Variance — 12-person team, 5 engineers — processes petabytes of data for Fortune 500 marketplaces, detected state-sponsored fraud rings during elections, and operates at a scale that would traditionally require 25+ engineers. Their co-founder describes a team where "every engineer runs three monitors of coding agents."

The Variance Playbook: What "AI-Native" Actually Looks Like

In a recent Y Combinator interview, Variance's co-founders — who previously built Trust & Safety ML infrastructure at Apple and Discord — described a workflow that makes traditional dev teams look like they're running uphill in mud.

Every engineer at Variance operates multiple AI coding agents simultaneously. Not copilot-style autocomplete. Autonomous agents that take a task description, read the codebase, write implementation code, run tests, and submit pull requests — while the engineer supervises and reviews across three screens.

But the most striking detail isn't about the engineers. It's about their customer success manager. This non-technical team member ships production features to enterprise clients using Cursor's agent mode — without ever filing an engineering ticket. She describes what the customer needs, the agent writes the code, and the feature goes live after a quick review.

That's the inflection point. When non-engineers start shipping code, the bottleneck isn't engineering capacity anymore. It's product imagination.

Why 2026 Is the Tipping Point

This isn't just a Variance story. The entire startup ecosystem is experiencing the same compression.

Y Combinator president Garry Tan put it bluntly on X last week:

View original post on X →

He's not being hyperbolic. Tan is so invested in this thesis that he's building GStack, an open-source AI development framework, himself. When the president of the world's top startup accelerator writes code for AI dev tools in his spare time, the signal is deafening.

And the data from the current YC W26 batch backs it up. Solo founders and two-person teams are shipping products that historically required Series A headcount. The economics have flipped: hiring 15 engineers is now a liability if five engineers with agents can ship faster, iterate quicker, and maintain less organizational overhead.

Meanwhile, Jason Calacanis — investor and All-In podcast co-host — declared on X that "we've already reached AGI — we just haven't implemented it broadly":

View original post on X →

Whether you agree with the AGI framing or not, the practical reality is clear: AI coding agents are already delivering a 3-5x productivity multiplier for teams that know how to use them.

The Tools: What's Actually Working in 2026

Not all AI coding tools are created equal. Here's a breakdown of what teams like Variance are actually using, and what each tool does best.

Tool	Type	Best For	Pricing	Autonomy Level
Claude Code	CLI agent	Complex multi-file refactors, architecture work, CI/CD integration	$100/mo (Max) or $20/mo (Pro)	High — reads codebase, writes code, runs tests, commits
Cursor	IDE (VS Code fork)	Daily coding, non-engineers shipping features, rapid prototyping	$20/mo (Pro) or $40/mo (Business)	Medium-High — agent mode handles full tasks
Codex CLI	Terminal agent	Code review, parallel task execution, investigation	$200/mo (ChatGPT Pro)	High — autonomous with sandbox execution
GitHub Copilot	IDE extension	Autocomplete, inline suggestions, quick edits	$10/mo (Individual) or $19/mo (Business)	Low-Medium — suggestion-based, new agent mode
Windsurf	IDE (Codeium)	Budget teams, educational contexts, lighter projects	Free tier available, $15/mo Pro	Medium — Cascade agent flow

⚡ The real unlock: Most productive teams don't pick one tool. They stack them. Engineers at companies like Variance run Claude Code for complex backend work and architecture, Cursor for frontend iteration and feature work, and Codex CLI for code review and debugging — simultaneously across multiple monitors.

Claude Code: The Power User's Choice

Claude Code is the tool serious engineering teams gravitate toward. It runs in your terminal, reads your entire codebase (up to 1M tokens of context), and operates as an autonomous agent — not just an autocomplete engine.

What makes it different: Claude Code understands project architecture. It reads your CLAUDE.md files for project conventions, uses hooks for CI integration, and can run cloud sessions that follow PRs and auto-fix CI failures while you sleep. Anthropic's recent additions — conditional hooks, cloud auto-fix, and Dispatch (text Claude from your phone, it takes over your desktop) — are turning it from a coding tool into a full development platform.

The three-hour advanced course from Nick Saraev is the best practical resource for teams getting started:

Cursor: The Gateway Drug

Cursor is what gets non-engineers coding. Its VS Code-based interface is familiar, its agent mode is powerful enough to handle full feature implementations, and its learning curve is gentle enough that a customer success manager at Variance ships production code with it.

For teams with mixed technical backgrounds, Cursor is the highest-leverage starting point. The agent mode handles everything from reading existing code to writing tests to explaining what it did — in a visual interface that doesn't require terminal comfort.

The Multi-Agent Setup

The most productive teams in 2026 aren't using one AI tool. They're running a fleet. Here's what a typical engineer's setup looks like at an AI-native startup:

Monitor 1 — Claude Code (Architecture & Backend)
Complex multi-file changes, database migrations, API design, infrastructure work. Claude Code's deep context window and CLAUDE.md project conventions make it ideal for work that requires understanding the full system.

Monitor 2 — Cursor (Feature Development & Frontend)
Rapid iteration on features, UI work, quick bug fixes. Agent mode for new features; tab-complete for small edits. This is where the fast, visual feedback loop lives.

Monitor 3 — Codex CLI or Review Dashboard
Code review, test execution monitoring, debugging investigations. Some engineers use this screen for a second Claude Code session running independent tasks in parallel.

The Practical Setup: Getting Your Team Started

Week 1: Foundation

Pick your primary agent. If your team is mostly engineers, start with Claude Code. If you have non-technical team members who need to ship, start with Cursor.
Create your CLAUDE.md (or equivalent project config). This is the single most impactful thing you can do. Document your coding conventions, architecture decisions, testing requirements, and deployment process. Every AI agent reads these files and follows them — it's like onboarding a new developer in 30 seconds.
Start with contained tasks. Don't hand the agent your entire roadmap on day one. Start with:
- Writing unit tests for existing code
- Bug fixes with clear reproduction steps
- Documentation generation
- Refactoring functions the team already understands

Week 2: Expand

Add a second tool. If you started with Claude Code, add Cursor for your frontend work. If you started with Cursor, add Claude Code for your complex backend tasks.
Enable CI integration. Claude Code's hooks system can auto-fix failing CI. Set it up so the agent catches lint errors, type issues, and test failures before they hit your PR review queue.
Let a non-engineer try. Give your most technically curious non-engineer a Cursor seat and a well-defined feature request. You'll be surprised.

Week 3+: Scale

Run parallel agent sessions. Each engineer should be comfortable running 2-3 agent sessions simultaneously — one per task stream.
Establish review protocols. AI-generated code still needs human review. Set up your code review process explicitly: what to look for, what the agents get wrong, and what patterns to enforce.

What to Delegate vs. What to Keep Human

This is where most teams get it wrong. They either under-delegate (using AI as fancy autocomplete) or over-delegate (trusting agents with architectural decisions they shouldn't make).

Delegate to AI Agents ✅

Boilerplate and scaffolding — CRUD endpoints, model definitions, form components, API clients
Test writing — Unit tests, integration tests, test data generation
Bug fixes with clear repro steps — Stack traces, error messages, reproduction paths
Refactoring — Renaming, extracting functions, migrating patterns across files
Documentation — API docs, README files, inline comments, changelog entries
Code review first pass — Style violations, common bugs, missing error handling
Data transformations — ETL scripts, format conversions, migration scripts

Keep Human 🧠

Architecture decisions — Service boundaries, database choices, API contract design
Security-critical code — Authentication flows, encryption, access control, input validation
Business logic validation — Does this feature actually solve the customer's problem?
Performance optimization — Agents can profile, but humans need to decide what tradeoffs to accept
Incident response — When production breaks at 3 AM, you need human judgment about risk and rollback
Hiring and team decisions — AI makes your existing team more productive. It doesn't replace the need for the right people.

⚠️ The "Entertainment Purposes" Warning: Microsoft recently added "for entertainment purposes only" to Copilot's Terms of Service — while simultaneously marketing it as an enterprise productivity tool. This is the legal reality of AI-generated code in 2026: the tools are powerful, but liability sits with you. Always review, always test, and never ship agent-generated code to production without human verification of security-critical paths.

The Honest Limitations

We're bullish on AI coding agents. We're also engineers. Here's what doesn't work yet.

1. Novel Architecture Is Still Hard

AI agents excel at implementing patterns they've seen in training data. Ask Claude Code to build a standard REST API, and it'll produce excellent code. Ask it to design a novel event-sourcing architecture for your specific domain constraints, and you'll get something that looks right but misses subtle requirements. Agents implement. Humans architect.

2. Context Windows Have Limits

Even Claude's 1M token context window has boundaries. Large monorepos with hundreds of services still overwhelm agents. The workaround: structure your codebase into well-defined modules with clear interfaces. Good architecture isn't just for humans anymore — it's for your AI agents too.

3. Debugging Novel Failures

When the bug is a known pattern — null pointer, race condition, off-by-one — agents are excellent debuggers. When the failure is a novel interaction between your specific library versions, infrastructure configuration, and business logic, agents struggle. They'll suggest plausible fixes that don't address the root cause. For hard bugs, agents are research assistants, not fixers.

4. The Security Surface Area

Every AI agent that reads your codebase is a potential data exposure vector. The Axios NPM supply chain compromise that hit Hacker News today (1,588 points) is a reminder: your dependency chain is your attack surface. AI agents that run arbitrary shell commands add another dimension to that surface. Sandboxing, network isolation, and review gates aren't optional.

5. The "Looks Right" Problem

AI-generated code compiles, passes tests, and looks clean. It can also contain subtle logic errors that only surface under specific conditions. The agents are getting better at this — Claude Opus 4.6 catches many of its own mistakes — but human review remains non-negotiable for anything customer-facing.

A Google DeepMind researcher shared how he stopped writing progress indicators in his code entirely — instead, he just asks a Codex session for ETAs:

View original post on X →

That's a creative use case — but it also reveals how deeply these agents are integrating into developer workflows. The integration is happening whether the limitations are solved or not.

The Economics: Why This Changes Startup Strategy

The math is simple and brutal.

A 25-person engineering team at Bay Area market rates costs roughly $6-8M per year in fully-loaded compensation. A 5-person team with AI agent tooling costs $1.5-2M per year in compensation plus maybe $50K-100K per year in AI tool subscriptions.

That's a 4-5x cost reduction with comparable (and sometimes superior) output velocity. For startups, this isn't just an efficiency gain — it's a fundamentally different funding equation. You need less capital, which means less dilution, which means more optionality.

Variance raised $21M at a point where many comparably-capable companies would have needed $50M+. They're not being capital-efficient because they're scrappy. They're capital-efficient because AI agents changed the production function.

📊 The funding implications: If 5 engineers with AI agents match the output of 25 engineers without them, the Series A you need drops from $15M to $5M. That's not just less dilution — it's a completely different relationship with your investors. You can be profitable earlier, default alive sooner, and keep strategic control longer.

What Happens Next

Three trends to watch:

1. Agent-to-agent collaboration. Today, each agent session is independent. The next step — already emerging in tools like OpenClaw and Paperclip — is agents that coordinate with each other. One agent writes the feature, another writes the tests, a third reviews both.

2. Non-engineer builders at scale. Variance's customer success manager is an early signal. Within 12 months, expect product managers, designers, and ops teams at AI-native companies to routinely ship code through agent interfaces. The title "developer" will increasingly describe a skill set, not a job title.

3. The agency model disruption. If a 5-person startup can match a 25-person team, what happens to software consultancies and agencies? They either adopt agents at the same rate (compressing team sizes and billing models) or they get undercut by solo operators and tiny teams who can.

The Betting Markets Agree: Tech Layoffs Are Coming

This isn't just anecdotal. Polymarket — the world's largest prediction market — has real money backing these trends:

Market	Odds	Volume
Tech layoffs up in 2026?	93% Yes	$10.4K
Tech layoffs up in Q1 2026?	86% Yes	$56
US unemployment hits 5.0%+ in 2026?	60% Yes	$344K
AI bubble burst by Dec 2026?	22% Yes	$3M

View market on Polymarket →

Bettors with real money on the line — $344K on the unemployment market alone — overwhelmingly expect tech layoffs to increase this year. The 93% consensus on rising tech layoffs isn't speculation. It's the market pricing in exactly what Variance is demonstrating: five engineers with AI agents replace twenty-five without them.

The uncomfortable math: if a 5-person startup matches a 25-person team, that's an 80% headcount reduction at equivalent output. Scale that across the industry — where CS grad placement has already collapsed from 89% to 19% and solo-founded companies now make up 36% of new startups (up from 23% five years ago) — and the prediction markets are pricing in the inevitable.

The signal isn't that AI replaces engineers. It's that AI makes small teams so productive that large teams become a competitive disadvantage. The overhead of coordination, communication, and management doesn't scale down — it just becomes unnecessary weight.

Getting Started Today

If you're a startup founder or engineering lead reading this, here's the 30-minute version:

Sign up for Claude Code Max ($100/month) or Cursor Pro ($20/month). Pick based on your team's terminal comfort level.
Create a CLAUDE.md file in your repo root documenting your project's conventions, architecture, and testing requirements.
Give the agent a real task — not a toy demo. A bug fix. A feature. A test suite. Something that would normally take 2-4 hours of human time.
Measure the actual time savings including review time. Your first task might be slower (learning curve). Your fifth task will blow your mind.
Add a second agent tool within two weeks. The multi-agent setup is where the 3-5x multiplier lives.

The companies that figure this out first don't just move faster. They win markets while competitors are still hiring.

The AI coding landscape moves fast. We track the latest tools, benchmarks, and real-world case studies weekly. Follow ComputeLeap for analysis that cuts through the hype.

🔗 Full article with charts and interactive sources on ComputeLeap → | Follow @ComputeLeapAI

Vibe Coding in 2026: How Founders Are Building Real Products Without Engineering Teams

Max Quimby — Tue, 31 Mar 2026 15:13:55 +0000

📖 Read the full version with charts and embedded sources on ComputeLeap →

Chamath Palihapitiya built a replacement HR system for his company on a Sunday. Not a prototype — a working system that replaced the vendor. Jason Freeberg shipped annotated.com, a project he'd been thinking about for 15 years, in a single weekend. Neither of them wrote code in the traditional sense. They described what they wanted, and AI built it.

This isn't a hypothetical future. It's happening right now, in March 2026, and the results are forcing everyone — founders, engineers, investors — to recalibrate what's possible.

"The unit of software production has changed from team-years to founder-days. Act accordingly." — Garry Tan, Y Combinator CEO, March 29, 2026

But here's the thing: vibe coding isn't magic. It's a skill with a workflow, a toolchain, and very real limits. This guide breaks down what's actually working, what breaks, and how to get started — without the hype.

What Is Vibe Coding?

The term comes from Andrej Karpathy, former Tesla AI director and OpenAI researcher, who coined it in early 2025:

"There's a new kind of coding I call 'vibe coding,' where you fully give in to the vibes, embrace exponentials, and forget that the code even exists."

Karpathy wasn't describing sloppy work. He was describing a fundamental shift in how software gets built: instead of writing code line by line, you describe what you want in natural language, and an AI agent writes, tests, and iterates on the implementation. You steer with intent. The AI handles syntax.

In practice, vibe coding means:

Describing features in plain English (or any language)
Reviewing what the AI generates — not writing it from scratch
Iterating through conversation — "make the sidebar collapsible" or "add error handling for the API timeout case"
Testing by using the app, not by reading every line of code
Shipping when it works, not when you understand every implementation detail

It's closer to being a product manager who can deploy than a programmer who designs products. And in 2026, the tools have gotten good enough that this actually works for real applications.

The Evidence: Real Products Built Without Engineers

Let's start with what's actually been shipped. Not demos. Not "Hello World" apps. Real products that people use.

The All-In Podcast Revelations

The All-In crew — four billionaire tech investors who collectively touch hundreds of companies — have been vibe coding on air. Here's what they've reported:

Chamath Palihapitiya replaced his company's HR system by vibe coding it himself on a Sunday. Not a weekend hackathon with a team. Just him, an AI coding agent, and a problem to solve. The old vendor system cost money and was mediocre. The replacement works and does exactly what his company needs.

Jason Freeberg had been thinking about annotated.com for 15 years — a project he never had time to build because building software used to require... well, a lot of building. In a single weekend with AI coding tools, he went from concept to deployed product.

David Sacks described the overall shift: the barrier to testing a business idea is now close to zero. If you have a product idea, you can have a working prototype by Monday morning.

⚠️ Reality check: These are technically sophisticated people. Chamath has a CS background. Sacks has built multiple software companies. They're not "non-technical" — they're technical people who stopped writing code years ago and can now build again. The tools didn't give them knowledge they lacked. The tools removed the friction between their knowledge and a working product.

The YC Signal

Y Combinator's current batch tells the story in numbers. Garry Tan, YC's CEO, has been the most vocal advocate for what's happening:

// Detect dark theme var iframe = document.getElementById('tweet-2038297938892607812-360'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2038297938892607812&theme=dark" }

His follow-up was equally pointed:

// Detect dark theme var iframe = document.getElementById('tweet-2038318965741019528-285'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2038318965741019528&theme=dark" }

"Plan well before, test well afterwards" — that's the entire workflow in one sentence. Vibe coding isn't about eliminating skill. It's about changing where the skill gets applied. The thinking moves upstream (what to build, how to architect it) and downstream (testing, iterating, deploying). The middle part — writing the actual code — is increasingly handled by AI.

Peter Diamandis: The Macro View

Peter Diamandis, the XPRIZE founder who's been tracking exponential technologies for decades, has been making an even bolder claim: AI can now run significant parts of your company, not just write code.

His argument: the same AI agents that write code can also handle customer support, data analysis, content creation, and operational workflows. Vibe coding is just the most visible manifestation of a broader shift — AI as a general-purpose business tool, not just a developer productivity booster.

The Tools: Your Vibe Coding Stack

Not all AI coding tools are created equal. Here's an honest breakdown of the major players in March 2026, what each is best at, and who should use what.

Claude Code — The Power User's Choice

What it is: Anthropic's command-line AI coding agent. Runs in your terminal, reads your files, writes code, runs tests, commits to git, executes shell commands.

Best for: Developers and technical founders who are comfortable in a terminal. Full-stack applications, complex refactors, CI/CD integration.

Strengths:

Massive context window (1M tokens) — it can hold your entire codebase in working memory
Autonomous agent behavior — give it a task, it figures out the steps
Direct filesystem and git integration — no copy-paste workflow
The .claude/ folder system for persistent project memory
Auto-fix integration with CI pipelines

Limitations:

Terminal-only — no visual interface for non-technical users
Requires Anthropic Max subscription ($100/month) for Opus-tier model access
Steeper learning curve than GUI-based alternatives

💡 Best starting point: Install it (npm install -g @anthropic-ai/claude-code), navigate to a project folder, and type claude. Then describe what you want in plain English.

Cursor — The IDE Experience

What it is: A fork of VS Code with deep AI integration. Code editor with AI that can read your codebase, suggest changes across files, and execute multi-step plans.

Best for: Developers who want AI assistance within a familiar IDE environment.

Strengths: Familiar VS Code interface, multi-file editing with diff previews, multiple AI model backends, strong autocomplete alongside agentic mode.

Limitations: Expensive at scale (Pro + API costs), less autonomous than Claude Code, desktop app dependency.

Windsurf (Codeium) — The Balanced Option

What it is: Another AI-enhanced IDE with its own model and "Cascade" agent flow.

Best for: Developers who want a polished AI IDE experience with good context awareness.

Replit Agent — The No-Setup Option

What it is: A fully browser-based AI coding agent. Describe your app, Replit Agent builds it, deploys it, and gives you a URL.

Best for: True non-technical founders. People who want to go from idea to deployed app without installing anything.

Strengths: Zero setup, built-in deployment, database/auth/hosting included, truly accessible to non-programmers.

Limitations: Less architectural control, vendor lock-in, struggles with complex multi-service architectures.

Bolt (StackBlitz) — The Rapid Prototyper

What it is: Browser-based AI app builder focused on speed.

Best for: Rapid prototyping, landing pages, simple web apps. Testing ideas before committing to a full build.

Which Tool Should You Pick?

If you are...	Start with...	Why
Technical founder, comfortable with terminal	Claude Code	Most powerful, most autonomous
Developer who wants AI in their IDE	Cursor	Familiar interface, strong multi-file support
Non-technical founder	Replit Agent	Zero setup, built-in hosting
Testing an idea quickly	Bolt	Fastest from idea to visual prototype
Want a balance of power and polish	Windsurf	Good middle ground

The Workflow: From Idea to Deployed App

Here's the actual process that works. Not theory — this is what founders are using daily.

Step 1: Define Before You Describe

The biggest mistake is jumping straight into "build me an app." The AI is only as good as your spec.

Before you open any tool, write down:

What the app does (one sentence)
Who uses it (be specific)
Core features (3-5 max for v1)
What success looks like

Garry Tan's advice: plan well before. Spend 30 minutes thinking. This saves hours of AI-generated code that solves the wrong problem.

Step 2: Scaffold With Conversation

Start your AI tool and describe your app in detail. Be specific:

Bad: "Build me a project management app"

Good: "Build a project management app for freelance designers. It needs: a kanban board with drag-and-drop, a client portal where clients can view progress and leave comments, file upload for design deliverables, and email notifications when tasks change status. Use Next.js with TypeScript, Tailwind CSS, and Supabase for the backend."

Step 3: Iterate, Don't Rewrite

Treat the AI like a junior developer, not a code generator. After the initial scaffold:

Use the app. Click every button. Fill out every form.
Note what's wrong — but don't fix it yourself.
Describe the problem to the AI.
Watch it fix the issue, test again, repeat.

Step 4: Test Like a User

You probably can't read every line of generated code. Instead:

Test every user flow end-to-end
Try to break it — enter weird data, click fast, open multiple tabs
Have someone else use it without guidance
If it handles money or sensitive data, get a real engineer to review security

Step 5: Deploy and Iterate in Production

Ship early. Ship ugly. Ship with known issues. Get real users touching it, then iterate based on actual feedback.

Where Vibe Coding Breaks Down

This is the section most guides skip. Here's where it fails.

Complex State Management

AI tools struggle with intricate, interrelated state. Think: collaborative document editors with multi-user editing, undo/redo, conflict resolution. The AI can scaffold this, but subtle sync bugs will eat you alive.

Rule: If your core value depends on getting state management exactly right, you need an engineer.

Security-Critical Systems

Vibe coding an app that handles payments, medical records, or auth is dangerous. AI models generate code that works but may have SQL injection vectors, insecure token storage, or missing input validation.

Rule: If a security breach would be catastrophic, get a human security review. No exceptions.

Performance at Scale

AI-generated code tends to be correct but naive — O(n²) algorithms, N+1 queries, loading datasets into memory. For 100 users, fine. For 100,000, your app falls over.

Rule: If you expect real scale, plan for an engineering hire to optimize critical paths.

Large, Evolving Codebases

AI tools work best on greenfield projects. Once your codebase grows beyond ~50,000 lines, the AI starts losing coherence.

📊 The honest math: Vibe coding gets you from 0 to 80% remarkably fast. The last 20% — edge cases, performance, security, scale — still requires traditional engineering. But that 80% used to require a team and months of work. Now it takes one person and a weekend.

Who Should (and Shouldn't) Vibe Code

Vibe Coding Is For You If:

You're a founder validating an idea. Get a prototype in front of users before spending $50K on a dev team.
You're a domain expert who can't code. Your domain knowledge is the hard part — the coding is now the easy part.
You're a developer who wants to move faster. AI for scaffolding, you for critical logic.
You're building internal tools. Lower reliability bar, higher tolerance for iteration.
You're prototyping. For any prototype, vibe coding is the fastest path.

Vibe Coding Is NOT For You If:

Failure has serious consequences. Medical devices, financial trading, infrastructure software.
You need to maintain a complex system over years. AI-generated codebases can become unmaintainable.
You're competing on technical depth. If your moat is engineering quality, you need engineers.
You refuse to learn anything. You need enough technical literacy to evaluate AI output.

Getting Started Today

Day 1: Pick One Tool, Build One Thing

Terminal comfort? Install Claude Code, build a task manager.
Zero setup? Go to bolt.new, describe a landing page, deploy it.
Maximum guidance? Open Replit, start an Agent session, describe a simple app.

Day 2: Build Something You Actually Need

A tool your team needs. A prototype of your business idea. An automation for something you do manually.

Week 1: Ship to Users

Deploy. Give it to real people. Collect feedback. Iterate.

The Cost

Claude Code: $20-100/month
Cursor: Free tier, Pro $20/month
Replit: Free for basics
Bolt: Free to start
Windsurf: Free tier available

Compare: one software engineer = $150K-250K/year + equity + benefits + onboarding.

The Bottom Line

Vibe coding in 2026 is real, practical, and changing how software gets built. The evidence is Chamath replacing enterprise software on a Sunday, Garry Tan reframing the unit economics, and thousands of founders shipping products that would have required engineering teams a year ago.

But it's not a replacement for software engineering. It's a new layer — a way for more people to build more things, faster.

The barrier to building software just dropped to near zero. What matters now is what you decide to build.

🚀 Start now: Pick one tool, build one thing this weekend, deploy it. You can't evaluate vibe coding by reading about it — you have to feel the workflow.

🔗 Full article on ComputeLeap → | Follow @ComputeLeapAI

Anthropic vs OpenAI 2026: Who’s Actually Winning?

Max Quimby — Sun, 29 Mar 2026 23:06:07 +0000

In 2021, Dario Amodei walked out of OpenAI with his sister Daniela and roughly 30 researchers. They didn't get fired. They weren't poached. They revolted — because they believed the company they'd helped build was heading somewhere dangerous.

📖 Read the full version with charts, Polymarket data, and embedded sources on ComputeLeap →

Three years later, they were an interesting footnote: the safety nerds who left the rocket ship.

Five years later — right now, in March 2026 — they're on the Wall Street Journal's front page, Dario is comparing his former colleagues to Hitler and Stalin, ChatGPT's market share has collapsed from 69% to 45%, and Anthropic is on track to overtake OpenAI in revenue by mid-year.

The revolt won.

This isn't a neutral comparison piece. The data has a clear direction, and pretending otherwise would be dishonest. But this also isn't hagiography — Anthropic faces real risks that could reverse everything. We'll get to those.

First, let's talk about the week that made the outcome undeniable.

The Week Everything Flipped

The week of March 22–29, 2026 didn't start the reversal. But it made it impossible to ignore.

In seven days:

Anthropic's next-generation model leaked. Fortune reported that roughly 3,000 internal documents were found on a publicly accessible server, revealing a model called "Mythos" — described internally as "by far the most powerful AI model we've ever developed." A new capability tier above Opus. Reddit exploded: "Anthropic May Have Had An Architectural Breakthrough!" hit 866 upvotes and 302 comments on r/singularity.

"Anthropic May Have Had An Architectural Breakthrough!" — 866 upvotes, 302 comments on r/singularity

View thread on Reddit →

OpenAI killed Sora. The AI video platform that once broke the internet was burning $15 million per day in inference costs — $130 per 10-second clip, $5.4 billion annually. Disney's $1 billion content deal? Dead. CEO Fiji Simo pulled the plug as pre-IPO cleanup.
Claude Code crossed $2.5 billion ARR. Nine months from launch to $2.5 billion, per Forbes — the fastest B2B product ramp in AI history, now driving over half of Anthropic's enterprise revenue.
Karen Hao's exposé dropped a bomb. The investigative journalist's Diary of a CEO interview drew on 300+ interviews — including 90+ current and former OpenAI employees — for her book Empire of AI. The NDA wall cracked wide open during IPO prep. Timing? Chef's kiss.
The All-In Podcast called it "generational." Chamath Palihapitiya and the Besties — who'd been skeptical of Anthropic for two years — used the word that venture capitalists only break out when they're genuinely spooked: this run is generational.
Dario Amodei went scorched earth in the WSJ. But more on that later.

This isn't a bad quarter for OpenAI. This is a regime change.

The scoreboard, March 29, 2026: ChatGPT app market share down from 69% to 45%. Anthropic ARR at ~$19B (up from $9B at end of 2025). Claude Code at $2.5B ARR from zero in 9 months. OpenAI projecting a $14B net loss. Sora dead. Claude hit #1 on the U.S. App Store. Polymarket gives Anthropic a 99% chance of having the best AI model at end of March.

The Founding Schism — 2021

To understand why March 2026 matters, you need to understand why Anthropic exists at all.

Why They Left

Dario Amodei was VP of Research at OpenAI. Daniela Amodei was VP of Safety & Policy. They weren't outsiders critiquing from the sidelines — they were the people closest to the work and closest to the risk.

The disagreements weren't abstract. According to the WSJ's reporting, the breaking point came when OpenAI President Greg Brockman floated the idea of selling artificial general intelligence to governments — specifically the nuclear powers on the UN Security Council. Russia. China. The United States.

Dario considered this "tantamount to treason" and nearly quit on the spot. He demanded direct board reporting and said he couldn't work with Brockman. The relationship was unsalvageable.

What followed wasn't a quiet departure. Roughly 30 researchers left together — not leaked out over months, but in a coordinated exodus. This was a revolt, rooted in a specific philosophical conviction: that the path OpenAI was on would end badly, and that there was a better way to build transformative AI.

What They Built Instead

Anthropic's founding thesis was deceptively simple: you could build the most capable AI systems and the most responsible ones. These weren't opposing goals — in fact, the safety research (Constitutional AI, the Responsible Scaling Policy) would produce better models, not handicapped ones.

The early years looked like a bet against the market. While OpenAI was shipping consumer features, signing Microsoft deals, and racing to ChatGPT, Anthropic was publishing papers on AI alignment and carefully releasing Claude with guardrails that competitors mocked as overcautious.

The mockery aged poorly.

The Pattern Nobody Noticed

Here's what most analysis of Anthropic gets wrong: the company's contrarian bets weren't principled instead of strategic. They were principled and strategic. Refusing to ship features that compromised safety wasn't leaving money on the table — it was building the kind of trust that enterprise customers and developers pay a premium for.

But that thesis needed time to prove itself. And in 2024, with OpenAI holding 69% market share and a $157 billion valuation, the clock looked like it was running out.

Then OpenAI started making mistakes.

OpenAI's Unforced Errors

The most important thing to understand about OpenAI's decline is that nobody did this to them. Every wound was self-inflicted.

The Pentagon Bet That Backfired

In late February 2026, Anthropic walked away from a Pentagon contract for AI systems that could be used in autonomous weaponry and mass surveillance. Their position: the technology wasn't ready for fully autonomous military deployment, and they weren't willing to pretend otherwise.

The Trump administration's response was immediate and unprecedented: a federal blacklisting of Anthropic from all government agencies. First time a sitting president had targeted an AI lab for refusing a military contract.

OpenAI took the deal Anthropic refused. Within 48 hours.

The consumer backlash was the most expensive PR disaster in AI history.

TechCrunch, citing Sensor Tower data, reported the damage: ChatGPT uninstalls surged 295% day-over-day. One-star reviews spiked 775% in a single day. ChatGPT downloads dropped 13%. Meanwhile, Claude downloads jumped 51%, and the Claude app hit #1 on the U.S. App Store — leaping 20+ ranks in under a week.

"US judge says Pentagon's blacklisting of Anthropic looks like punishment for its views on AI safety" — 2,346 upvotes on r/technology

View thread on Reddit →

On Reddit, "Cancel your ChatGPT Plus, burn their compute on the way out, and switch to Claude" hit 29,903 upvotes on r/ChatGPT — OpenAI's own subreddit. The top comment: "Anthropic was founded by people who left OpenAI specifically because they saw the company abandoning its mission. Turns out they were right about every single concern they raised."

An estimated 1.5 million subscription cancellations followed. A federal judge later said the Pentagon's blacklisting of Anthropic "looks like punishment for its views on AI safety."

Pentagon domino effect: Anthropic refuses contract → Trump blacklists Anthropic → OpenAI takes the deal → 295% uninstall spike → 775% 1-star review surge → ~1.5M cancellations → Claude hits #1 App Store. Every step of the sequence was a foreseeable consequence. OpenAI walked into it anyway.

The Sora Money Pit

Sora was supposed to be OpenAI's moonshot — the platform that proved AI could create professional-quality video. Instead, it became the most expensive demo reel ever built.

The numbers are staggering. At peak usage, Sora was generating 11 million clips per day at a compute cost of roughly $130 per 10-second clip. That's $15 million per day in inference alone — $5.4 billion annualized. OpenAI's adjusted gross margin fell from 40% to 33% before the kill decision was made.

Disney had signed a $1 billion deal granting Sora access to over 200 characters, including Mickey Mouse and Darth Vader. That deal is now dead. Fiji Simo killed Sora as pre-IPO cleanup, and honestly? It was the most rational decision OpenAI has made in a year.

But rationality doesn't reverse the narrative damage. Killing your flagship creative product weeks before an IPO tells the market something uncomfortable: we built something we couldn't afford to run.

The Culture Cracking Open

Then there's the human cost. Karen Hao's Empire of AI, drawn from over 300 interviews including 90+ current and former OpenAI employees, paints a picture of an organization in internal turmoil — and it dropped at the worst possible time for OpenAI's IPO narrative.

The key pattern Hao documents: every major builder at OpenAI eventually left feeling used, and each one started a direct competitor. Dario Amodei founded Anthropic. Ilya Sutskever founded Safe Superintelligence Inc. Mira Murati founded Thinking Machines Lab. No other tech company has seen its entire original builder team walk out and compete head-on.

Hao's reporting also alleges that Altman tailored the AGI narrative depending on his audience — "cure cancer" for Congress, "best assistant ever" for consumers, "$100 billion revenue machine" for Microsoft. Whether that's savvy marketing or something more corrosive is a question each reader can answer for themselves.

"Karen Hao Whistleblower Exposed How Sam Altman Allegedly Manipulated Elon Musk" — 252 upvotes on r/ArtificialInteligence

View thread on Reddit →

What's not debatable is the timing: when 90+ employees are willing to talk to a journalist during IPO prep, the NDA wall isn't just cracking. It's crumbling.

Anthropic's Jiu-Jitsu

Anthropic didn't win by outspending OpenAI or out-hiring them. They won by turning every "no" into a competitive advantage. It's strategic jiu-jitsu — using the opponent's momentum against them.

Saying No as Strategy

Consider the pattern:

No to the Pentagon → earned public trust → Claude downloads surge 51% → #1 App Store → subscriber growth that would have cost billions to acquire through marketing.

No to erotic chatbots → maintained the safety brand → became the default choice for enterprise customers who need to explain their AI vendor to a compliance department.

No to shopping features and side quests → maintained developer focus → Claude Code dominance → $2.5B ARR from the highest-value customer segment in tech.

Each "no" looked like leaving money on the table at the time. Collectively, they built a moat that money can't replicate: trust. In AI, where every customer knows they're handing over sensitive data and critical workflows to a model they can't fully audit, trust isn't a nice-to-have. It's the product.

If you've been following our comparison of Claude, ChatGPT, and Gemini, this pattern has been building for months. The Pentagon moment just made it visible to everyone else.

The Claude Code Phenomenon

Claude Code is the most important product launch in AI since ChatGPT itself — and almost nobody outside the developer community noticed until the revenue numbers forced them to.

Launched in mid-2025, Claude Code reached $2.5 billion in annual run-rate revenue by early 2026, doubling since January. It serves over 300,000 business customers and now drives more than half of Anthropic's enterprise revenue. We've covered the implications of agentic coding in our deep dive on Claude Code's remote task capabilities — what's happening here is bigger than a product launch. It's a platform shift.

The product itself keeps accelerating: Auto Dream (memory consolidation modeled on human REM sleep), auto-fix in the cloud for CI pipelines, a hooks system for custom workflows, and iMessage integration that signals where agents are heading next. The creator ecosystem is exploding — 5+ tutorial videos per day, ecosystem velocity that exceeds even the early GPT-wrapper era.

Claude Code ARR trajectory: $0 at launch (mid-2025) → ~$1.2B (January 2026) → $2.5B (March 2026). Key milestones along the way: Auto Dream memory consolidation, cloud auto-fix for CI pipelines, hooks system for custom workflows, and iMessage integration. The fastest B2B product ramp in AI history — and it's still accelerating.

Matthew Berman's widely-watched model tier list placed Claude as S-tier and ChatGPT as A-tier. For developers, the hierarchy has quietly settled: Claude Code is the tool you reach for first. If you're building AI-powered development workflows, our comparison of the best AI coding assistants breaks down exactly why.

Mythos — The Next Punch

Then there's the leak that might not have been a leak.

In late March, Fortune reported that roughly 3,000 unsecured digital assets were discovered on a publicly accessible Anthropic server. Among them: documentation for a model called Mythos, described as "by far the most powerful AI model we've ever developed," with dramatically higher scores on software coding, academic reasoning, and cybersecurity benchmarks compared to the current flagship Opus 4.6.

The most intriguing detail: Mythos represents a new capability tier called "Capybara" — above Opus. Anthropic has never created a tier above Opus before. The planned release strategy? Cybersecurity organizations first, not the general public. The stated reason: Mythos is "currently far ahead of any other AI model in cyber capabilities" and could enable attacks that "far outpace the efforts of defenders."

Anthropic called the exposure "human error." Maybe it was. But the timing — right when the competitive narrative favors Anthropic, right when OpenAI is hemorrhaging trust — gave Anthropic the best of both worlds: free publicity for their most impressive model and the responsible AI narrative of only releasing it to defenders first.

Was the Mythos leak intentional? Probably not — 3,000 unsecured files is an embarrassingly large surface area for a controlled leak. But the rapid cleanup, immediate confirmation, and "cybersecurity-first release" narrative suggest Anthropic pivoted fast from "security incident" to "strategic positioning." Never let a crisis go to waste.

The Dario Interview That Changed the Tone

On approximately March 10, the Wall Street Journal published "The Decade-Long Feud Shaping the Future of AI" — and Dario Amodei stopped being diplomatic.

The quotes are extraordinary for a sitting CEO of a company valued at $380 billion:

He compared the legal battle between Sam Altman and Elon Musk to "the fight between Hitler and Stalin."

He dubbed Greg Brockman's $25 million donation to a pro-Trump super PAC "evil."

He likened OpenAI and other rivals to "tobacco companies knowingly hawking a harmful product."

"Altman is as evil as Stalin — Dario Amodei" — 664 upvotes, 198 comments on r/OpenAI

View thread on Reddit →

This is a CEO going on the record in the Wall Street Journal with language that would get most PR teams fired. The Hitler-Stalin comparison alone would normally be career-ending in corporate America.

But here's what's interesting: the market didn't punish it. If anything, it accelerated the narrative shift. Why?

Because Dario wasn't being reckless — he was being specific. The Hitler-Stalin comparison wasn't about character; it was about the dynamic between Musk and Altman's legal battle, two powerful figures fighting each other while the real stakes (AI governance) went unaddressed. The "tobacco companies" framing wasn't hyperbole; it was a reference to knowingly shipping products with downplayed risks.

And the "treason" accusation — that Brockman wanted to sell AGI to the UN Security Council nations including Russia and China — wasn't name-calling. It was a description of a specific proposal that, if accurate, represents the most reckless idea in tech history.

The r/singularity thread hit 591 upvotes. The r/OpenAI thread hit 664. These aren't massive numbers — but they're happening on OpenAI's home turf. The narrative has shifted from "Anthropic is the underdog" to "Anthropic is the frontrunner who's now willing to play offense."

The Numbers Don't Lie

Strip away the narrative. Strip away the Reddit threads and the WSJ quotes and the podcast takes. What do the raw numbers say?

Market share shift (Jan 2025 → Mar 2026): ChatGPT app share declined from 69% to 45%. Claude's share rose from ~5% to ~15-20%. The crossover trajectory is clear — and accelerating after the Pentagon backlash. Source: All-In E220, TechCrunch/Sensor Tower data.

Metric	OpenAI (March 2026)	Anthropic (March 2026)
App market share	45% (↓ from 69%)	~15-20% (↑ rapidly)
Annualized revenue	~$25B	~$19B (10× growth/year)
Projected 2026 net income	-$14B loss	Not disclosed (leaner cost structure)
Flagship product killed	Sora ($5.4B/yr burn)	None
Military contracts	Took Pentagon deal	Refused → blacklisted → won ruling
Developer sentiment	A-tier (Berman rankings)	S-tier
Employee morale	90+ talked to Karen Hao	Stable
Latest model	GPT-5.4	Opus 4.6 + Mythos (leaked)
Valuation	~$340B (pre-IPO)	~$380B

Epoch AI's analysis projects the revenue crossover: since each company hit $1 billion in annualized revenue, Anthropic has grown at 10× per year versus OpenAI's 3.4×. If recent trends continue, Anthropic overtakes OpenAI in total revenue by mid-2026.

Revenue crossover projection: Anthropic growing at 10× per year vs OpenAI's 3.4× since each hit $1B ARR. Current: OpenAI ~$25B, Anthropic ~$19B. At these rates, Anthropic overtakes OpenAI in total revenue by mid-2026. Source: Epoch AI growth rate analysis.

And the understanding that this isn't just analyst projection — there's real money behind this — is where the numbers get particularly interesting. The cost of reasoning models has been dropping dramatically, which favors the company with the more efficient architecture.

The Betting Markets Have Already Decided

Polymarket — the prediction market where traders put real money behind their forecasts — tells a story that leaves almost no room for ambiguity.

Market	Result	Volume
Best AI model at end of March 2026	Anthropic: 100%	$16M
Best AI model end of April 2026	Anthropic: 90%	$3M
Will Anthropic or OpenAI IPO first?	Anthropic: 69%	$50.6K
Anthropic $500B+ valuation?	91% yes	$11K
Claude Mythos released by June 30?	70% yes	$37.6K
Claude 5 released by June 30?	59% yes	$3M (161 comments)
Anthropic Pentagon deal?	Only 19% yes	$43.2K
OpenAI has #1 model by June 30?	Only 29%	—

Read those last two lines again. Only 19% of traders think Anthropic will take a Pentagon deal — the market has priced in that Anthropic will continue to say no. And only 29% think OpenAI will reclaim the top model spot by the end of June. With $16 million in volume on the March market alone, this isn't speculation from bored degens — it's institutional-grade conviction.

The betting markets have already decided. The question is whether the fundamentals agree. So far, they do.

Polymarket snapshot, March 29: $16M in volume says Anthropic has the best model. 91% say Anthropic hits $500B+ valuation. Only 29% think OpenAI reclaims #1 by June. When this much money is on the line, sentiment becomes signal.

What Could Go Wrong for Anthropic

The data supports Anthropic winning. But intellectual honesty requires asking: what could reverse this?

The answer isn't nothing. It's four specific things.

The Capacity Problem

Anthropic is growing faster than its infrastructure can handle — and users are noticing.

On r/ClaudeAI, an open letter titled "Want to free up compute during peak hours?" hit 1,052 upvotes — a rare display of user frustration from Anthropic's most loyal community. The complaint: throttled responses, degraded quality during peak usage, and rate limits that feel punitive for paying customers.

"They're adding 1M users/day... It's a miracle these AI services are up at all." — @Austen

Growth this fast can break more than servers. It can break talent pipelines, engineering culture, and the careful quality control that earned Anthropic its reputation. The history of tech is littered with companies that grew faster than their infrastructure — and the ones that survived were the ones that throttled growth until quality caught up. The ones that didn't? Ask anyone who worked at early-growth Twitter.

The Mythos Expectations Trap

When you leak documentation calling your next model "by far the most powerful AI model we've ever developed" and create a new tier above your flagship product, you've set expectations that are nearly impossible to meet.

If Mythos delivers a genuine step-change — the kind of jump that Opus 4 represented over Claude 3 — Anthropic's lead becomes structural. But if Mythos feels like an incremental improvement with better marketing, the narrative reverses fast. Markets reward expectation beats, not absolute performance.

The 70% Polymarket odds on Mythos releasing by June 30 mean there's already a countdown clock ticking. Every week that passes without a release builds both anticipation and skepticism.

The Government Isn't Done

Anthropic won a court ruling, but they haven't won the war.

The federal judge said the Pentagon blacklisting "looks like punishment for its views on AI safety" — a meaningful legal signal. But the government has far more tools than lawsuits: executive orders, procurement requirements, export controls, national security designations. The next administration could flip the entire posture. And the current one has demonstrated willingness to punish companies that don't align with its AI agenda.

The Polymarket number here is telling: only 19% think Anthropic will take a Pentagon deal. That's the market pricing in continued refusal — which means continued government friction.

OpenAI Isn't Dead

Let's not write the obituary yet.

OpenAI still holds 45% app market share. They topped $25 billion in annualized revenue as of February. They just raised an additional $10 billion, bringing total funding past $120 billion. They're hiring aggressively — from 4,500 to 8,000 employees. And the SuperApp consolidation (merging Atlas browser, ChatGPT, and Codex into a single desktop application) is architecturally sound.

Most importantly: Tom's Guide reports that OpenAI is preparing a new model codenamed "Spud" — potentially GPT-6 — and that Sora's compute was freed specifically to train it. If Spud delivers a genuine capability leap, the Polymarket odds reset overnight. Killing Sora was a sacrifice, not a surrender — OpenAI bet that video AI was the wrong game and coding/reasoning is the right one.

The $14 billion projected loss looks alarming until you remember that OpenAI has $120B+ in backing and is targeting a $1 trillion IPO valuation in H2 2026. They can afford to lose money for a long time — the question is whether that money buys them back the trust they've burned.

The realistic bear case for Anthropic: Capacity constraints alienate power users → Mythos underwhelms relative to expectations → Government pressure escalates beyond the courts → OpenAI's "Spud" delivers a genuine GPT-6-level leap → IPO capital gives OpenAI an infrastructure advantage Anthropic can't match. Each of these alone is manageable. Together, they could reverse the narrative.

The Uncomfortable Question

Here's what keeps me thinking about this story long after the numbers are tallied.

If doing the right thing is also the optimal business strategy, what does that mean for every other company?

Anthropic refused the Pentagon contract — and got rewarded with the #1 App Store position and a subscriber wave that would have cost billions to acquire through paid marketing. They refused to ship erotic chatbots — and earned the enterprise trust that's driving $19 billion in ARR. They focused on developer tools instead of consumer gimmicks — and Claude Code became the fastest B2B product ramp in AI history.

Every contrarian bet was a bet on the proposition that responsible AI development produces better commercial outcomes. Not because the market rewards virtue (it usually doesn't), but because in AI specifically, trust is the scarcest resource. When you're asking enterprises to route their most sensitive data through your models, when you're asking developers to build their careers on your platform, when you're asking consumers to trust you with conversations they wouldn't have with another human — the company that demonstrably takes safety seriously has a structural advantage over the company that takes Pentagon contracts and ships adult content.

This isn't a feel-good story. It's a market story. And if Anthropic's thesis is correct — if principle and profit are genuinely aligned in AI — then every company in tech needs to reconsider the assumption that ethics is a cost center.

OpenAI's IPO will be the biggest test. It will either be the comeback story of the decade or the most expensive validation of Dario Amodei's original thesis: that the people who left were right all along.

The betting markets have picked their side. With $16 million in volume.

The question isn't really who's winning anymore. The question is what it means that this is how they won.

This article is part of our ongoing coverage of the AI industry landscape. For a direct model comparison, see our Claude vs ChatGPT vs Gemini breakdown. For a deeper look at how Claude Code is reshaping development workflows, read our analysis of Claude Code's remote task capabilities.

🔗 Full article with charts and interactive sources on ComputeLeap → | Follow @ComputeLeapAI

Anthropic Just Turned Claude Into a Desktop Agent. Here's How CoWork Actually Works.

Max Quimby — Sun, 29 Mar 2026 17:43:21 +0000

Anthropic has been quietly shifting Claude from a developer's tool into something anyone can use. CoWork — a sandboxed agent environment built into Claude Desktop — is the clearest signal yet. No terminal. No command line. Just mount your files, describe what you need, and let Claude work.

📖 Read the full version with charts and embedded sources on ComputeLeap →

This week, Anthropic's Head of Design Jenny Wen sat down with Peter Yang for a 40-minute official walkthrough of CoWork. That's not a casual product update — it's Anthropic telling the market: Claude is for everyone now.

Here's what CoWork actually is, how to set it up, what it's good at, and where it falls short.

What Is Claude CoWork?

CoWork is a tab inside Claude Desktop that gives Claude agent-level capabilities without requiring any technical knowledge. Think of it as Claude Code's non-developer sibling.

When you open CoWork, you get a sandboxed environment where Claude can:

Read and write files from folders you mount (documents, spreadsheets, CSVs, PDFs)
Run code in the background to process data, generate charts, or transform documents
Create and edit files directly — reports, presentations, cleaned datasets
Execute multi-step workflows — "analyze this CSV, find the outliers, write a summary, export it as a formatted PDF"

The key word is sandboxed. CoWork runs in an isolated environment on your machine. It can't browse the web, can't access your email, and can't touch anything you haven't explicitly shared with it. This is a deliberate design choice — Anthropic is trading capability for trust.

CoWork launched in January 2026 as part of the Claude Desktop app. It's available on the $20/month Pro plan — the same tier that gives you access to Claude Opus 4.6 and extended thinking. No additional cost, no waitlist.

How to Access CoWork

CoWork is available to anyone on Claude Pro ($20/month) or higher. Here's how to get started:

Download Claude Desktop from claude.ai/download if you haven't already (macOS and Windows supported)
Sign in with your Claude Pro account
Look for the CoWork tab in the left sidebar — it's separate from the standard chat interface
Mount a folder by clicking the folder icon and selecting a directory from your computer

That's it. No API keys, no configuration files, no environment variables. You point CoWork at your files and start talking.

Your First CoWork Project: A Practical Walkthrough

Let's say you have a folder of monthly sales reports in CSV format and you need a quarterly summary with charts.

Step 1: Open CoWork and mount the folder containing your CSV files.

Step 2: Tell Claude what you need:

"Analyze all the CSV files in this folder. Each one is a monthly sales report. Create a quarterly summary showing total revenue by product category, month-over-month growth rates, and highlight any categories that declined. Export the summary as a formatted markdown report and generate a bar chart comparing the three months."

Step 3: Watch Claude work. CoWork shows you what it's doing in real-time — reading files, running Python code, generating outputs. You'll see the code it writes and the intermediate results.

Step 4: Review the outputs. Claude will create the summary report and chart in your mounted folder. If something's off, just tell it: "The chart needs a legend" or "Break down the electronics category by sub-category."

The feedback loop is conversational. You don't need to understand Python or data analysis — you just need to know what you want.

Best Use Cases for CoWork

After testing CoWork extensively and watching what the community is building, these are the use cases where it genuinely shines:

Data Analysis and Reporting

This is CoWork's strongest suit. Drop CSVs, Excel files, or JSON data into a mounted folder and ask Claude to analyze, visualize, and summarize. It handles:

Sales reports and financial analysis
Survey data processing and visualization
Log file analysis and pattern detection
Cleaning messy datasets (deduplication, format normalization, missing value handling)

Document Processing

CoWork excels at batch document work that would take hours manually:

Extracting structured data from PDFs
Converting between formats (markdown to HTML, CSV to formatted reports)
Summarizing long documents and flagging key sections
Generating templated documents from data (contracts, invoices, proposals)

Project Management Artifacts

Need a project plan, Gantt chart, or status report? Mount your project files and let Claude generate:

Project timelines and milestone tracking
Resource allocation summaries
Risk assessment documents
Meeting notes → action items → follow-up templates

Content Creation Workflows

CoWork is particularly good at content workflows where you need Claude to reference existing materials:

Draft blog posts from research notes and outlines
Create social media calendars from content strategy docs
Generate email sequences from product briefs
Build presentation outlines from meeting transcripts

Power user tip from Jenny Wen's tutorial: Start with a "project brief" file in your mounted folder. Write a plain-text document describing what the project is, what the expected outputs are, and any constraints. When you start a CoWork session, tell Claude to read the brief first. This gives it context that persists across the entire session and dramatically improves output quality.

CoWork vs. Claude Code: When to Use Which

This is the question everyone's asking. Both are Anthropic products. Both give Claude agent capabilities. The difference is who they're built for.

	CoWork	Claude Code
Target user	Non-developers, business users, analysts	Software developers, engineers
Interface	GUI in Claude Desktop	Terminal / CLI
Environment	Sandboxed file system	Full system access (with permissions)
Primary use	Data analysis, documents, content	Writing code, debugging, DevOps
File access	Mounted folders only	Entire project directory + git
Code execution	Background (Python sandbox)	Direct (any language, full toolchain)
Price	$20/mo (Pro)	$20/mo (Pro) or $100/mo (Max)

Use CoWork when: You're working with documents, data, or content and you don't want to touch a terminal. You need Claude to process files, generate reports, or automate office workflows.

Use Claude Code when: You're building software. You need git integration, multi-file code editing, test execution, CI/CD interaction, or anything that requires a real development environment.

They're complementary, not competing. Many people use both — CoWork for business tasks, Claude Code for engineering work.

CoWork vs. Competitors

CoWork isn't the only player in the "AI agent for non-developers" space. Here's how it stacks up.

Paperclip

Paperclip has been positioning itself aggressively as the "CoWork killer" this week, with creators like Nate Herk and Greg Isenberg framing it as the AI-native staffing alternative. The pitch: hire AI agents like employees to handle specific business functions.

The fundamental difference is architecture. CoWork runs locally in a sandbox on your machine — your files stay on your computer. Paperclip routes through cloud APIs.

HuggingFace CEO Clement Delangue flagged this directly: Paperclip sends your data through external APIs, which means your documents, spreadsheets, and business data transit through third-party infrastructure. For anyone handling sensitive data — client information, financial records, internal strategy docs — this is a meaningful distinction.

CoWork advantage: Local execution, data stays on your machine, Anthropic's privacy stance.
Paperclip advantage: More specialized agent templates, "hire an employee" UX metaphor, broader integrations.

ChatGPT Canvas

OpenAI's Canvas is the closest direct comparison. Like CoWork, it provides a workspace for non-developers to collaborate with AI on documents and code.

CoWork advantage: Deeper file system integration (mount entire folders vs. single documents), stronger data analysis pipeline, Claude Opus 4.6's superior reasoning for complex analytical tasks.
Canvas advantage: Better real-time collaborative editing UX, integrated image generation (DALL-E), broader plugin ecosystem.

Google Gemini Workspace Integration

Google's approach is different — rather than a standalone agent environment, Gemini is being woven directly into Workspace apps (Docs, Sheets, Slides, Gmail).

CoWork advantage: More powerful for complex, multi-file workflows. Not locked into Google's ecosystem.
Gemini advantage: Native integration with tools billions of people already use. If you live in Google Workspace, the AI comes to you — you don't go to it.

The bigger picture: Anthropic's $6B ARR (as of February 2026) is 75% API revenue — enterprise developers building on Claude. CoWork is their first serious play for the other 75% of knowledge workers who will never touch an API. The All-In Podcast covered this as Anthropic's "generational run" — and CoWork is a key part of how they sustain it beyond developers.

Limitations You Should Know

CoWork is impressive, but it has real constraints:

No internet access. CoWork can't browse the web, call APIs, or fetch external data. Everything it works with must be in your mounted folder.

No persistent memory across sessions. Each CoWork session starts fresh. Claude doesn't remember what you worked on yesterday. The workaround: keep a "project context" file in your folder that you update after each session.

File type limitations. CoWork handles text-based files well (CSV, JSON, markdown, plain text, Python scripts). Complex Excel files with macros or pivot tables may not parse perfectly.

Rate limits on Pro. The $20/month Pro plan has usage limits. The $100/month Max plan offers higher limits for intensive processing.

macOS and Windows only. No Linux support yet, no mobile, no web-only option. You need the Claude Desktop app.

Tips for Getting the Most Out of CoWork

Structure your folders before starting. Claude works better when files are organized logically — not dumped in a flat mess.
Write a project brief. A 200-word document describing your project, expected outputs, and constraints will save you multiple rounds of back-and-forth.
Be specific about output formats. "Generate a report" is vague. "Generate a markdown report with headers for each product category, a summary table at the top, and bullet points for key findings" gets you what you want on the first try.
Use iterative refinement. Don't try to get everything in one prompt. Start with the core analysis, review it, then refine.
Keep sessions focused. One project per CoWork session. If you need to switch contexts, start a new session with a fresh folder mount.

The Simon Willison prediction, realized: When CoWork launched in January, Simon Willison (the Django co-creator and prominent AI commentator) predicted Anthropic would shift Claude's messaging from "developer tool" to "general productivity agent." Jenny Wen's official tutorial this week — focused entirely on non-developer workflows — confirms exactly that trajectory.

The Bottom Line

Claude CoWork is not revolutionary — it's the logical next step. AI assistants that can read your files, process your data, and generate useful outputs without requiring technical skills. What makes it worth paying attention to is who built it and how it works.

Anthropic's local-first, sandbox approach is a genuine differentiator in a market where most competitors route your data through cloud APIs. The $20/month price point (bundled with everything else Claude Pro offers) makes it accessible. And the quality of Claude Opus 4.6 underneath means the outputs are legitimately good — not demo-quality, but actually usable.

If you're a knowledge worker drowning in spreadsheets, reports, and document processing, CoWork is worth trying. If you're a developer, you probably want Claude Code instead. And if you're evaluating both CoWork and Paperclip, the privacy architecture difference should be your first decision criterion.

The agent wars are heating up. Anthropic just made their move for the non-developer market. Whether that move sticks depends on how fast they can close the gaps — internet access, persistent memory, and the ecosystem integrations that make an agent truly indispensable.

Want the developer-focused perspective? Check out our guide to AI APIs for developers in 2026 and the rise of AI agents.

🔗 Full article on ComputeLeap → | Follow @ComputeLeapAI

ARC-AGI V3 Explained: The New AI Benchmark That Breaks Every Agent

Max Quimby — Sun, 29 Mar 2026 17:41:38 +0000

The Score That Should Have Everyone Worried

On March 28, 2026, the AI world got a number that should be printed on every AGI roadmap in a very large font: 0.3%.

📖 Read the full version with charts and embedded sources on AgentConn →

That's the score GPT-5.4 High and Claude Opus 4.6 Max — the two most capable AI systems on the planet — achieved on ARC-AGI V3. At a cost of $5,000 to $9,000 per task.

Humans? 100%.

Symbolica's Agentica SDK? 36% — and a total bill of about $1,005 for 113 of 182 levels.

This isn't a minor benchmark update. ARC-AGI V3 is the clearest signal yet that the AI industry has been solving the wrong problem.

📊 The V3 Scoreboard

Humans: 100% success rate

Symbolica Agentica SDK: 36.08% (113/182 levels, $1,005 total)

GPT-5.4 High: ~0.3% (at $5,000-9,000 per task)

Claude Opus 4.6 Max: ~0.25-0.3% (similar cost profile)

What Is ARC-AGI, and Why Does It Keep Mattering?

The Abstraction and Reasoning Corpus (ARC) is the benchmark that François Chollet — Keras creator, Google DeepMind researcher, and arguably the AI field's most credible skeptic — designed specifically to measure fluid intelligence rather than memorized knowledge.

The core insight: if a model has seen enough training examples, it can score well on almost any benchmark. ARC was designed from the start to resist this.

V1 to V2 to V3: Closing the Escape Hatches

ARC-AGI V1 (2019): Static 2D grid puzzles. Given a few input-output examples, derive the transformation rule and apply it to a new input.

ARC-AGI V2 (2025): Addressed the contamination problem with harder, more compositional puzzles and stricter novelty guarantees.

ARC-AGI V3 (2026): A complete category shift — interactive video game environments instead of static puzzles.

How ARC-AGI V3 Actually Works

V3 drops agents into interactive video game environments. Here's what that means:

The agent is presented with a novel mini-game it has never seen before
There are zero instructions — no goal, no controls, no rules explained
The agent has a limited number of turns to figure everything out
Success means: discover the goal, learn the controls, understand the rules, complete the task

This is how humans learn to play new games. A 10-year-old can master a new mobile game in minutes. Current AI systems? They break.

💡 Chollet's Core Thesis: LLMs didn't get smarter. They got better-trained on verifiable domains like code. Move to genuinely novel, non-verifiable tasks — and the apparent intelligence evaporates.

François Chollet's Vision — and Warning

His key arguments:

LLMs improved on measurable tasks, not on intelligence itself.
Move to unverifiable domains and progress stalls.
AGI timeline: 2030, but not via the current path. The core engine will fit in fewer than 10,000 lines of code.
The $600K ARC Prize exists to redirect research incentives away from benchmark gaming.

The Results in Context: What 0.3% Actually Means

GPT-5.4 High, running at $5,000-9,000 per task, scored 0.3% on an evaluation where humans score 100%. This is not a narrow gap.

Symbolica's Agentica SDK: 36% at ~$9 per level — approximately 1,000x cheaper than the frontier models that scored near-zero.

The 36% vs 0.3% comparison is a signal about architecture. Symbolica's program synthesis approach outperforms pure LLM scaling by 120x on this benchmark.

Why This Exposes the Agent Industry's Blind Spot

AI agents can write code, browse the web, draft emails. But these are all examples of applying learned patterns to familiar scenarios.

Put an agent in a genuinely novel environment and it collapses. ARC-AGI V3 puts numbers on the failure.

The kicker: the agent industry's go-to defense — it gets better with more context — directly contradicts the V3 premise. You don't get examples. You get to figure it out.

x.com

What Happens Next

Researchers: Hybrid architectures combining pattern matching with program synthesis are more likely to crack V3-style problems than pure scaling
Builders: Stop overselling adaptability. Design for the limitation.
Buyers: Benchmark performance ≠ general capability
AGI watchers: Chollet's 2030 estimate looks more credible. We're not in the final miles.

The score is 100% humans, 36% Symbolica, 0.3% everything else. The gap is the map.

Read the full analysis with multimedia at AgentConn

🔗 Full article on AgentConn → | Follow @ComputeLeapAI

Claude Code Just Hit #1 on Hacker News. Here's Everything You Need to Know.

Max Quimby — Sat, 28 Mar 2026 17:45:45 +0000

Claude Code hit #1 on Hacker News today. The post — a deep dive into the .claude/ folder anatomy — pulled 556 points and counting. Five YouTube tutorials dropped in the last 48 hours. X is buzzing with auto-fix demos, hooks configurations, and cloud session workflows. And Anthropic just shipped conditional hooks and cloud-based auto-fix in the same week.

📖 Read the full version with charts and embedded sources on ComputeLeap →

Something is happening. Claude Code isn't just a developer tool anymore — it's becoming the default way a new generation of builders creates software. Prosumers who've never opened a terminal are cloning repos and shipping sites. Senior engineers are restructuring their entire CI/CD pipelines around it. The adoption curve isn't linear — it's vertical.

This guide covers everything. Installation to advanced workflows. Whether you're opening Claude Code for the first time or you're ready to wire it into your CI pipeline with hooks and auto-fix, this is the resource you bookmark and come back to.

📊 The adoption signal is loud: Chase AI posted 5 Claude Code tutorials in two days. Kenny Liao dropped a beginner-to-mastery deep dive. Matthew Berman ranked Claude S-tier in his March 2026 model tier list — "unbelievable, good at everything." This isn't just developer content anymore. It's prosumer builders using Claude Code as their default "build anything fast" tool.

What Is Claude Code?

Claude Code is Anthropic's command-line AI coding agent. Unlike chat-based AI assistants that suggest code snippets, Claude Code operates directly in your terminal — reading your files, understanding your project structure, writing code, running tests, committing to git, and executing shell commands. It's an autonomous agent, not an autocomplete engine.

Think of the difference like this: GitHub Copilot is a passenger giving directions. Claude Code is a driver who knows the roads, checks the mirrors, and parallel parks.

It runs on Anthropic's Claude models (currently Opus 4.6 by default for Max subscribers, Sonnet 4.5 for Pro) with a massive context window — up to 1 million tokens. That means it can hold your entire codebase in its head while working.

Installation and Setup

Prerequisites

You need:

Node.js 18+ (Claude Code is an npm package)
An Anthropic account with a Max subscription ($100/month for unlimited Opus 4.6) or Pro ($20/month with Sonnet 4.5 and limited Opus)
A terminal — macOS Terminal, iTerm2, Windows Terminal, or any Linux terminal
Git installed and configured

Install Claude Code

npm install -g @anthropic-ai/claude-code

That's it. One command. No Docker containers, no Python virtual environments, no config files to create first.

Authenticate

claude

Running claude for the first time opens a browser window for OAuth authentication with your Anthropic account. Once authenticated, the token is stored locally and you're ready to go.

Verify Your Installation

claude --version
claude /doctor

The /doctor command checks your environment — Node version, authentication status, git configuration, and available tools.

⚡ Pro tip: If you're on macOS, install via Homebrew for automatic updates: brew install claude-code. The npm install works everywhere, but Homebrew keeps you on the latest version without thinking about it.

Your First Project Walkthrough

Let's build something real. Open a terminal, navigate to a project directory (or create a new one), and start Claude Code:

mkdir my-first-project && cd my-first-project
git init
claude

Claude Code launches in interactive mode. You'll see a prompt where you can type natural language instructions. Try this:

Create a React app with TypeScript that displays a real-time 
cryptocurrency price dashboard. Use Vite for the build tool, 
Tailwind CSS for styling, and the CoinGecko free API for data. 
Include a search bar, favorites list, and auto-refresh every 30 seconds.

Watch what happens. Claude Code will:

Plan — outline the architecture and file structure
Scaffold — create package.json, vite.config.ts, tsconfig.json, Tailwind config
Implement — write components, hooks, API integration, types
Configure — set up routing, environment variables, dev scripts
Test — run the dev server to verify everything works

The entire process takes 3-5 minutes.

The .claude/ Folder: Your Project's Brain

This is what hit #1 on Hacker News. The .claude/ folder is where Claude Code stores its understanding of your project. Think of it as the configuration layer between "generic AI" and "AI that knows your codebase."

Here's the anatomy:

.claude/
├── CLAUDE.md           # Project instructions (the big one)
├── settings.json       # Claude Code configuration
├── settings.local.json # Local overrides (gitignored)
├── commands/           # Custom slash commands
│   ├── review.md       # /review command
│   └── deploy.md       # /deploy command
├── skills/             # Reusable capabilities
│   └── my-skill/
│       └── skill.md
└── rules/              # Constraints and patterns
    ├── no-any.md
    └── error-handling.md

CLAUDE.md — The Most Important File

CLAUDE.md is the instruction manual for Claude Code in your project. When Claude starts a session, it reads this file first. Everything in it shapes how Claude understands and works with your code.

A good CLAUDE.md includes:

# Project: CryptoDash

## Architecture
- React 18 + TypeScript + Vite
- State management: Zustand (NOT Redux — we migrated away in v2.1)
- API layer: TanStack Query with custom hooks in src/hooks/api/
- Styling: Tailwind CSS with custom design tokens in tailwind.config.ts

## Conventions
- All components use named exports (not default exports)
- API hooks follow the pattern: useGet{Resource}, useMutate{Resource}
- Error boundaries wrap every route-level component
- Tests colocate with source: Component.tsx → Component.test.tsx

## Do NOT
- Use any type — use unknown with type guards instead
- Import from barrel files (index.ts) in the same package
- Add dependencies without checking bundle size impact first

The CLAUDE.md Hierarchy

Claude Code reads multiple CLAUDE.md files in priority order:

~/.claude/CLAUDE.md — Global instructions (your personal coding style, always applied)
./CLAUDE.md or ./.claude/CLAUDE.md — Project root (team-shared, committed to git)
./src/CLAUDE.md — Directory-specific (instructions for specific parts of the codebase)

Deeper files override shallower ones. Think of CLAUDE.md files like .gitignore — they cascade from general to specific.

The Hooks System: Automating Everything

Hooks are where Claude Code transforms from "AI assistant" to "development platform." They're user-defined commands that execute automatically at specific points in Claude Code's lifecycle.

Hook Events

Event	When It Fires	Common Use
SessionStart	Session begins/resumes	Load environment, inject context
PreToolUse	Before a tool call	Block dangerous commands, validate
PostToolUse	After a tool call succeeds	Auto-format, lint, notify
Notification	Claude needs attention	Desktop alerts, Slack messages
SubagentStart	Subagent spawned	Log, resource management
PreCompact	Before context compaction	Save important context
SessionEnd	Session ends	Cleanup, report generation

Your First Hook: Auto-Format on Save

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write",
        "hooks": [
          {
            "type": "command",
            "command": "npx prettier --write \"$CLAUDE_FILE_PATH\""
          }
        ]
      }
    ]
  }
}

Every time Claude writes a file, Prettier formats it automatically.

Conditional Hooks with if

This just shipped this week — the if field enables conditional hook execution:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "echo 'Blocked: no direct DB access in production'",
            "if": "echo $CLAUDE_TOOL_INPUT | grep -q 'psql.*prod'"
          }
        ]
      }
    ]
  }
}

Prompt-Based Hooks: AI Reviewing AI

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write",
        "hooks": [
          {
            "type": "prompt",
            "prompt": "Review this file change for security vulnerabilities. If you find any, return BLOCK. If safe, return ALLOW.",
            "model": "claude-haiku-4"
          }
        ]
      }
    ]
  }
}

A cheaper, faster model (Haiku) reviews every file write for security issues. AI auditing AI.

Auto-Fix: Claude Code Meets CI/CD

Auto-fix lets Claude Code automatically monitor your pull requests and fix CI failures — linting errors, type errors, failing tests — without you lifting a finger.

The magic: this now runs in the cloud. Your laptop can be closed. Claude Code cloud sessions monitor your PRs and fix them autonomously.

Setting Up Auto-Fix

{
  "autoFix": {
    "enabled": true,
    "github": {
      "ciChecks": ["test", "lint", "typecheck", "build"],
      "maxAttempts": 3,
      "branchPattern": "feat/*"
    }
  }
}

The CI Integration Pattern

name: Claude Auto-Fix
on:
  check_suite:
    types: [completed]

jobs:
  autofix:
    if: github.event.check_suite.conclusion == 'failure'
    runs-on: ubuntu-latest
    steps:
      - uses: anthropic/claude-code-action@v1
        with:
          mode: auto-fix
          max-attempts: 3

⚡ Real-world usage pattern: Start with auto-fix on lint and type errors only. Graduate to test failures once you trust the workflow. Never auto-fix security scans automatically.

Cloud Sessions and Remote Tasks

Anthropic shipped Remote Tasks — the ability to run Claude Code sessions on Anthropic's cloud infrastructure, triggered on schedules or events.

Scheduled maintenance — "Every Monday at 9 AM, audit dependencies and open PRs for outdated packages"
Event-driven workflows — "When a new issue is labeled bug, create a branch, investigate, and open a draft PR"
Continuous documentation — "After every merge to main, update the API docs and changelog"

Advanced Workflows

Multi-Agent Architecture with Subagents

Claude Code can spawn subagents — isolated Claude instances that handle specific subtasks:

Main Agent (Opus 4.6)
├── Subagent 1: "Implement the API endpoints" (Opus)
├── Subagent 2: "Write tests for the API" (Sonnet)
├── Subagent 3: "Update documentation" (Haiku)
└── Subagent 4: "Review all changes" (Opus)

The Harness Engineering Pattern

The most sophisticated Claude Code users build harnesses around it — CLAUDE.md files, hooks, custom commands, MCP integrations, review pipelines, and CI workflows.

The same model scored 78% with one harness and 42% with another. The harness matters more than the model.

Pricing

Plan	Price	Model Access
Pro	$20/month	Sonnet 4.5 (default), limited Opus
Max 5x	$100/month	Opus 4.6 (default), unlimited Sonnet
Max 20x	$200/month	Opus 4.6 extended, priority access
API	Pay-per-token	Any model

Tips That Actually Matter

Write Your CLAUDE.md Before Writing Code — 15 minutes saves hours.
Use /compact Strategically — Run it when Claude starts making mistakes.
Start Conversations with Context — Reference specific files and patterns.
Git Commit Frequently — Gives you rollback points.
Trust But Verify — Always review the diff before merging.
Use the Right Model for the Job — Opus for architecture, Sonnet for features, Haiku for docs.
Hooks Are Your Guardrails — PreToolUse to block, PostToolUse to format, Notification to alert.

Start Building

npm install -g @anthropic-ai/claude-code

Create a CLAUDE.md. Set up your first hook. Push a PR and let auto-fix handle the lint errors. Build something that would have taken you a week — in an afternoon.

🔗 Full article on ComputeLeap → | Follow @ComputeLeapAI

Anthropic Dispatch Review: The AI Desktop Agent That Delivers Finished Work

Max Quimby — Sat, 28 Mar 2026 17:44:53 +0000

There's a phrase Anthropic keeps repeating when they talk about Dispatch, their new agentic desktop product: finished work.

📖 Read the full version with charts and embedded sources on AgentConn →

Not a briefing. Not a summary to review. Not a draft that needs your edits. Finished work. The kind that was blocking you, then wasn't, because Claude handled it while you were in a meeting, on a flight, or — and this is the paradigm they're selling — just texting from your phone.

That framing distinction matters more than the feature list. It's the difference between AI as a productivity multiplier (still in your workflow) and AI as a workflow executor (operating autonomously while you're away). Dispatch is betting on the latter.

After analyzing Nate B Jones's detailed walkthrough, cross-referencing Anthropic's own framing, and looking at how it compares to the broader computer-use agent landscape, here's what you actually need to know about Anthropic Dispatch in 2026.

What Is Anthropic Dispatch?

Dispatch is Anthropic's consumer-facing agentic product that pairs two capabilities into a single coherent workflow:

Desktop Computer Use — Claude takes over your Mac (or PC), sees your screen, opens applications, navigates UIs, fills forms, and executes multi-step tasks exactly as a human would — without any API integrations required
Remote Task Delegation — You text Claude from your phone (or any remote interface), hand it a task, and walk away. Claude works on your actual desktop environment until it's done

The key word in that second point is actual desktop. Dispatch isn't running in a cloud VM. It's operating in your local desktop environment, with access to every app you have installed, every file on your disk, every tool in your workflow — no API credentials, no webhooks, no Zapier flows required.

💡 The paradigm shift in one line: Before Dispatch, AI delivered work that still landed on your desk. Dispatch delivers work that never reaches your desk at all.

The Nate B Jones Analysis: Three Tools, One Paradigm

Nate B Jones covered Dispatch as part of a broader announcement — "Anthropic Just Gave You 3 Tools That Work While You're Gone" — and his framing is the sharpest take on what Anthropic is actually building.

His core insight: Anthropic shipped Dispatch as a pair with Computer Use updates not as separate products but as a single thesis. The thesis is asynchronous work delegation. You are not using Claude in a chat session while you watch it work. You are handing it a task and returning to find it done.

Nate walks through several real-world demonstrations:

Technical debt clearing — Claude navigating a codebase across multiple files, identifying deprecated patterns, making fixes, running tests, and committing changes — all while the developer is in a standup
Document workflows — Claude pulling data from various sources, populating a spreadsheet, formatting a report, and exporting a final version — without touching a single API
Research and synthesis — Claude browsing multiple sites, collecting information, and producing a structured output in whatever tool you use (Notion, Google Docs, Word — doesn't matter, it just opens them)

The "no API" angle deserves special emphasis. The biggest friction in enterprise automation has always been integrations. Your tools don't talk to each other natively. Dispatch sidesteps this entirely by operating at the UI layer — the one interface every app exposes equally.

How Dispatch Differs From Basic Computer Use

Anthropic has had Computer Use in API beta since late 2024. So what's new?

The API-level Computer Use product is powerful but requires significant setup: Docker containers, custom tool-calling code, screenshot pipelines, managing the agent loop yourself. It's a developer primitive — incredibly flexible, but not something you hand to a non-technical user.

Dispatch is the consumer layer built on top of that primitive:

Dimension	Computer Use API	Anthropic Dispatch
Setup	Docker container, API keys, custom code	Native desktop app install
Interface	Programmatic tool calls	Natural language via text/chat
Trigger	Your own orchestration code	Text from phone / any device
Environment	Sandboxed VM (recommended)	Your actual local desktop
Target user	Developers	Knowledge workers, professionals
Task model	Synchronous (you watch it work)	Asynchronous (you return to find it done)

⚠️ Important distinction: Dispatch runs on your local machine, not a cloud desktop. This means it has access to everything you have access to. That's powerful — and requires careful thought about permissions and scope.

Real Use Cases: What "Finished Work" Actually Looks Like

✅ Where Dispatch Shines

Cross-application data workflows: "Pull the Q1 pipeline numbers from Salesforce, update the board deck in Google Slides, and send me the updated file." Three apps, zero APIs. This previously required either developer-built integrations or a virtual assistant who could sit at your computer.

Research and competitive intelligence: "Browse these 8 competitor pricing pages, extract their tier structures, and put it in a comparison table in our Notion database." The human version of this takes 2 hours. Dispatch does it while you sleep.

Email and communication triage: Actually navigate to your email client, find threads, produce staged replies — not just "draft a response given this context."

Code maintenance tasks: "Find all deprecated fetchUser API calls, replace them with the new pattern, run the tests, push to a branch." The kind of grunt work that burns half a day for no creative value.

Form-heavy administrative work: Government portals, insurance claims, benefits enrollment. The UI layer that no API will ever reach.

⚠️ Where Dispatch Struggles

Long-horizon tasks with ambiguity — Multiple branch points increase error compounding probability
Security-sensitive workflows — Financial transactions need explicit human confirmation steps
Novel interfaces and dynamic UIs — Non-standard UI patterns can confuse the vision-based agent
Real-time data requirements — Tasks requiring very current information have natural limitations

The "Finished Work" Paradigm

Most AI productivity tools still operate in the work-lands-on-your-desk model: the AI produces something — a draft, a summary, a code snippet — and you pick it up from there.

Dispatch is a serious attempt at the work-gets-off-your-desk model. The completed task is the output. Not a draft. Not a starting point. A closed loop.

The trust is earned through:

Verification checkpoints — Pause before irreversible actions
Audit trails — A log of exactly what the agent did, when, and what the outcomes were
Scope boundaries — You define what apps and data the agent can access

🎯 The real productivity unlock: Dispatch isn't valuable when you're watching it work. It's valuable when you stop watching — when you hand it a task, go do something else, and return to a closed loop. The product's value scales with your willingness to delegate.

Social Signal: What The Community Is Saying

The developer community's reaction to Anthropic's recent agentic product push has been significant. Claude Code's explosive growth — which shipped alongside Dispatch — has generated a wave of prosumer adoption that's hard to ignore.

https://twitter.com/bcherny

When Chase AI posted 5 Claude Code tutorials in 48 hours — website cloning in 15 minutes, Obsidian integration, animated site generation — that wasn't developer content. That was prosumer builders discovering a new default for "build anything fast."

Dispatch is that same energy applied to knowledge work.

Matthew Berman's S-Tier Context

Matthew Berman's recent model tier list placed Claude at S-tier — "unbelievable model, good at everything, love every interaction" — while ChatGPT landed at A ("all the features, not best in class at anything").

That underlying model quality matters enormously for computer-use agents. The agent loop is only as good as the model's reasoning when it hits an unexpected state. Claude's strength at nuanced reasoning and instruction-following is precisely what makes a computer-use product reliable enough for the "walk away and trust it" use case. A mediocre model doing computer use is a liability; an S-tier model doing computer use is a different product category.

Dispatch vs. The Alternatives

vs. Open Interpreter: Open-source, model-agnostic, fully local. Dispatch wins on polish and the mobile delegation UX. Open Interpreter wins on cost, privacy, and flexibility. Different markets.

vs. OpenAI Operator: Cloud browser only — can't access your local files or desktop applications. For browser-only tasks, viable. For anything requiring your actual desktop environment, Dispatch wins on scope.

vs. Perplexity Computer: Interesting model-routing architecture, but also cloud/browser-bound. Same limitation as Operator for local desktop work.

📊 Competitive summary: Dispatch is the only major player combining (1) local desktop access, (2) mobile delegation interface, and (3) consumer-grade polish. The "text from phone, work gets done on desktop" UX is genuinely novel in the category.

The Bottom Line

Anthropic Dispatch is the most serious attempt yet to move AI assistance from "work that lands on your desk" to "work that never reaches your desk."

The limitations are real. Start with low-stakes tasks, verify outcomes carefully, and gradually expand the scope of what you delegate as you build confidence in the agent's judgment.

But the direction is clear. The question was never whether this kind of autonomous desktop agent would arrive. The question was who would be the first to get the consumer experience right.

Anthropic just made a strong argument that the answer is them.

Sources: Nate B Jones — Anthropic Just Gave You 3 Tools That Work While You're Gone · Matthew Berman — Best Models Tier List · Chase AI — I STOLE a $100K Website in 15 Minutes with Claude Code

🔗 Full article on AgentConn → | Follow @ComputeLeapAI