What Is Claude Code? The Complete History of Anthropic's Agentic Coding Tool (2026)

If you have heard the phrase "agentic coding" at all in the last year, you have heard about Claude Code. It started as one engineer's side project during his first month at Anthropic in September 2024, launched quietly as a limited research preview in February 2025, and — per public reporting — was past a $1 billion annualized run rate by November 2025, roughly six months after general availability. That is one of the fastest revenue ramps in software history, and it changed how software teams work.

This is the complete story: what Claude Code actually is, where it came from, how the agent loop works under the hood, the leak that showed everyone the internals, the ecosystem of skills and subagents and workflows that grew around it, and the honest answer to the question most explainers skip — should you, personally, be using it?

TL;DR: Claude Code is Anthropic's agentic coding tool - an AI agent that reads your codebase, edits files and runs commands until a task is done. Launched February 24, 2025; past $1B annualized revenue by November 2025, per public reporting. It now runs Claude Opus 5.5 and Sonnet 5.5. Taskade Genesis applies the same pattern to apps, agents, and automations.

🤖 What Is Claude Code, Exactly?

Claude Code is an AI agent that works on your computer, not a chatbot that talks about your code. You give it a task in plain English — "fix this failing test," "migrate this component," "find out why signups dropped" — and it searches your files, makes edits, runs commands, reads the output, and keeps going until the job is done or it needs your approval. It lives in the terminal first, with IDE extensions, a desktop app, and a web version layered on top.

The distinction that matters on day one:

That second column is the subject of this post. And the fastest way to understand why it exploded is the principle its creator names as the most important one in product:

"Latent demand I think is the single most important principle in product. You can never get people to do something they do not yet do. The thing you can do is you can find the intent that they have and then you can steer it." — Boris Cherny, creator of Claude Code

Developers were already pasting code into claude.ai and wiring the API into their editors. Claude Code didn't invent a behavior — it removed the friction from one that already existed.

Where can you run Claude Code?

Claude Code runs on five surfaces that share one engine, so your CLAUDE.md files, settings, and MCP servers follow you between them. Anthropic's Claude Code overview lists the terminal, IDE extensions, a desktop app, and the web. Most surfaces need a Claude subscription or an Anthropic Console account.

How do you install Claude Code?

The recommended install is one command, then claude inside a project folder. These are the commands from Anthropic's docs, verified on September 29, 2026.

Native installs update themselves in the background. Homebrew and WinGet installs do not, so run brew upgrade claude-code or winget upgrade Anthropic.ClaudeCode yourself. Then start your first session:

cd your-project
claude

Claude Code asks you to log in on first use. If you set the ANTHROPIC_API_KEY environment variable, it skips the login and asks you to approve the key instead.

First session, step by step

Install        curl -fsSL https://claude.ai/install.sh | bash
Verify         claude --version      (prints a version number)
Open project   cd your-project
Start          claude                (log in on first use)
Ask            "write tests for the auth module, run them, and fix any failures"
Review         approve edits and commands, read the diff

The fifth step is the example prompt Anthropic itself uses in its overview. For a deeper walkthrough of skills, see best Claude Code skills, tested.

⚡ How Claude Code Actually Works

Under the hood, Claude Code is a loop: gather context → act → verify → repeat. The model decides which tool to use next — read a file, search the codebase, run a command — looks at the result, and chooses the next step. Everything else (skills, hooks, subagents, workflows) is scaffolding around that loop.

Three design decisions defined it, all confirmed by the team on the record:

1. Search like an engineer, not like a search engine. Early Claude Code used vector embeddings to find relevant code — the standard "RAG" approach. The team ripped that out in favor of agentic search: the model greps and navigates files the way a human would. Accuracy stayed the same, and an entire class of problems (stale indexes, re-indexing, a bigger security surface) disappeared.

2. Give the model everything, mediated by permissions. As the team puts it: Claude Code has access to everything an engineer does at the terminal — "everything you can do, Claude Code can do." What keeps that safe is a permission system that asks before risky actions, with rules you can tighten or loosen per project.

