Forem: Max Quimby

Silicon Valley CEO vs Tang Dynasty: AI-Native Org Design

Max Quimby — Sun, 05 Apr 2026 06:10:45 +0000

In February 2026, Block CEO Jack Dorsey cut 4,000 employees — roughly 40% of his workforce. Six weeks later, he and Sequoia Capital partner Roelof Botha published "From Hierarchy to Intelligence", a 5,000-word manifesto arguing that AI should replace the entire middle management layer of modern companies.

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

The essay landed like a grenade. Bloomberg, Fortune, and CoinDesk covered it within hours. The Sequoia co-publication gave it institutional weight that most corporate restructuring memos never get.

But here's the thing nobody in Silicon Valley seems to have noticed: the Tang Dynasty solved the same problem in 618 AD — and their solution lasted 1,300 years because it included a critical component that Dorsey's model is missing.

The Problem Both Are Solving: Human Bandwidth Has a Hard Limit

Before we compare architectures, we need to understand the shared constraint that makes governance necessary in the first place.

The Roman legions discovered it empirically: one person can effectively coordinate 3-8 others. They called it "span of control." Your brain can track what 8 direct reports are doing, what problems they face, what resources they need. It cannot track 50.

So the Romans built hierarchy. Eight soldiers per contubernium, led by a squad leader. Squad leaders reporting to centurions. Centurions to tribunes. The pattern stacked upward because human cognitive bandwidth forced it to.

ℹ️ The key insight: hierarchy didn't emerge because humans love bureaucracy. It emerged because human brains can't process enough information to coordinate at scale without it.

Every organizational innovation since then — from medieval guilds to the East India Company to General Motors — has been a variation on the same theme: how do you coordinate large groups of people when no single brain can hold the full picture?

This is the problem Dorsey is solving with AI. And it's the same problem Emperor Gaozu of Tang solved with three departments and six ministries in 618 AD.

Dorsey's Three-Layer Model: Replace the Router, Keep the Edges

In "From Hierarchy to Intelligence", Dorsey and Botha argue that the core function of middle management is information routing. Managers exist to relay information up and down the chain. If AI can handle the routing, you don't need the routers. Dorsey proposes replacing the entire management chain with three AI layers.

Layer 1: Company World Model — "What's happening inside"

This replaces the manager's function of knowing team status and relaying it upward. Instead of scheduling syncs and writing status reports, an AI system continuously aggregates internal data — code commits, decisions, workflows, performance metrics — to maintain a live picture of company operations.

The prerequisite is that all work must produce digital artifacts. Decisions, discussions, designs, code — everything captured in text. As Dorsey noted, remote-first companies have a natural advantage here because their communication is already text-based.

Layer 2: Customer World Model — "What customers need"

This replaces the traditional PM function of conducting user research, writing PRDs, and deciding the roadmap.

Block has a unique advantage: they own both Cash App (consumer) and Square (merchant), seeing every transaction from both sides. Money is the most honest signal — people lie in surveys but not when spending.

The system observes user behavior and automatically identifies demand signals. Instead of quarterly product cycles, the Customer World Model generates the to-do list in real time.

Layer 3: Intelligence Layer — "What to do now"

This is the decision engine that connects layers 1 and 2. It knows what capabilities the company has (from the Company World Model), what customers need (from the Customer World Model), and automatically composes solutions.

When a combination fails, the failure signal feeds back into the roadmap automatically. Traditional organizations rely on PMs and executives for this judgment call. In Dorsey's model, customer reality generates the priorities directly.

The three layers form an information pipeline:

Layer	Question	Function
Company World Model	"What do we have?"	Capability + Status
Customer World Model	"What do they want?"	Demand + Signals
Intelligence Layer	"What should we do now?"	Decision + Execution

Together, they replace the entire CEO-to-Manager information processing chain.

