Kite's 500K Developers Wouldn't Pay: A 2022 Farewell Letter Revisited in 2026

In November 2022, an AI coding assistant with roughly 500,000 monthly active users announced it was shutting down. Founder Adam Smith's farewell letter was posted to Hacker News, where it racked up over 1,000 points and 528 comments. One line from it became DevClass's headline: "Our 500,000 developers wouldn't pay for it." The company was Kite. Less than three weeks later, on December 7, 2022, GitHub announced Copilot for Business at $19 per person per month—a price aimed at companies, not at individual developers.

In the farewell letter, Kite gave two reasons for its failure. Four years later, one has been overturned, and the other has turned into a pricing guide. The original is no longer on kite.com, but copies pasted in the HN comments and contemporaneous media reports preserve the full text. All quotes below come from those copies.

What Kite Actually Did

Kite was founded in San Francisco in 2014 by Adam Smith, who had previously founded the Outlook plugin Xobni. The company raised "tens of millions of dollars in venture capital," took from 2014 to 2019 to ship a marketable product, and led with local execution—selling points were low latency, security, and privacy.

The product was code completion. On May 12, 2020, Kite launched Kite Pro at $19.90 per month, or $16.60 per month when billed annually; at launch, the paid version only supported Python. Smith claimed Kite Pro users saw "an average efficiency gain of 18%." According to GIGAZINE's summary, Kite reached 500,000 monthly active users with near-zero marketing spend. For comparison, GitHub Copilot became generally available on June 21, 2022, priced at $10 per month or $100 per year—by which point Kite had already been charging for AI completion for two years.

Reason One: The Model Didn't Understand Code Structure—This One Has Expired

The first reason in the farewell letter was: "We failed to achieve our vision of AI-assisted programming because we were more than 10 years ahead of the market—that is, the technology wasn't ready." Specifically, Kite "failed to reach the 10x improvement needed to break through, because the state of the art in machine learning on code today isn't good enough." The core problem: "The biggest issue was that state-of-the-art models don't understand the structure of code, such as non-local context."

Smith also estimated that "building a production-grade tool that can reliably synthesize code might require more than $100 million," and said of Copilot at the time that "as of the end of 2022, Copilot still has plenty of problems holding it back from broad adoption."

Read that passage today, and the "not ready yet" part no longer holds. Claude Code's documentation describes how it can "read your codebase, edit files, and run commands"; given a feature request, it "writes code across multiple files and verifies it runs," and will "stage changes, write commit messages, create branches, and open PRs." Codex CLI lets you "inspect code, make changes, run commands, and automate repetitive work in the terminal without leaving it."

My understanding of how non-local context got solved is this: the model didn't learn to hold the entire repository in its head while you type. Instead, the agent actively goes and fetches context—opening the file that defines the type, searching for callers, running tests and reading the failure output. A completion engine has only a few hundred milliseconds and the context around the cursor; an agent can spend minutes in a shell. Smith was also right that it would take big money: the models that cross this line come from large labs training general-purpose models, not from a company building an editor plugin.

Non-local context refers to program information that affects the correctness of the current code but isn't near the cursor. When a completion model only sees the lines before the cursor, it can't know the exact type of a function parameter, where a variable is defined, or what return structure a caller expects—so it easily produces code that is syntactically correct but semantically wrong. Traditional completion relies on editor caches and simple indexes, and struggles to feed cross-file, cross-module dependencies to the model in real time. Agents get around this bottleneck because they don't need full visibility within a few hundred milliseconds; instead, they turn "fetching context" into an executable action: read the definition, search references, check test failure output, then decide the next edit.

Reason Two: "Individual Developers Don't Pay for Tools"—Overturned by Reality, but the Second Half Became a Pricing Guide

The second reason is the most quoted: "We failed to build a business model because the product wasn't monetized, and it took us too long to realize that." The line that became the headline was: "Our 500,000 developers wouldn't pay for it. Our diagnosis was that individual developers don't pay for tools. Their managers might, but engineering managers only want to pay for discrete new capabilities—that is, making developers write code 18% faster wasn't compelling enough."

That passage contains two judgments, and their fates today are completely different.

The first judgment—individual developers don't pay—no longer holds as a rule. Anthropic's Claude Pro is $20 per month and includes Claude Code; the Max plans at $100 or $200 per month also include Claude Code. GitHub's individual Copilot plans range from Pro at $10 per month to Pro+ at $39 and Max at $100. According to iTWire, Microsoft reported more than 4.7 million paid Copilot subscribers, with Pro+ for individual developers growing 77% quarter over quarter.