3. "Don't build for the model of today. Build for the model 6 months from now." Cherny's design maxim explains the product's strange minimalism. The team once deleted about 2,000 tokens of instructions from the system prompt because a newer model no longer needed them — in their words, "models will eat your scaffolding."

The vocabulary you'll meet everywhere, in one table:

🥚 The Origin Story: A Weekend Project and a Research Tool Called Clyde

Claude Code began in September 2024 as a side project by Anthropic engineer Boris Cherny. By his own account, the idea was almost naive: "let me just see if I can build a thing where you can give Claude access to your terminal and your file system and it can just help you code." The first version, he says, "was terrible." But it showed signs of life, internal demand snowballed, and a team formed around it.

According to the team's own telling, there was a precursor: a heavyweight internal Python research project the engineers describe under the name Clyde. Cherny joined Anthropic, hand-wrote a pull request, and was told to try the internal tool instead — which completed the task in one shot. The revelation that stuck, in the team's words: "the model just wants to use tools." Given nothing but a shell, the model started writing AppleScript to automate the computer. The terminal interface wasn't a philosophical statement — it was simply the fastest way to prototype without building a UI.

Cherny's own path to that side project reads like preparation in hindsight: roughly seven years at Meta (the two-year facebook.com rewrite, a tech-lead stint on Facebook Groups, then infrastructure and developer-experience work at Instagram — the last stretch of it from Nara, Japan, which is the section below), the O'Reilly Programming TypeScript book, and a habit of building developer tools nobody asked for. Anthropic's flat structure did the rest — everyone from engineers to PMs carries the same "Member of Technical Staff" title, a convention borrowed from Bell Labs, and the Claude Code team recruits generalists ("our product managers code, our data scientists code").

The features you now think of as the product arrived bottom-up, built by individual engineers scratching their own itches: todo lists (Sid), hooks (Dixon), plugins (Daisy), bash mode (Cherny himself). Hooks exist because engineers wanted a Slack ping when Claude was waiting for permission while they got coffee. Internally, the feedback channel gets a post roughly every five minutes — Anthropic calls the practice "ant-fooding."

"When I created Claude Code as a side project back in September 2024, I had no idea it would grow to what it is today... This technology is alien and magical, and I feel lucky to experience it so intimately." — Boris Cherny

🗾 The Japan Years: Where the Expertise Actually Came From

Before Anthropic, Cherny spent his last stretch at Meta living in Nara, Japan — roughly sixteen hours ahead of his California colleagues — and the time-zone gap took his meeting load to nearly zero. In his first two weeks there he landed more code than in his entire previous year at Menlo Park, and he went on to rank in the top 1% of Instagram engineers by code output. This is the part of the story almost nobody tells.

The setup matters. Before Japan he was tech lead for Facebook Groups in Menlo Park — one of the largest product surfaces at the company, and a job made almost entirely of meetings, scoping docs, spreadsheets, executive reviews, and a permanent inbound of chat and email. His own summary of it is one line long:

"You know what I wasn't doing a lot of? Coding."

Then he moved. Nara "feels like rural Japan," in his words, and the constraint that followed was not one he designed. Colleagues in California and New York logged off as his morning began. Not fewer meetings — nearly none. His team did the logical thing and pulled him off time-sensitive projects. He dropped out of the important chats, the planning docs, the executive reviews.

"This stung, at first — I was used to being included in meetings, and learning about new information before others did. These are the things that made me feel important! I didn't want to give them up. But I had no choice." — Boris Cherny, "Learning to work (very) remotely," December 2023

He tried to engineer his way around it first. He considered mentoring engineers out of Meta's Singapore office; it didn't work, because product work at that distance from headquarters was too hard. What worked was going back to the keyboard.

"I'm an engineer, and this made me happy — I missed coding!"

At Instagram he shipped Instagram Maps and QR codes and cleaned up the Python codebase. And while doing it he kept noticing the other problems — what slowed engineers down, what made a large codebase unreliable, what internal tooling was missing. He moved into infrastructure and Developer Experience.

Here is the correction that most retellings miss, and it's his own:

"This shift was not something I did intentionally."