ℹ️ From the community: The AI Investor (@The_AI_Investor) summarized Block's restructuring: three roles — ICs who build capabilities, DRIs who own specific problems on 90-day cycles, and player-coaches who combine building with developing people. The Hacker News discussion "Ask HN: When will managers be replaced by AI?" drew 83 comments, with one user noting their company already fired a third of its managers.

The Tang Dynasty Solution: 1,300 Years Ahead of Silicon Valley

While the West was still running simple command hierarchies, the Tang Dynasty (618-907 AD) designed a governance system of remarkable sophistication. The Three Departments and Six Ministries (三省六部) separated planning, review, and execution into independent branches — a separation of powers that Western political philosophy wouldn't formalize until Montesquieu, 1,100 years later.

Three design principles made this system exceptional:

First, separation of planning and execution. The department that drafts policy (中书省) is not the department that executes it (尚书省). This prevents the "I both decide and do" conflict that plagues flat organizations.

Second, mandatory independent review. Every policy must pass through 门下省 before execution. This isn't advisory — it's constitutional. If 门下省 vetoes a policy, it goes back to 中书省 for revision. Even the Emperor couldn't bypass this process without causing a political crisis. This was essentially code review + PR approval, 1,300 years before GitHub.

Third, specialized parallel execution. The six ministries operate independently within their domains. HR doesn't need to coordinate with Engineering for routine operations. This is the same principle as microservices — bounded contexts with clear interfaces.

This architecture outlasted every Western organizational form of its era. It survived because information flowed through checkpoints, not just through chains of command.

The Mapping: Where Dorsey and the Tang Dynasty Align

When you place the two models side by side, the structural parallel is striking:

Dorsey's AI Layers	Tang Dynasty	Function
Company World Model	中书省 (Planning Dept)	Internal state awareness, drafting proposals
??? (Missing)	门下省 (Review Dept)	Independent review and veto power
Customer World Model	户部 + 早朝官 (Treasury + Intelligence)	External signals, market data
Intelligence Layer	尚书省 + 六部 (Execution + Ministries)	Decision execution, capability composition

The same governance pattern was independently invented twice — once to govern an empire of 50 million people, once to govern an AI-native company. Both recognized that scale requires separating planning from execution, and that raw information must be processed through structured layers before becoming action.

But there's a critical difference.

The Missing 门下省: Dorsey's Biggest Blind Spot

The Tang system had something Dorsey's model lacks: an independent review layer.

门下省 existed for one purpose — to catch bad plans before they reached execution. If 中书省 drafted a policy that was contradictory, poorly thought out, or harmful, 门下省 could kill it. No exceptions.

In Dorsey's three-layer model, information flows from Layer 1 to Layer 2 to Layer 3 with no independent checkpoint. Who audits the Company World Model for accuracy? What happens if the Customer World Model misreads a signal? What if the Intelligence Layer composes a capability combination that looks optimal by the numbers but creates a terrible user experience?

⚠️ This is exactly the problem that killed previous flat organization experiments. Zappos' Holacracy, Valve's no-manager structure, Spotify's Squad model — they all collapsed because removing hierarchy also removed the implicit quality checks that managers provided. The hidden power structures just went underground.

The Tang Dynasty solved this explicitly. 门下省 wasn't optional — it was structural. Conflicts between departments were resolved at the review stage, before execution, not after. This is why the system lasted 1,300 years while Silicon Valley organizational experiments typically last 3-5 years before quiet reversion to hierarchy.

The implication for AI-native organizations is clear: if you're building an AI system that plans and executes, you need a separate AI system that reviews and can veto. The reviewer cannot be part of the planning or execution chain. It must be structurally independent.

The Open Source Response: Edict and Multi-Agent Governance

The developer community has already noticed this gap. An open-source project called Edict (6.9K+ stars on GitHub) explicitly implements the Three Departments and Six Ministries architecture as a multi-agent orchestration system.

