Somewhere in 2026, agentic coding stopped being a demo and became a budget line.

The evidence stacks up fast. Cognition, the company behind the Devin agent, closed a round of more than $2B at a $48B valuation, the highest price tag in the AI coding business. McKinsey's State of AI survey found 32% of organizations skipped a software purchase this year and built their own solution with agents instead. Cursor's parent company, worth $29.3B on its own in November 2025, got absorbed by SpaceX and now feeds developer data into Grok.

And yet the loudest argument in the industry is still about two words: vibe coding. That's the state of agentic coding in September 2026: record capital, measurable enterprise adoption, and a profession that can't agree whether the person at the keyboard still counts as an engineer.

The market has already decided

Four months after raising $1B at a $26B valuation, Cognition came back with a $2B+ round at $48B. The company's annualized revenue run-rate went from $492M in May to nearly $900M now. At that scale, enterprises are paying real money for agent-built software, not funding pilots.

The customer list reads like a Fortune 500 bingo card: NVIDIA for chip design, GE Aerospace for aviation, Citi for financial services, Mercedes-Benz for manufacturing. Scott Wu, Cognition's CEO, positions Devin as relief for the work programmers don't want: legacy system upgrades, platform migrations, long-tail maintenance. Free the humans for creative work, the pitch goes. The three founders are all International Olympiad in Informatics gold medalists, with five medals between them. Devin itself launched in March 2024 to enormous hype, then stumbled: 3 of 20 tasks succeeded in a public real-world test, and the $500/month price tag scared off individual developers. The 2025 Windsurf deal changed the trajectory. After Google DeepMind poached Windsurf's CEO and core team, Cognition grabbed the remaining IP and reported revenue growth above 30% within seven weeks.

The rest of the scoreboard moved just as fast.

Company	Product	Valuation / fate	What it signals
Cognition	Devin	$48B, Sept 2026	Raised $2B+; owns Windsurf after the DeepMind raid
Anysphere	Cursor	Acquired by SpaceX	$29.3B standalone in Nov 2025; developer data now trains Grok
Lovable	Lovable	$13.3B, Aug 2026	Built its whole brand on vibe coding; $500M+ annualized revenue
Replit	Replit	$9B, Mar 2026	Pivoted from education tool to AI-native development platform

Cursor's exit is the strangest data point. Anysphere went from a $400M valuation in August 2024 to $29.3B in November 2025, then vanished into SpaceX at roughly 20% above the $50B deal it had been negotiating. SpaceX's IPO filing says Cursor's programming requests and design decisions will improve Grok. The most successful AI coding company in history is now a training-data pipeline for a foundation model, which says a lot about who holds the advantage: model-makers keep squeezing the standalone tool layer, and the pure-play startups that survive are the ones that move up the stack.

Menlo Ventures counts coding as $4B of the $7.3B in department-level enterprise AI spending this year. That's 55 cents of every enterprise AI dollar, more than IT ops, marketing, customer success, and design combined. Grand View Research sizes the global market at $9.8B this year and expects $26B by 2030. Market share is shifting just as hard: Cursor fell from 41% to about 26% between June 2025 and May 2026, while Claude Code climbed to roughly 54% with a 91% customer satisfaction score. Caveat: Menlo is itself an Anthropic investor. Even discounted, the direction matches what developers report anecdotally: terminal-based agents are grabbing share from IDE-based tools, even if the two coexist in many workflows.

Quick Take: The market has stopped asking whether agents can write software. The open question is who owns what happens next, and that's the argument the vibe coding debate keeps circling.

The definition fight

With that much money in motion, you'd expect the industry to have settled what it's actually building. Instead, the most-read arguments this month are about a term with no agreed definition.

The cleanest breakdown I've found comes from a Dev.to essay by George Kobaidze, and it splits the field into three:

Vibe coding. You write a prompt, hand it to the AI, and ship what comes back. You don't edit the code and you don't review it. You might know nothing about programming and still produce something that runs.

AI-assisting. The AI generates, but a human reads every line before it ships. This is not vibe coding, because the ability to tell good code from bad is itself a skill, and the no-review workflow never develops it.

AI-assisted. You and the AI write together, with you driving. The AI is a second opinion, an edge-case generator, and a speed multiplier. Also not vibe coding.

The comments push back exactly where you'd expect. Some developers argue the vibe-coding label is too narrow: people who direct agents through prompts, iterations, and validation are doing engineering, just with the syntax moved elsewhere. Orchestration is the new engineering, goes the argument. Others hold the line: if you never review the output, you're creating, not engineering. Both sides are describing real activities. They're just using the same word for different things.

The boundary that actually matters is the one the comments kept circling: reviewing agent-written code takes skill, but being the person who gets paged when it breaks in production at 2am is a different skill entirely. A lot of vibe-coded software never hits that test, because it never goes anywhere real.

The review layer is the real skill floor

I've spent the last few months living on this boundary, and my experience matches the comment section more than the vendor marketing does.

When I wanted to add a multi-runtime tool runner to a project, I couldn't just tell the agent "add Wasmer." I had to verify it was using WASIx correctly, check that the SDKs were sufficient, and make sure tool calls weren't double-serializing. Getting the output right took longer than building the thing myself. I now spend more tokens interrogating generated code than generating it, because the first pass is always plausible and often subtly wrong.