It took about six months to become his main work. He had done infrastructure before, but only as 20%-time projects. Nobody handed him a mandate — the absence of organizational drag simply revealed where his attention went when it wasn't being spent. That drift is the entire technical foundation Claude Code was later built on: large codebases, developer tooling, and the specific texture of what makes engineers slow.

Two honesty notes, because the tidy version of this story is wrong in two specific ways.

First, the top-1% number comes with a framing he supplied himself and everyone drops: "I had essentially turned myself into an intern, coding 80% of the day." He also gave the reason senior engineers ship less code than he suddenly was, and it isn't talent — the organization takes their time. Remove the org, and a senior engineer becomes an extremely well-informed intern.

Second, he did not build Claude Code in Japan. He left Meta in August 2024 and built the prototype at Anthropic the following month. The constraint shaped the engineer; the tool was built somewhere else, later, for the reasons in the origin story above. Any version of this story where rural Japan produces the product is a causal leap the evidence doesn't support.

What is Boris Cherny's async work playbook?

Four practices carried him through two years of near-zero synchronous contact, and all four transfer to any distributed team. He published them in December 2023, well before any of the Claude Code coverage, which is exactly why they're worth stealing: they were written as survival mechanics, not as thought leadership.

The management half of it he calls "leading from behind" — and he's candid that it came with real delegation anxiety. If you want the same operating model in practice, our guides on sync vs async communication, how to reduce meetings, deep work for remote teams, and managing remote teams cover the mechanics. The durable-surface half of point 2 is exactly what a workspace is for: a written broadcast in a shared project is searchable in a year; the meeting it replaced is not.

There is a straight line from that playbook to what agents are for. Async work forced Cherny to write down context that used to live in his head and in hallway conversations — the same act, at a smaller scale, as writing a CLAUDE.md. The teams who adapt fastest to agents tend to be the ones who already wrote things down.

📜 The Complete Timeline: 2024–2026

From side project to a billion-dollar product line in under two years. Every date below is drawn from Anthropic announcements, official docs, or named press reporting.

The July 2025 detour deserves its own sentence, because it was the AI talent war in miniature: Anysphere hired away the two people most identified with Claude Code — Cherny on the engineering side, Wu on product — and roughly two weeks later both were back at Anthropic. Few episodes say more about how strategically important agentic coding had become by mid-2025.

For the wider company story — the founding, the funding, the model generations — see our full Anthropic and Claude history.

Claude Code's own release timeline

Claude Code has shipped alongside a model release at almost every major step. Anthropic's Claude 3.7 Sonnet announcement introduced it as a limited research preview, and the Claude 4 announcement made it generally available.

🎚️ Why There Were Two Model Step-Changes, Not One

The most common error in Claude Code retellings is compressing 2025 into a single inflection point. Cherny names two. The first was Claude Opus 4 and Sonnet 4 in May 2025, the month Claude Code reached general availability. The second was Claude Opus 4.5 in November 2025 — and it was the November model, not the May one, that took him to 100% agent-written code.

The receipt for the second one is public and precise. On December 27, 2025, Cherny posted his own thirty-day numbers:

"In the last thirty days, I landed 259 PRs — 497 commits, 40k lines added, 38k lines removed. Every single line was written by Claude Code + Opus 4.5. Claude consistently runs for minutes, hours, and days at a time (using Stop hooks)."

— Boris Cherny, December 27, 2025

Two details in that post get skipped and shouldn't. "Every single line was written by Claude Code + Opus 4.5" names the model, which is why the November step-change is load-bearing rather than trivia. And "runs for minutes, hours, and days at a time (using Stop hooks)" is the mechanism: hooks — the feature an engineer built so he'd get a Slack ping while getting coffee — are what let a run continue unattended. The harness and the model moved together, which is the whole argument of the agent harness explainer.

One more correction worth making in the same breath: the December post's own conclusion is far milder than the line it usually gets quoted with. Its actual claim is "Increasingly, code is not the bottleneck." The famous soundbite came later, and it comes with its own section below.

💥 The April 2025 Leak: Everyone Got to Read the Source

Two months after launch, Anthropic accidentally published Claude Code's source. An npm release shipped with source maps included, exposing roughly 390,000 lines of TypeScript across ~2,000 files — and because hundreds of other packages already depended on the release, npm policy blocked unpublishing it.