Edict runs 9 specialized AI agents, with the critical innovation being a dedicated review agent modeled after 门下省. This agent can reject outputs from planning agents and force them to redo work — a structural veto power that mainstream multi-agent frameworks like AutoGen and CrewAI lack.

The contrast is instructive:

Framework	Approach	Review Mechanism
AutoGen / CrewAI	Agents "chat freely"	None — agents self-organize
Dorsey's Block Model	Three AI layers	None — information flows one-way
Edict (三省六部)	Structured pipeline	Dedicated review agent with veto

Most current multi-agent frameworks let agents self-organize through conversation. This works for simple tasks but breaks down at scale — agents hallucinate, enter loops, drift off-topic, and there's no structural mechanism to catch these failures. Edict's approach treats review not as a plugin but as architecture. As we explored in our look at the rise of AI agents, the agent landscape is evolving fast — and governance is becoming the key differentiator.

The broader conversation is exploding across platforms. On Substack, Ken Huang asks "What is an Agentic AI Native Organization?" — arguing that once AI becomes agentic, the org chart becomes an execution graph. GAI Insights cuts through the buzzwords: the real metric isn't whether you're "AI-native" or "AI-first" — it's revenue per employee.

What This Means for Practitioners

Whether you're restructuring a company or building a multi-agent system, the convergence of these ideas points to three actionable principles:

1. Make All Work Machine-Readable

Dorsey's Company World Model requires digital artifacts for everything. This is the foundation — without it, nothing else works.

Practically: put an AI scribe in every meeting. Move key decisions from hallway conversations to documented channels. Make Slack, docs, and code your single source of truth. Remote-first companies already have this. Office-first companies need to build it deliberately.

2. Separate Your "Information Routing" from Your "Real Judgment"

List everything your managers do weekly. Categorize each task:

Function	% of Time	AI Replaceable?
Status syncs, info relay	~40%	Yes — fully automatable
Priority setting, resource allocation	~20%	Mostly — AI can optimize
Quality review, risk assessment	~10%	Partially — AI assists, humans decide
Conflict resolution, politics	~10%	No — requires power and trust
People development, coaching	~10%	No — requires human connection
Culture, values, morale	~10%	No — requires authenticity

AI can replace roughly 60% of what middle managers do today. The remaining 40% — judgment, people, culture — stays human. This doesn't mean you need fewer managers. It means management becomes a behavior (something senior ICs do part-time) rather than a full-time role. For a deeper look at how these AI tools actually work in practice, see our guide to what AI agents are and how they work.

3. Add a "门下省" to Your AI Systems

Whether you're designing an AI-native organization or building a multi-agent pipeline, ask: who reviews the AI's output before it reaches the customer?

This reviewer must be:

Independent — not part of the planning or execution chain
Empowered — able to reject and force revision, not just flag concerns
Structural — built into the architecture, not bolted on as an afterthought

The Tang Dynasty figured this out 1,300 years ago. The most sophisticated bureaucracy in human history survived because review wasn't optional — it was constitutional.

The Meta-Insight: Governance Is Eternal

Put Dorsey's AI-native organization and the Tang Dynasty's Three Departments together, and you get a closed narrative loop:

Human hierarchy is too slow → Dorsey proposes replacing it with AI information routing
But AI agents also need coordination → multi-agent frameworks emerge
Multi-agent frameworks without governance fail → the Tang Dynasty's review architecture resurfaces
Therefore: hierarchy doesn't disappear, only its medium changes

Whether the coordinating entities are carbon-based (humans) or silicon-based (AI agents), the fundamental governance challenges remain the same: how do you plan, review, execute, validate, and balance at scale?

Dorsey's contribution is asking the right question: if AI can handle information routing, do we still need the current organizational structure? The Tang Dynasty's contribution is the answer the question implies: you still need structure — just make sure it includes independent review.

The answer for 2026 probably won't look exactly like Dorsey's vision, and it won't be a perfect replica of the Tang Dynasty system. But the core insight from their collision is worth remembering:

