CodeRabbit Founder: Where Do Software Engineers Go in the AI Era?

When Code Generation Becomes a Commodity, Why Is Code Review Worth Hundreds of Billions?

At a time when AI coding tools are exploding, a counterintuitive judgment is being validated: the larger the code generation market, the higher the value of code review. CodeRabbit co-founder Harjot proposed on the Neon Show podcast that code review will capture 25-30% of the value share of the code generation market—if the latter is a trillion-dollar market, then the former is a $250 billion opportunity.

Behind this judgment is a grander narrative: all work will become a programming problem. Harjot believes companies will run as code, and any work that can be transformed into a programming problem can achieve 10x speed progress. From slide creation to marketing campaigns, from design to operations, the execution method AI agents are best at is writing code.

From Weekend Project to $150 Million Valuation: CodeRabbit's Rise

CodeRabbit's story began with an internal experiment at Harjot's second startup. At that time, 15 developers started using GitHub Copilot, and the code review bottleneck became painfully obvious—the remote team was distributed across Eastern Europe, and waiting for a single approval could take hours or even days. This weekend project was productized by Harjot's brother Gauri and quickly went viral thanks to its excellent developer experience.

The key turning point was a seemingly risky decision: free for open source projects. At a time when GPT-4 charged $40 per million tokens, the company bore huge costs with its own funds. Harjot revealed that over three years they spent $7-8 million in AI costs supporting open source. But this strategy built a powerful distribution flywheel—developers saw CodeRabbit's effects in open source projects they loved, then brought it into their workplaces.

The result: growing from $1 million ARR to over 10x in less than 12 months, followed by a $60 million Series B led by Scale Ventures. The latest $140 million round corresponds to a $1.5 billion valuation, with ARR already exceeding $60-65 million and 15-20% month-over-month growth.

ARR (Annual Recurring Revenue) is the most core scale metric in the SaaS industry, referring to revenue annualized based on current subscription status, which smooths out one-time revenue and seasonal fluctuations, making it easier to compare different companies horizontally. CodeRabbit's disclosed "ARR exceeding $60-65 million, 15-20% month-over-month growth" means its revenue curve is still in a steep upward phase—at this growth rate, it can double within a quarter. The early statement "growing from $1 million ARR to 10x in less than 12 months" corresponds to the commonly used "triple-triple-double-double" growth narrative in the SaaS circle, used to prove that product-market fit has been established.

Developers in the Agent Era: From Writing Code to Making Decisions

When AI agents can run autonomously for hours and open Pull Requests, the developer's role has fundamentally shifted. Harjot observed that the code review loop is being automated: Claude Code agents open PRs, CodeRabbit reviews them, and agents iterate submissions based on feedback until all guardrail requirements are met. This adversarial review loop is completed before human intervention.

This means the developer's core value is no longer writing code, but judgment—deciding which of the 100 PRs opened by agents are worth pursuing. Is it a security issue? A customer support ticket? Or a new feature? Planning is shifting from ticket systems like Jira and Linear to the code itself. As Harjot says, no longer submitting tickets, but submitting Pull Requests; ideas exist in the form of code.

80% of the work is done by AI, and the last 20% is human taste.

This also explains why among CodeRabbit's 250-275 employees, only 35-40 are engineers, while sales and marketing teams make up the majority. Product creation is no longer the bottleneck; human attention is.

Pull Request (PR) is the collaboration primitive on code hosting platforms like GitHub: developers submit changes on a branch as a proposal that can be discussed, commented on line by line, automatically checked, and ultimately merged. It is essentially a "package of changes," accompanied by diff comparison, review records, and CI pipeline status. Harjot's statement that "planning shifts from Jira to the code itself" precisely leverages this characteristic of PRs—when agents can directly produce PRs, requirement descriptions, implementation plans, and verification results naturally aggregate on the same object, eliminating the need to sync back and forth between ticket systems and code repositories.

Observability Is the Past, Explainability Is the Future

Harjot offered an analogy: the observability services provided by Datadog account for about 25-30% of AWS bills, and code review and explainability—that is, how to build trust in AI output—will be a problem of the same magnitude.

CodeRabbit's product logic revolves around three layers of value. The first layer is guardrail enforcement, ensuring code meets the organization's maintainability, security, and compliance standards before human intervention. The second layer is prioritization, helping developers identify changes with the greatest customer impact from the massive number of agent-generated PRs. The third layer is explainability, providing high-level abstraction for increasingly large PRs so reviewers can understand the scope of impact, blast radius, and architectural impact of changes.

As agents run longer and PRs grow larger, the problem of authors not reading code and reviewers being unable to piece together the full picture becomes increasingly prominent. CodeRabbit efficiently extracts context through semantic analysis and code graphs, handing line-by-line review to AI while humans make judgments at a higher dimension.

Observability originated from control theory, referring to the ability to infer a system's internal state solely through its external outputs (logs, metrics, distributed tracing). In the cloud-native era, it became the infrastructure for operations teams to troubleshoot distributed system failures, and Datadog is a representative vendor in this space. Harjot's analogy of "25-30% of AWS bills" is meant to illustrate that code review and explainability hold a similar position in the AI era: not optional icing on the cake, but a necessary expense for understanding black-box output. The difference is that observability answers "where the system broke," while explainability answers "why this AI-generated code can be trusted."

Business Model: Per-Seat Pricing Scarcity