Everything "known" from the leak is community analysis rather than official documentation, so treat the details accordingly. But the reported architecture became required reading for anyone building agents:

• One loop, not a framework. The internals community analysts described were a single agent loop with tools — no exotic multi-agent choreography. A Reddit post claiming to have reverse-engineered a secret "multi-agent framework" from the leak was debunked; the durable insight was the opposite: the simple thing works.
• Layered permissions. Analysts described a multi-level permission cascade (policy → flags → local → project → user) mediating everything the agent does.
• Context is managed obsessively. CLAUDE.md is reportedly re-inserted as context changes rather than pasted once; multiple compaction strategies keep long sessions alive.

The leak's real legacy was a mental-model shift the industry now takes for granted: the harness matters as much as the model. The same model, wrapped in different scaffolding, produces meaningfully different outcomes — which is why every serious AI lab and tool company now competes on the loop, the permissions, the memory, and the context management, not just the weights. (Our agent harness explainer goes deep on that idea.)

🧠 The AI Layer: CLAUDE.md, Skills, Hooks, and Subagents

By 2026, Anthropic's own guidance treats the "AI layer" as a first-class part of a codebase — alongside the code and the tests. That layer is the accumulated instructions, rules, and workflows that make an agent effective in your project rather than generically smart.

A modern codebase, 2026:
├── src/                    ← the code
├── tests/                  ← the tests
└── the AI layer
├── CLAUDE.md           ← project rules, always loaded
├── src/api/CLAUDE.md   ← area-specific rules, loaded in place
├── .claude/skills/     ← repeatable workflows, loaded on demand
├── .claude/hooks/      ← guardrails that fire on events
└── MCP servers         ← connections to outside tools

Two mechanisms make the layer economical:

Progressive disclosure. A skill costs the agent only its name and description — tens of tokens — until the task makes it relevant, at which point the full instructions load. You can attach dozens of workflows without drowning the context window. The same philosophy shows up in Anthropic's Tool Search Tool, which loads tool definitions on demand and cut context usage from 77,000 tokens to 8,700 in Anthropic's published example.

Self-improvement hooks. Anthropic's large-codebase guidance describes a pattern where a hook fires when a session ends, spawns a fresh headless agent to review what happened, and proposes CLAUDE.md updates while the context is still warm. Correct the agent once, and the correction compounds.

Does the AI layer actually work? The best independent evidence so far: an ETH Zurich study (arXiv 2602.11988, February 2026) tested agent/model pairs with and without context files and found developer-written files helped, while auto-generated ones were a small net negative — they added bloat without adding judgment. Write your CLAUDE.md by hand.

And subagents earn their keep for one non-obvious reason the team states plainly: uncorrelated context windows produce better results. Two agents that can't see each other's reasoning don't share each other's blind spots — the same reason you ask two people to review a document independently. For the concept in depth, see our Claude skills explainer and the tested skills roundup.

🕸️ Dynamic Workflows: The Orchestration Era (May 2026)

On May 28, 2026, Claude Code stopped being one agent. Dynamic workflows, shipped in v2.1.154 alongside Opus 4.8, let Claude write a real orchestration script — actual JavaScript with loops and conditionals — that fans out subagents, collects their results, and controls the flow deterministically: up to 16 agents running concurrently, 1,000 per run.

The official docs give the crisp reason this exists: "A workflow script holds the loop, the branching, and the intermediate results itself, so Claude's context holds only the final answer." One long-running agent past a few hundred thousand tokens develops predictable failure modes — the community shorthand is agent laziness (claims all fifteen tasks are done, did seven), self-preference (grades its own homework kindly), and goal drift. Orchestration sidesteps all three by making the structure external to any single context window.

The flagship demonstration arrived within weeks: Bun creator Jarred Sumner used workflow-orchestrated Claude Code to port the Bun runtime from Zig to Rust — roughly 750,000 lines of Rust in eleven days from first commit to merge, with 99.8% of the existing test suite passing, per Anthropic's own write-up. The same write-up notes the port was not yet in production despite the passing tests, which is the honest caveat to carry with the headline. Reasonable people can argue about what the port proves; nobody argues it was possible for one person before.