💡 Governance problems are eternal. The medium changes — from humans to AI to whatever comes next. But the pattern holds: plan, review, execute, validate, balance. This has been true for 1,300 years. It will be true for the next 1,300.

Originally published at ComputeLeap

Gemma 4 for AI Agents: Google's Best Open Model Review 2026

Max Quimby — Sat, 04 Apr 2026 17:57:26 +0000

Google just quietly dropped one of the best arguments for switching your agent stack away from proprietary APIs. On April 2, 2026, Gemma 4 landed with four variants, an Apache 2.0 license, and benchmark numbers that should genuinely unsettle the teams at DeepSeek and Meta.

The headline: Gemma 4's 31B dense model is currently ranked #3 on the open model global leaderboard (Arena AI ELO ~1452). It beats DeepSeek V3.2 Thinking — at a fraction of the parameter count. For developers building agents, it also earned a perfect score on Tool Call 15, the standard agentic function-calling benchmark.

The Four Models: What You're Actually Choosing Between

Gemma 4 ships as four distinct variants:

Variant	Architecture	Active Params	Context	Best For
E2B	Dense	2B	128K	Mobile, edge, audio input
E4B	Dense	4B	128K	Mobile, edge, audio input
26B-A4B	MoE (26B total, 4B active)	4B	256K	Local inference, agents
31B	Dense	31B	256K	Maximum capability

The 26B MoE model runs at 34 tokens/second on an M4 Mac Mini with 16GB RAM and 162 tokens/second on an RTX 4090.

Why Apache 2.0 Is The Actual Story

Everyone's debating benchmarks. The license is the story.

Previous Gemma releases shipped under Google's custom model terms. Apache 2.0 means commercial use, modification, redistribution — no strings attached. Google finally stopped trying to have it both ways.

"Gemma 4 is FINALLY Apache 2.0 aka real-open-source-licensed." — @ClementDelangue, Hugging Face CEO

Agent Benchmarks: The Numbers That Matter

Tool Call 15: Perfect score (15/15)
AIME 2026 math: 20.8% → 89.2% (post-thinking)
LiveCodeBench: 29.1% → 80.0% (post-thinking)
Context window: 256K tokens (26B/31B variants)

The Tool Call 15 perfect score is significant. This benchmark tests function call accuracy, parameter formatting, and multi-step tool chaining — exactly what production agents require.

Video: Matthew Berman's Full Breakdown

Local Deployment: Day-Zero Ecosystem

Within 24 hours of release:

NVIDIA published NVFP4-quantized 31B — 4x smaller at frontier-level performance
MLX support was available day-zero
llama.cpp 2.7x faster on RTX GPUs
Hugging Face Inference Endpoints supporting one-click deployment

# Start the 26B MoE model locally
llama-server -hf ggml-org/gemma-4-26b-a4b-it-GGUF:Q4_K_M

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

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

How to Download Gemma 4 Locally

Gemma 4 vs. The Competition

vs. DeepSeek V3.2: Gemma 4 31B edges it out on Arena AI at a smaller parameter count. Better licensing clarity. DeepSeek has edge cases with export controls some enterprise teams prefer to avoid.

vs. Qwen 3.5: Qwen 3.5 has strong coding benchmarks but the flagship 3.6-Plus went hosted-only. Gemma 4 is fully open and locally deployable.

vs. Llama 4: Similar tier, Llama 4 has broader ecosystem, Gemma 4 has cleaner tool calling benchmarks. Benchmark both for your use case.

vs. GPT-4o/Claude Sonnet 4: Frontier APIs still lead on very complex reasoning and 1M+ context. For most production agent workloads — RAG, function calling, structured output — Gemma 4 is competitive enough that local inference economics win.

What's Missing

Context window: 256K is large but not frontier-large (no 1M+)
Audio input only in edge models (E2B/E4B), not 26B/31B
Relatively new — give the community a few weeks for production hardening