In an era of AI startups where token-based billing has become mainstream, CodeRabbit insists on per-seat pricing. The Pro plan is $24 and the Pro Plus plan is $48, and the vast majority of users will not hit rate limits. Harjot compares this to Amazon Prime's free shipping—users want it, but actually doing it is a difficult engineering problem.

The difficulty lies in cost control. CodeRabbit has been a multi-model integrated architecture from day one, not letting users select models from a dropdown menu, but presenting the right tokens to reasoning models through sub-agents and context engineering. This efficiency strategy is pushing its gross margin from early levels toward the 50-80% range.

Interestingly, model price cuts have not improved profit margins—the savings have been used to add more sub-agents and more thorough reviews. The result is product improvement: the adoption rate of review suggestions has increased from 30-35% to 65-70%.

Per-seat Pricing is the most classic billing model of traditional SaaS, charging by the number of users using the product. Revenue is predictable and easy to understand, but insensitive to "usage intensity." In contrast, token-based or call-volume-based billing can more precisely reflect the marginal cost of AI inference. CodeRabbit's insistence on the seat model is essentially using the pricing structure to signal to customers that "review costs will not spiral out of control with the number of PRs," while forcing itself to lower per-review costs through multi-model routing and context engineering—which is also the key to its gross margin moving toward the 50-80% range.

Competitive Landscape: The Trust Crisis of Benchmarks

Competitors in the code review space include startups like Codo and Reptile, as well as general solutions offered by model labs themselves. But Harjot is skeptical about the credibility of benchmarks: vendor-published benchmarks are inevitably biased, and independent benchmarks like Martian can only touch one side of complex workflows.

CodeRabbit has never published its own benchmark, citing the reason that "it cannot be done fairly." Measuring the effectiveness of code review is itself subtle—look at adopted comments? But developers may delay processing because they don't want to inflate existing PRs. This complexity makes it difficult for external benchmarks to capture real product differences.

In Harjot's view, the competitive moat is not model capability, but distribution and integration depth. CodeRabbit has the most GitHub installations among all AI products, and this surface is difficult to conquer. Once it becomes part of a team's workflow, product stickiness is extremely high and churn is very low.

Who Is the Next Target for Disruption?

When agents directly operate on code, middle-layer tools face survival pressure. GitHub is bearing the PR flood—which is also why its infrastructure frequently has problems, but Harjot believes this precisely proves GitHub's importance as the only remaining bottleneck. The ticket systems of Linear and Jira are being bypassed, and planning happens directly in code.

Figma is not immune either. Design will not disappear, and human taste remains crucial, but the interaction interface will become agentic. Harjot revealed that CodeRabbit has already coded all marketing materials, slides, and even Google ads internally—deploying an ad means opening a Pull Request, automated through the GitOps process.

Design still needs to be tactically driven by humans, but if you want to create new taste and new design, you still need to drive the agent.

The Next 12 Months: Agent Change Management Becomes a New Category

CodeRabbit redefines itself as an "agent change management" platform. Analogous to Git as source code management, the new market is change management—because changes are made by agents. More and more agents will autonomously wake up in the background, decide to fix data alerts, implement customer features, or write changelogs, then open Pull Requests.

This means three core capability requirements: PR quality must meet standards before human intervention; humans need help categorizing and prioritizing; explainability—proving that agents' work can be trusted. Harjot believes the market opportunity for explainability is even greater than observability, because every problem is becoming a programming problem, and the audience that needs to understand agent output is far larger than traditional operations teams.

Is this a winner-take-all market? Harjot's answer is yes, but only at the code review layer. Programming agents themselves will be highly fragmented—each company will use four or five different agents, just as they used different editors in the past. But review and guardrails need to be centralized: a unified solution to define and enforce the checklist that organizations care about.

Entrepreneur's Lesson: Identifying Waves Within Waves

Looking back on three startup experiences, Harjot's core reflection is: don't try to make waves, surf them. His first startup NetSil seized the observability demand arising from Kubernetes and microservices, going from zero to $1 million ARR in just one quarter. His second company LuxNinja tried to educate the market about controllability without a wave, and was eventually acquired by CodeRabbit.

You cannot truly create waves. Riding waves is easier.

But identifying waves requires being in the arena. Harjot believes that if you are not in the arena, you will never discover these opportunities. Once a wave is identified, failing fast and pivoting decisively are equally important. He admits he has also fallen into the sunk cost fallacy, but ultimately chose to close his own company and merge with his brother's CodeRabbit.

Regarding the current AI startup boom, Harjot's advice is to look upstream in the value chain: models will become commoditized, agent frameworks will be open sourced, and value will accrue to the application layer that solves team-level pain points. He particularly points out that the AI experience of collaboration platforms like Slack is still blank, and there is still a lot of room for new abstractions like "company as code."

Conclusion

Software engineering has not ended; it is being re-layered. The barrier to writing code is disappearing, but the ability to verify code, understand code, and make the final 20% judgment has never been more precious. CodeRabbit's case reveals a broader trend: when execution becomes cheap, trust and judgment become the new bottleneck, and companies that solve this bottleneck will capture enormous value.

Harjot's prediction is that in the future most tokens will be consumed by background agents that run autonomously, submit PRs, and wait for review. Human work is deciding which PRs deserve to exist. This is not the end of software engineering, but the coming of age of software engineering.