The second judgment—managers pay for discrete new capabilities—has stood the test of time. Look at the other half of the same price sheets: Copilot Business is $19 per assigned seat per month, Copilot Enterprise is $39; Claude's Team plan is $100 per month per premium seat when billed annually, and Enterprise is $20 per seat plus usage-based billing. These are all bills sent to companies. However, no party's public pricing page or the data cited in this article specifies how much of paid seats are purchased by developers themselves versus by employers, so nobody outside knows that split. What has really changed is that now both pillars exist.

Seat-based pricing is a common way to charge for enterprise software: billing by actual number of users or assigned accounts, rather than by number of calls or compute usage. For buyers, seat pricing makes budgets predictable and auditable; for vendors, it ties revenue growth directly to the expansion of customer organizations. Copilot Business at $19 per seat and Enterprise at $39 per seat both follow this model. Its implicit premise is that the tool is embedded in team workflows and managers can account for input and output per head. By contrast, individual subscriptions charge a flat monthly fee, the decision-maker is the developer, and growth depends more on word of mouth and self-serve conversion than on a procurement process.

The Unit of Work Has Changed: From Keystrokes to Tasks

Put Smith's two sentences side by side, and the lesson lies in the gap between them. "Writing code 18% faster" is an acceleration of what developers already do; "here's a branch with a fix, tests pass, please review" is a discrete deliverable. Managers can only accept an 18% speedup on faith, but they can count a branch with passing tests.

Kite sold keystrokes; the tools people pay for sell tasks. Kite itself was moving in this direction near the end: the README of its open-source repository lists experiments from late 2020 to early 2021 on PR title generation and code search, and GIGAZINE reported that the team considered pivoting to code search before shutting down.

Once an agent takes over a task, that task has a nameable shape: a task, a branch, a directory. Create a branch with git worktree, call claude "fix the flaky login test" in a separate directory, inspect what the task changed with git diff main...task/fix-login, and merge back from the main checkout—every step is ordinary git. When completion is no longer the bottleneck, the work shifts here: you're no longer waiting for the model to finish a line; you're figuring out which agent is stuck waiting on you, reading what three agents each changed, and deciding what's safe to merge.

git worktree lets you check out multiple working directories from the same repository at once, each on a different branch, without copying the whole repository or repeatedly switching branches. In agent workflows, it's well suited to isolating parallel tasks: create a separate worktree and branch for each task, let different agents make changes and run tests in their own, without interfering with each other; the main checkout stays clean for review and merging. git diff main...task/fix-login uses three-dot comparison to show all changes the task branch introduced since the common ancestor, making it easy to judge which changes are safe to merge. These are all ordinary git commands that don't depend on a proprietary platform, so task-level deliverables are naturally reviewable and reversible.

What Still Holds in the Farewell Letter

Kite open-sourced most of its code under the BSD-3-Clause license, and the repository is still there: a Go parser for Python, type inference, a GPT-2-based completion model, and years of data pipelines. If you want to see how much engineering went into a problem that a lab later attacked from a different direction, this is great reading material.

What I'll keep is the bar it set. Kite said it needed a 10x improvement to break through, and 18% wouldn't convince buyers. That test still applies to any agent tool today, including my own: does it just make the same work a little faster, or does it hand you a finished task you can review, merge, or throw away?

FAQ

Why did Kite fail? By the founder's own account, there were two reasons: the models didn't understand non-local context in code, and the product couldn't monetize—500,000 developers wouldn't pay. The former was circumvented by agent architectures, while the latter was partly overturned by the reality of individual paid subscriptions.

Does "nobody pays for AI coding tools" from 2022 still hold? No. Claude Pro, Claude Max, and the various tiers of individual Copilot subscriptions all target individual developers, and Copilot has more than 4.7 million paid subscribers. What continues to hold is the other half: managers are willing to pay for countable new capabilities.

What's the difference between code completion and coding agents? Completion accelerates what you're doing at the cursor, usually with only a few hundred milliseconds and local context; an agent actively retrieves context, edits across files, runs tests, and delivers a reviewable branch or PR. Buyers can count the output of the latter, but have a hard time verifying the percentage of the former.

Can I still look at Kite's code? Yes. The kiteco-public repository is preserved under the BSD-3-Clause license and includes the parser, type inference, and early completion models.