Deployment Checklist

Match variant to hardware: 26B MoE for 16-24GB RAM; 31B for 32GB+
Use NVIDIA NVFP4 quantization for RTX GPU deployments
Use llama.cpp GGUF Q4_K_M for CPU/Apple Silicon
Test Tool Call 15 with your actual tool schemas before deploying
Start with 26B MoE for cost/quality tradeoff

Gemma 4 is the most significant open model release from Google since the Gemini architecture pivot. The combination of Apache 2.0 licensing, perfect tool call benchmark scores, 256K context, and day-zero ecosystem support makes it the strongest single argument for running open weights in production agent stacks as of April 2026.

Full article with additional detail at AgentConn

Gemma 4 is available on Hugging Face, Kaggle, and Google AI Studio.

Run Claude Code for 99% Less With Ollama and OpenRouter

Max Quimby — Sat, 04 Apr 2026 17:49:11 +0000

At 12 PM Pacific today, Anthropic flipped the switch. Claude Max subscriptions — the $100/month and $200/month plans that gave you unlimited Opus 4.6 — no longer work with third-party tools like OpenClaw, Cline, or any harness outside Anthropic's own apps. If you were running Claude Code through a third-party client on your Max subscription, it stopped working this afternoon.

The announcement came from Boris Cherny, Claude Code's creator, and was confirmed across multiple channels. The reaction was immediate: two separate tutorial videos dropped within hours, the "free Claude Code" community mobilized, and Hugging Face's CEO started posting CLI commands to run open-source models as direct replacements.

⚠️ The April 4 cutoff is real. Starting today at 12 PM PT, Claude Max subscriptions no longer cover usage on third-party tools. You need an API key from here on — which means per-token billing instead of a flat monthly fee. For heavy users, this could mean going from $100/month to $500-2,000/month overnight.

But here's the thing Claude Code's harness doesn't care which model powers it. The agent framework — the file reading, code writing, git integration, terminal execution — is separate from the language model underneath. Swap the model, keep the workflow. That's exactly what we're going to do.

This guide covers two approaches: Ollama (completely free, runs on your machine) and OpenRouter (pennies per request, cloud-hosted). Both work today. Both are tested. And both will save you 90-99% compared to API pricing.

What Actually Changed (And Why It Matters)

Let's be precise about what happened. Anthropic didn't shut down Claude Code. They didn't change the API. What they did was decouple the Max subscription from third-party tool access.

Previously, your $100/month Max plan gave you unlimited Claude Opus 4.6 usage — and that included any tool that could authenticate through your Anthropic account. Power users on OpenClaw were getting hundreds of dollars worth of API calls for a flat fee. From Anthropic's perspective, these users were "freeloading at scale," as one analyst put it.

Now, third-party tools require an API key with per-token billing:

Claude Opus 4.6: $15 per million input tokens, $75 per million output tokens
Claude Sonnet 4.5: $3 per million input tokens, $15 per million output tokens

For a typical coding session — 50,000 input tokens and 10,000 output tokens — that's roughly $1.50 per session with Opus or $0.30 with Sonnet. Do 10 sessions a day and you're looking at $450/month with Opus. Heavy users report $1,000+ monthly bills on the API.

📊 The cost math that triggered the migration: Light users (5 sessions/day) go from $100/mo on Max to ~$225/mo on API Opus — or $0 with Ollama and ~$5/mo on OpenRouter. Heavy users (20+/day) face ~$900+/mo on API vs. still $0 locally. Power users who coded all day on Max? Looking at $2,000+/mo on the API.

Usage Level	Max Plan (Before)	API Opus (After)	Ollama (Local)	OpenRouter
Light (5 sessions/day)	$100/mo	~$225/mo	$0	~$5/mo
Medium (10 sessions/day)	$100/mo	~$450/mo	$0	~$10/mo
Heavy (20+ sessions/day)	$200/mo	~$900+/mo	$0	~$25/mo
Power user (all day)	$200/mo	~$2,000+/mo	$0	~$50/mo