The cost honesty that belongs next to the excitement: Anthropic's own engineering blog reports agent systems use roughly 4x the tokens of chat, and multi-agent systems roughly 15x. Orchestration is a power tool, priced like one.

🔁 The Next Rung: Loops (Agents Prompting Agents)

The step beyond orchestration is loops — and by 2026 Boris Cherny said writing them had become his actual job. If an orchestration script is one agent coordinating others within a task, a loop is a higher abstraction: agents that run on a schedule, read signals (user feedback, GitHub issues, Slack), and decide what to build next — prompting other agents to do it, with no human prompting each cycle.

Cherny frames it as the newest rung on a very old ladder:

"If source code is like a statement in programming, then the agent run writing the code is like a function, and loops are like a higher-order function. Loops are as big a step from agents as agents were from source code."

— Boris Cherny, creator of Claude Code

By his own account, he'd stopped prompting Claude directly: "I have loops that are running. They're the ones prompting Claude and figuring out what to do. My job is to write loops." It's candidly early — only a fraction of what the loops propose is worth shipping today — but the trajectory mirrors the one agents themselves traveled. Anthropic productized the idea as features like scheduled tasks and cloud routines, and the same loop layer is what Taskade's automations give non-coders out of the box.

The other 2026 expansion runs sideways, not up. Claude Cowork — "Claude Code for non-engineers" — is built on the same Claude Agent SDK, bringing the agent loop to office work (files, connectors, browser use) for people who never open a terminal. Together they point at the same future Cherny keeps describing: the old distinctions between engineer, PM, and designer "melting into one builder," and what he calls "the golden age of the generalist."

🆕 What Changed in Claude Code, July to September 2026

Between July and late September 2026, Claude Code moved from Opus 4.8 to Opus 5.5 and Sonnet 5.5, and gained design, plugin-testing, and migration tools. This section is dated September 29, 2026. Every item comes from Anthropic's Claude Code What's new digest, the Claude Code changelog, Anthropic's Opus 5.5 announcement, or the models overview.

Models: Opus 5.5 and Sonnet 5.5

Opus 5.5 costs less than Opus 5. Anthropic prices it at $4 input and $20 output per million tokens, which is 20% below Opus 5, and cache reads at $0.20 per million. Anthropic says it generates output more than 30% faster than Opus 5. Both 5.5 models have a 1M-token context window, and Sonnet 5.5 is priced at $2 input and $10 output. For the full lineup, see Claude models explained and the Claude release dates timeline.

The API default effort for Opus 5.5 is medium, per Anthropic's models overview. Claude Code lets you change effort per session, and the new maxEffortLevel setting caps it.

Limits: raised on September 22, not removed

Anthropic raised the five-hour usage limits on Pro, Max, Team, and seat-based Enterprise plans on September 22, 2026. Subscribers also got a rate limit reset they can save and use whenever they choose. This is an increase, not the removal of limits, and weekly limits remain.

Safeguards: cyber tasks can fall back to an older model

Opus 5.5 re-routes most cybersecurity tasks to Opus 4.8. Anthropic's announcement says most cybersecurity tasks are re-routed to Opus 4.8, and that its verification program is expanding with tiers. Expect a fallback on security-heavy prompts, and read Anthropic's announcement for the current scope.

Design, migration, and plugins

• /design (research preview, August 17, 2026). Claude drafts several editable UI artboards, you pick one, and Claude implements it as code in the same session.
• /claude-api migrate. Anthropic's Opus 5.5 migration guide says to run /claude-api migrate in Claude Code to invoke the bundled Claude API skill. The skill swaps model IDs, applies breaking parameter changes, and produces a checklist to verify. It asks you to confirm the scope before it edits files.
• Plugins and skills. claude plugin eval (September 2026) scores a plugin against test cases and a no-plugin baseline. /skill-doctor shows what each skill costs in context. See best Claude Code skills, tested.

The agent loop, step by step

Claude Code, September 2026
  prompt ──► model (Opus 5.5 / Sonnet 5.5) ──► tool call