I've caught agents doing "interesting" things plenty of times. A clean-looking implementation that was wrong at the system level. A caching "optimization" with no invalidation strategy. An auth path that worked in the demo and sat open to the internet in production. Reviewing every line an agent wrote does not catch a misconfigured server, missing backups, or permissions left wide open. Code review saves you from bad code. It does not save you from bad ops.

The comment that stuck with me was about ownership after deploy. Reviewing AI-written code is one skill. Being on call when the database fills up at 2am is another. The vibe-coded feature rarely includes the vibe-coded ops behind it, and that's where it quietly falls apart.

Companies are already building instead of buying

The McKinsey number deserves more attention than the headline. The State of AI survey, published in late August, found 32% of organizations decided against a commercial software purchase this year and built their own solution with agentic coding tools instead. In the tech sector, it's 41%.

On Reddit, the reaction was healthy skepticism: is anyone actually killing real purchase orders, or is this survey answers outrunning budget reality? My own team sits in between. We cancelled one niche internal tool subscription and replaced it with an agent-built service that two engineers stood up in about three weeks. We also started three agent-built prototypes that will never see production, because they passed the "looks finished" test and failed the "we'd bet user data on this" test.

But the build-versus-buy calculus has shifted for real. When a procurement cycle takes six months and an agent can scaffold a production-shaped service in a weekend, the default flips. Writing the code is no longer the bottleneck. Verification, security review, and the willingness to be on call for something an agent wrote are what take the time now.

The capital side moves in the same direction. Cognition's valuation curve shows how fast the category is compounding:

A $26B company in May, a $48B company in September. That's not a product cycle, that's a land grab. The funding is betting that agentic coding becomes the default way enterprise software gets built, and the 32% adoption number says the bet is landing early.

Key numbers:$48B — Cognition's post-money valuation after its September 2026 round, up from $26B in May. 55% — share of department-level enterprise AI spending that goes to coding tools, per Menlo Ventures. 32% — share of organizations that skipped a purchase and built with agents instead, per McKinsey. 41% → 26% — Cursor's market share slide from June 2025 to May 2026, while Claude Code climbed toward 54%.

What happens to junior engineers

August 2025 gave the industry its most-quoted line on this topic. AWS CEO Matt Garman called using AI to replace junior staff "the dumbest thing I've ever heard." It was a strange moment: the head of the world's largest cloud company, whose customers buy AI infrastructure by the megawatt, telling executives not to cut the entry-level pipeline. He's right, and the mechanism is more concrete than the usual culture argument.

Junior engineers learn by doing the work agents now do. Updating the legacy endpoint. Running the migration nobody wants. Bumping a dependency and watching staging break. That grunt work is the on-ramp. It's where developers first build a sense of what good code looks like, because they see the consequences of bad code at small scale. If an agent absorbs all of it and the only human involvement is a senior engineer reviewing diffs, the industry is setting up a 10-year gap in which nobody arrives at senior level through the traditional path.

The counter-position shows up in every thread: orchestration is the new engineering, and prompt decomposition plus output validation are the skills that matter now. There's truth in it. But orchestration skill does not substitute for the ability to tell good code from bad, and that's the ability the no-review workflow never builds. The three-tier split puts the skill floor exactly where it belongs: not in who typed the code, but in who reviewed it.

Common pitfalls: what trips people up with agents

Ship without the review layer. Fine for a weekend project. The moment agent-written code touches user data, money, or auth, skipping review is how you end up in a postmortem.

Review the code but not the system. I made this mistake myself. I read every line the agent wrote, approved the PR, and missed that the deployment config it generated had no backups and a public storage bucket. Check the deployment, the permissions, the data handling, and the failure modes.

Trust agent-written tests. Agents write tests that pass because they encode the same wrong assumption as the implementation. A tautological test suite gives false confidence. I write one adversarial test by hand for every critical path the agent builds.

Let the agent touch dependencies. Don't bundle "upgrade this library" into a feature task. I watched an agent quietly bump a build tool three major versions mid-refactor, and the next deploy failed in a way that took a day to unwind. Pin the environment and let the agent work inside it.

Measure speed instead of ownership. It doesn't matter that the agent delivered the feature in an afternoon if nobody is willing to be on call for it. A chunk of the 32% adoption number is prototypes that will never survive contact with real traffic.

One thing to remember

Whether you call it vibe coding, orchestration, or engineering, the accountability question is the same. Once agent-written code handles money or personal data, someone has to own it. The person who gets paged is the owner, and the page doesn't care who wrote the code.

The bottom line

Three takeaways, depending on where you sit:

• If you're building something for yourself or for fun, vibe code freely. The cost of being wrong is low. Keep it away from other people's data, and don't call it engineering to anyone whose opinion matters.
• If you're running an engineering team, adopt agents aggressively, with two non-negotiable rules: a human reviews every line, and an engineer owns the deployment. Generation is cheap. Verification and on-call are the actual product.
• If you're making hiring plans, don't cut juniors to save money. Agents eat the exact tasks that build senior engineers, so cutting the on-ramp saves a year of salary and costs a decade of capability. Watch the tool market: model-makers keep eating the standalone layer, and the Cursor/SpaceX deal won't be the last consolidation of 2027.