Ollama costs = electricity only. OpenRouter costs assume using capable free-tier or low-cost models like Qwen3.5, Gemma 4, or DeepSeek.

The community response has been swift. Nate Herk published two tutorials the same day. Clément Delangue (Hugging Face CEO) posted literal CLI commands to run Gemma 4 locally as a Claude replacement. The "free Claude Code" tutorial is becoming its own genre.

Approach 1: Ollama — Free, Local, Unlimited

Ollama is an open-source tool that runs large language models on your own hardware. No API keys. No billing. No data leaving your machine. You download a model, point Claude Code at it, and you're coding.

Prerequisites

macOS, Linux, or Windows (with WSL2)
16GB+ RAM (32GB recommended for larger models)
~20GB free disk space per model
A reasonably modern CPU — Apple Silicon (M1+) or a recent AMD/Intel with AVX2

Step 1: Install Ollama

# macOS
brew install ollama

# Linux
curl -fsSL https://ollama.com/install.sh | sh

# Windows (via WSL2)
curl -fsSL https://ollama.com/install.sh | sh

Start the Ollama server:

ollama serve

This runs in the background and exposes a local API at http://localhost:11434.

Step 2: Pull a Coding Model

Not all models are equal for code generation. Here's what works well:

# Best overall coding model for local use (35B, needs 24GB+ RAM)
ollama pull qwen3.5:35b

# Great MoE option — only 4B active params, runs on 16GB (26B total)
ollama pull gemma4:26b

# Smaller but capable (needs 8GB+ RAM)
ollama pull qwen3.5:14b

# Budget option — runs on almost anything (needs 4GB+ RAM)
ollama pull qwen3.5:7b

⚡ Which model should you pick? If you have 32GB+ RAM (like a MacBook Pro M2/M3/M4), go with qwen3.5:35b — it's the closest to Claude Sonnet quality for code. If you're on 16GB, gemma4:26b is excellent thanks to its MoE architecture (only 4B parameters are active at any time, so it runs fast despite the large model size). On 8GB, stick to qwen3.5:14b.

Step 3: Configure Claude Code to Use Ollama

Claude Code reads its model configuration from environment variables. Set these before launching:

# Point Claude Code at your local Ollama instance
export ANTHROPIC_BASE_URL="http://localhost:11434/v1"
export ANTHROPIC_API_KEY="ollama"  # Ollama doesn't need a real key
export CLAUDE_CODE_MODEL="qwen3.5:35b"  # Match the model you pulled

# Now launch Claude Code normally
claude

To make this permanent, add those exports to your ~/.zshrc or ~/.bashrc:

echo 'export ANTHROPIC_BASE_URL="http://localhost:11434/v1"' >> ~/.zshrc
echo 'export ANTHROPIC_API_KEY="ollama"' >> ~/.zshrc
echo 'export CLAUDE_CODE_MODEL="qwen3.5:35b"' >> ~/.zshrc
source ~/.zshrc

Step 4: Verify It Works

claude

You should see Claude Code launch normally. Try a simple prompt:

Create a Python function that calculates the Fibonacci 
sequence using dynamic programming. Include type hints 
and docstring.

If it generates code, reads files, and executes commands — you're running Claude Code for free.

Ollama Troubleshooting

Problem	Solution
"Connection refused"	Run `ollama serve` in a separate terminal
Slow generation	Try a smaller model or check RAM usage with `htop`
Model crashes mid-generation	You're out of RAM — switch to a smaller model
"Model not found"	Run `ollama list` to see installed models; name must match exactly

Approach 2: OpenRouter — Cloud Models, Pennies Per Request

If your machine can't run local models (or you want frontier-quality output without the $15/MTok Opus price), OpenRouter is the play. It's a unified API that routes to 100+ models from different providers — many of them free or near-free.