▲                                             │
│                                             ▼
your review  ◄── result ◄── files · shell · MCP (for example Taskade)

📈 Claude Code by the Numbers (Mid-2026)

The growth curve is the story. Figures below are from Anthropic statements or named reporting; treat third-party estimates as estimates.

Cherny's most striking internal claim — that Anthropic tripled in headcount while productivity per engineer still grew about 70% because of Claude Code — is a company self-measurement, but it matches his own public receipt. The verbatim December 27, 2025 numbers, which are the most citable figure in this entire story:

Note the shape of it: 38k lines removed against 40k added. That is not a code-generation firehose — it is roughly break-even net, which is what maintenance on a real codebase actually looks like. The interesting number isn't volume, it's that the ratio held while a human stopped typing.

💼 Beyond Coding: The Claude Code Economy

The most surprising 2026 development is who uses Claude Code now. An agent loop that can run a long time, touch files, and reach the internet turns out to be a general-purpose work engine, and a creator economy has grown around treating it as one:

• Business operating systems. Course creator Nate (who says he built a $100K/month automation agency) teaches an "AIOS" — a portable brain of context files and skills. His system is deliberately tool-agnostic: the durable asset is the markdown, not the harness; he claims porting an entire setup from Claude Code to Codex took two minutes. His best line doubles as a philosophy: "Treat AI as a mentor, not a vending machine."
• SEO at scale. One practitioner attributes ~50,000 monthly clicks to a Claude-Code-driven publishing pipeline — blog posts for topical authority, service pages for money keywords. (Claims are the creator's own.)
• Faceless YouTube. A channel reportedly hit 130K subscribers and 14M views in about a month with a Claude Code + image-generation pipeline; the revenue estimates ($60K+/month) come from VidIQ, not audited books.
• A YC-endorsed software factory. Y Combinator president & CEO Garry Tan open-sourced gstack, a 28-command sprint process for Claude Code (Think → Plan → Build → Review → Test → Ship → Reflect) with a doctrine worth stealing: "Boil the Lake" — when AI makes completeness nearly free, always do the complete thing.
• Second brains. Andrej Karpathy popularized a no-vector-database pattern: an Obsidian vault of markdown plus Claude Code as the librarian — plain files, grep, and an index note instead of embeddings. Thousands now run it.

Anthropic institutionalized the trend by renaming the Claude Code SDK to the Claude Agent SDK — per the team, thousands of companies build non-coding agents (health assistants, financial analysts, legal research, email) on the same loop. It is the clearest signal of where this goes: the coding tool was the beachhead; the agent loop is the product. Our execution layer thesis explores that shift.

⚔️ Claude Code in the 2026 Landscape

Nobody picks an agentic coding tool in a vacuum anymore. The honest mid-2026 map:

Benchmarks won't settle it for you: by mid-2026, frontier models sit in a tight band on SWE-bench Verified, so harness fit — how the tool matches your workflow — matters more than leaderboard deltas. The deep dives: Claude Code vs Codex, Claude Code vs Cursor vs Taskade Genesis, Claude Code vs OpenClaw, Claude Code vs n8n, and the full alternatives roundup.

Claude Code vs Cursor: which one fits your workflow?

Claude Code is agent-first and Cursor is editor-first, and most teams that compare them end up using both. With Claude Code you describe the goal, the agent drives, and you review the result. With Cursor you stay in an AI-native editor and approve suggestions and edits inline. Claude Code now also runs inside VS Code and Cursor through its extension, so the choice is about where you want control, not which one can open your files.

For the long version, read Claude Code vs Cursor vs Taskade Genesis, Taskade Genesis vs Cursor, and the Anysphere and Cursor history. To wire either tool to your workspace, see connect Claude and Cursor to Taskade over MCP.

Which plan do you actually need?

Claude Code has no free tier. Anthropic's ladder, at 2026 prices: Claude Pro $20/month (entry, with usage windows heavy users outgrow), Claude Max $100/month (5x limits), Claude Max $200/month (20x limits), or metered API pricing - where a typical 200K-token run costs roughly $0.20–$2.00, and heavy orchestration costs multiples of that. On September 22, 2026, Anthropic raised the five-hour limits on Pro, Max, Team, and seat-based Enterprise plans (raised, not removed; weekly limits remain). Practitioner rule of thumb: Pro to evaluate, Max when it becomes your daily driver, API when you're building on the Agent SDK. (These are Anthropic's plans - Taskade's own pricing is separate and appears further down.)

Anthropic's pricing page states that "Claude Code is included in all paid plans." The free Claude plan does not include it.

🛑 When NOT to Use Claude Code

Claude Code is the wrong tool in four specific situations, and all four are about review and cost rather than capability. Agentic runs use roughly 4x the tokens of a chat and 15x for multi-agent work, per Anthropic's own engineering blog, and every output still needs a human who can judge it. Claude Code is the wrong tool when:

• You don't read code. The product assumes you can judge a diff. "Vibe-coding" past that assumption is how people ship things they can't maintain — the failure mode isn't the tool, it's the unreviewable output.
• You need predictable costs. Agentic runs are token-hungry by design, and budget-capped teams feel it fast.
• The task is a repeatable business workflow, not a coding project. "Every Monday, summarize support tickets and post to Slack" doesn't need a terminal agent wired to a codebase — it needs an automation with a trigger, and maintaining a script + server + API keys is real overhead for a non-engineer.
• The output must be right the first time, unreviewed. Non-deterministic generation plus no review gate is a production incident with extra steps.

🧭 Is Coding "Largely Solved"? The Honest Version

"Coding is largely solved" is Cherny's most-quoted 2026 line, and he has publicly narrowed it twice. It is not from the December 2025 post — that post's actual claim is the much milder "Increasingly, code is not the bottleneck." The soundbite comes from his 2026 appearances, and within months he had bounded it himself, on stage and in print.

The first audit was live. At Sequoia AI Ascent in May 2026, he stopped and polled the room: who here writes 100% of their code with an agent? Who's somewhere in between? Then he read the hands and revised on the spot:

"So, like, 50% solved."

The second narrowing came in Platformer, and it's the more useful one because it names the actual boundary:

"Coding is solved for the kinds of coding that I do."

That is not a walk-back to score points off — it's the correct epistemics, and it's why this section exists. A frontier engineer working in a mature TypeScript codebase, with a test suite, a review gate, and clear specs, is operating in close to the best possible conditions for an agent. Regulated systems, legacy code with no tests, hardware-adjacent work, and anything where the specification is the hard part all sit further from "solved."

The claim that survives all four framings is the interesting one, and it's not about coding at all: if writing the code stops being the bottleneck, then knowing what to build becomes the whole job. Which leads directly to the argument of his that matters most to everyone reading this who is not an engineer.

Who should actually write accounting software?

Cherny's answer is not "an engineer." It's the single most consequential thing he has said for non-developers, and it inverts thirty years of software's default assumption about who gets to build:

"Let's say you're writing accounting software. The best person to write accounting software, I think maybe even today, is not an engineer, it's a really good accountant. Because they know the domain really well and coding is the easy part. It's knowing the domain that's the hard part."

— Boris Cherny

Read that as a claim about where the scarce skill sits. For most business software, the hard part was never the syntax — it was knowing which edge cases matter, which fields are load-bearing, what "done" means in that industry, and which shortcuts quietly destroy trust with a client. That knowledge lives in the operator, not in the toolchain. Until recently, the operator had to hand it across a translation layer to someone who could type — and translation is where requirements go to die.

The clinic manager knows the intake workflow. The freight coordinator knows which shipment states actually exist. The accountant knows why that reconciliation rule has an exception in March. What changed in 2026 is that the translation layer became optional. See vibe coding for non-developers, what vibe coding actually is, and the no-code builder landscape for how far that has already gone — and AI agents for solopreneurs for what a one-person operation can now run alone.

🔌 Claude Code + Taskade: Connect Your Workspace

Claude Code is an MCP client, and Taskade runs a hosted MCP server, so Claude Code can read and work with your Taskade workspace from the terminal. The server lives at https://www.taskade.com/mcp, uses an OAuth login, and is available on every paid Taskade plan (Beta). This direction is the useful one for developers: Claude Code does the coding, and Taskade holds the plans, tasks, agents, and automations around it. Setup details are in the Taskade MCP server guide and the Learn article on the MCP server.

Anthropic's MCP docs give the syntax for adding a remote HTTP server, and OAuth runs through the /mcp command:

claude mcp add --transport http taskade https://www.taskade.com/mcp

Then type /mcp inside Claude Code and follow the browser steps to log in. Your tokens are stored and refreshed automatically, per Anthropic's MCP docs.

Taskade itself builds on the same agent pattern. Taskade EVE builds and edits Taskade Genesis apps from a prompt, custom AI agents keep persistent memory, and 100+ integrations let automations act on the result. One clarification: Claude models do not run on Taskade credits. Claude runs inside Taskade only on your own Anthropic key, through the Anthropic Claude automation connector or Enterprise BYOK, as described in the BYOK guide. Connecting Claude Code to Taskade over MCP needs no Claude key on the Taskade side.

🧑‍🚀 If You Don't Write Code: The Same Power, a Different Door

Here's the convergence that makes 2026 interesting: the agent pattern Claude Code proved out is not inherently about code. An agent that reads and writes files, remembers your conventions, delegates to helpers, and executes multi-step work — that pattern applies to any structured workspace.

That's precisely what Taskade Genesis does for people who will never open a terminal: describe what you need in plain English, and it builds a live app backed by your workspace, with AI agents (a large built-in toolset, persistent memory, custom slash commands), automations across 100+ bidirectional integrations, and databases, running on managed infrastructure with role-based access instead of a server you harden yourself. Taskade EVE is the agent that does the building, and Claude Code can also connect to your Taskade workspace through the Taskade MCP server; frontier models from top AI labs sit behind it, with Auto as the default. Claude models do not run on Taskade credits; Claude runs in Taskade only through your own Anthropic key, such as the Anthropic Claude automation connector. The same loop; the door is a prompt instead of a shell. Where Claude Code turns a developer into a team, Taskade Genesis turns a description into a working system, and 150,000+ apps in, the pattern holds. Browse what people ship with it, explore the Community Gallery, or start free at taskade.com/create.

This is the accountant argument made operational. The domain expert describes the workflow in the language of their own business — customers, jobs, invoices, who owes me money — and gets a working, deployed app back, without ever crossing a translation layer. Memory (your projects) feeds Intelligence (your agents), Intelligence triggers Execution (your automations), and Execution writes back to Memory. Paid plans start at Pro $10/month billed annually ($120/year), with Business at $25/month billed annually ($300/year) when a team needs custom domains and shared workspaces.

The two tools don't compete so much as bracket the same future from opposite ends: software that builds and runs itself, supervised by the person who needed it. Memory feeds intelligence, intelligence triggers execution, execution becomes memory. ▲ ■ ●

💬 Frequently Asked Questions

📚 Further Reading

• Anthropic & Claude: The Complete History — the company behind the tool
• Claude Models Explained · Claude Release Dates · Taskade MCP Server
• What Is OpenAI Codex? The Complete History — the rival lineage
• Best Claude Code Skills (Tested) and Claude Skills, Explained
• Claude Code vs OpenClaw · Claude Code vs n8n · Claude Code vs Cursor vs Taskade Genesis
• What Is an Agent Harness? · Agentic Workflows Explained · The Execution Layer Thesis
• What Is Agentic Engineering? — Karpathy's framing and the discipline it became
• Best Claude Code Alternatives · Free Claude Code Alternative
• The async playbook, in practice: Sync vs Async Communication · How to Reduce Meetings · Deep Work for Remote Teams · Managing Remote Teams
• If the domain expert is the builder: Vibe Coding for Non-Developers · What Is Vibe Coding? · Best No-Code Builders · AI Agents for Solopreneurs · Context Engineering
• Claude Code and Taskade together: Taskade MCP Server · MCP Connectors for Taskade Genesis · Connect Claude and Cursor over MCP · Taskade Genesis vs Cursor · Anysphere and Cursor History · Best Claude Cowork Alternatives · What Are AI Agents?
• Build without a terminal: Taskade Genesis · AI Apps · AI Agents · Automations · Community Gallery · Pricing