Step 1: Get an OpenRouter API Key

Go to openrouter.ai
Create an account (free)
Generate an API key from your dashboard
Add credits — $5 will last weeks for most users

Step 2: Configure Claude Code

# Point Claude Code at OpenRouter
export ANTHROPIC_BASE_URL="https://openrouter.ai/api/v1"
export ANTHROPIC_API_KEY="sk-or-v1-your-key-here"

# Pick your model — here are the best options:
export CLAUDE_CODE_MODEL="qwen/qwen3.5-coder-next"    # Strong coder, ~$0.50/MTok
# export CLAUDE_CODE_MODEL="google/gemma-4-31b"        # Free tier available
# export CLAUDE_CODE_MODEL="deepseek/deepseek-v3.2"    # Great reasoning, ~$0.27/MTok
# export CLAUDE_CODE_MODEL="anthropic/claude-sonnet-4.5" # Full Claude, but cheaper than direct API

claude

Step 3: Pick the Right Model for Your Task

OpenRouter's strength is model selection. Match the model to the work:

Task	Recommended Model	Cost/MTok (Input)	Why
Quick edits, scripting	`qwen/qwen3.5:14b`	Free	Fast, good enough for simple tasks
Feature development	`qwen/qwen3.5-coder-next`	~$0.50	Optimized for code, strong reasoning
Complex architecture	`deepseek/deepseek-v3.2`	~$0.27	Excellent reasoning at low cost
Production-critical code	`anthropic/claude-sonnet-4.5`	$3.00	When quality matters most
Budget unlimited	`google/gemma-4-31b`	Free tier	Apache 2.0, solid all-around

💡 The hybrid strategy: Use a cheap model (Qwen 3.5 or Gemma 4) for routine coding, file exploration, and test writing. Switch to Sonnet 4.5 via OpenRouter only when you need frontier reasoning — complex refactors, subtle bugs, architecture decisions. This drops your average cost by 80-90% compared to running Opus for everything.

The Tradeoffs: What You Gain and What You Lose

Let's be honest about what you're giving up. This isn't a free lunch — it's a different lunch at a different price point.

What You Keep ✅

The Claude Code harness — file reading, code writing, git operations, shell commands, the entire agent workflow
Multi-file editing — Claude Code's ability to work across your whole project
CLAUDE.md and hooks — your project context and automation rules still work
Terminal UI — same interface, same commands, same muscle memory

What You Lose ❌

With Ollama (local models):

Raw intelligence drops. Qwen 3.5 35B is ~85% of Claude Sonnet on coding benchmarks. For complex multi-step reasoning, you'll notice the gap. The hidden cost of cheaper reasoning models is real — they make more subtle mistakes.
Context window shrinks. Most local models max out at 32K-128K tokens vs. Claude's 1M. For large codebases, this means Claude Code can't hold your entire project in context simultaneously.
Speed varies wildly. On an M4 Max, Qwen 3.5 35B runs at ~25 tok/s. On an older Intel MacBook, you might get 3-5 tok/s. Opus via API gives you ~80 tok/s consistently.
Your machine is busy. Running a 35B model uses 20-30GB of RAM and significant CPU/GPU. Don't expect to be running other heavy workloads simultaneously.

With OpenRouter:

Latency is higher. Requests route through OpenRouter's proxy, adding 100-500ms per request compared to direct API calls.
Free models have rate limits. The free tier on models like Gemma 4 restricts requests per minute. Heavy sessions will hit these.
Model availability isn't guaranteed. If a provider goes down, that model goes down with it. OpenRouter's routing helps, but it's not immune.

The Pro Setup: Switching Models on the Fly

Power users don't pick one approach. They set up aliases to switch between models depending on the task:

# Add to ~/.zshrc or ~/.bashrc

# Free local model — for exploration, simple tasks
alias claude-local='ANTHROPIC_BASE_URL="http://localhost:11434/v1" ANTHROPIC_API_KEY="ollama" CLAUDE_CODE_MODEL="qwen3.5:35b" claude'

# Cheap cloud model — for feature development
alias claude-cheap='ANTHROPIC_BASE_URL="https://openrouter.ai/api/v1" ANTHROPIC_API_KEY="sk-or-v1-YOUR-KEY" CLAUDE_CODE_MODEL="qwen/qwen3.5-coder-next" claude'

# Full Claude Sonnet — when quality matters
alias claude-sonnet='ANTHROPIC_BASE_URL="https://openrouter.ai/api/v1" ANTHROPIC_API_KEY="sk-or-v1-YOUR-KEY" CLAUDE_CODE_MODEL="anthropic/claude-sonnet-4.5" claude'

# Direct Anthropic API — when you need Opus
alias claude-opus='ANTHROPIC_API_KEY="sk-ant-YOUR-KEY" CLAUDE_CODE_MODEL="claude-opus-4-6" claude'

Now you can type claude-local for free coding sessions, claude-cheap for daily work, and claude-opus only when you're tackling something that genuinely needs frontier intelligence.

# Exploring a new codebase? Free.
claude-local

# Building a feature? Pennies.
claude-cheap

# Debugging a race condition in your distributed system? Worth paying for.
claude-opus

What the Community Is Building

The "free Claude Code" movement isn't just about cost savings — it's about resilience. When your workflow depends on a single provider's pricing decisions, you're one announcement away from a 10x cost increase. Today proved that.

This is a pattern we've seen before. Every time a closed provider tightens access, the open-source alternative gets a growth spike. The difference now is that open-source coding models are genuinely competitive — Gemma 4's 31B dense model ranked #3 on Arena AI's text leaderboard, and Qwen 3.5's coding variants are approaching Sonnet-level quality on SWE-bench.

📊 The open-source quality gap is closing fast: Qwen 3.6-Plus hits SWE-bench 78.8 (vs. Claude Opus 4.5's 80.9). Gemma 4 31B ranks #3 open model globally at ELO ~1452. DeepSeek V3.2 delivers strong reasoning at $0.27/MTok. Six months ago, the best open model scored ~65 on SWE-bench. The gap went from 25% to 3%.

Which Approach Should You Pick?

Pick Ollama if:

You have 16GB+ RAM (32GB ideal)
Privacy matters — your code never leaves your machine
You do mostly routine coding (CRUD, scripts, tests, frontend)
You want zero ongoing costs
You're comfortable with ~85% of Claude's quality for most tasks

Pick OpenRouter if:

Your machine can't run large models (8GB laptop, Chromebook)
You want access to multiple model providers through one API
You need near-frontier quality but can't justify Opus pricing
You want the flexibility to switch models per task
You're OK with $5-25/month instead of $0

Pick both if:

You're a power user who wants the alias-switching setup above
Use local models for exploration and simple tasks (free)
Route to cloud models for complex work (cheap)
Only pay full Anthropic API rates for genuinely hard problems (rare)

The Bigger Picture

Today's announcement is a business decision, not a technical one. Anthropic is profitable on API usage and losing money on Max subscribers who use third-party tools heavily. The subsidy had to end.

But the unintended consequence is acceleration. Every developer who sets up Ollama today is one more developer who knows how to run local models. Every OpenRouter account created this week is one more developer who understands model routing and cost optimization. The lock-in weakens with every migration guide that gets published.

Claude Code as a harness is still excellent — arguably the best agent framework available. But the model powering it? That's now a commodity. Compare the options, pick the right tool for each task, and don't pay $15/MTok for work that a $0 local model handles just fine.

The 99% cost reduction is real. The tradeoffs are real too. Now you know both sides.

Running Claude Code with alternative models and want to share your setup? We're collecting community configurations — reach out via our GitHub.

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