A new category of developer is emerging, business developers.
Not everyday developers. Not no-code users.
These are people who have spent 10, 20, 30 years of their life inside a domain — insurance management, clinical operations, logistics, manufacturing, regional banking, and more. They understand the business in a way no software developer ever will. They've had tons of ideas the entire time. They just couldn't build any of them without hiring a dev agency, finding a technical co-founder, or giving up.
That restriction is gone (or soon to be).
The biggest unlock isn't the technology. It's the experience: someone with years of domain expertise watches their idea become a working, usable product. Time compresses from quarters to days. Cost compresses from thousands of dollars to a few dollars / month subscription.
What they're reaching for (and what they're not)
They're not reaching for Claude Code or Cursor — that stack still assumes you can read a stack trace. They're reaching for the layer above: Lovable, v0, Bolt, Replit Agent, Emergent. Idea goes in as natural language. Full-stack application comes out. No tech stack decisions. No orchestration. No auth wiring. No CI/CD. No deployment target debate. What you received is a working application, backed with best practices and industry standards (or at least the best practices of the past few years).
The abstraction isn't “write less code.” It's “don't think about the stack at all.”
The space is already crowded and it will get more crowded. But the opportunity is genuinely large because the unlock isn't incremental — it's categorical. Thousands of people who could never ship are about to ship.
Where coding agents fit in the chain
It helps to draw the layers out, because all of these tools get conflated in conversation.
- Foundation models (Anthropic Claude, OpenAI GPT, Google Gemini) — the raw intelligence layer. Almost nobody uses these directly for shipping apps. Platforms wrap them with their specialised agents, harness, orchestrators, prompt chains and deployment targets.
- Agentic coding tools (Claude Code, Google Antigravity, OpenAI Codex, Cursor) — the engineer's layer. You bring the project, the architecture, the stack decisions; the agent accelerates the work. Still requires stack know-how — when something breaks, you debug. This is where senior engineers live in 2026.
- No-stack platforms (Lovable, v0, Bolt, Replit Agent, Emergent) — the business developer's layer. You bring the idea; the platform brings the stack, the hosting, the auth, the CI/CD. When something breaks, you ask the agent to fix it — because reading the code isn't on the table.
The same foundation models power layers 2 and 3. The difference isn't the intelligence — it's the wrapper: what gets hidden, who the user is, what assumption set the tool optimizes for. Engineers and business developers will both be using foundation models from Anthropic, OpenAI, or Google under the hood. They'll be having entirely different conversations with them.
Three things to watch out for
1. The deployment layer. Whoever hosts captures the recurring revenue. The build is the hook; the runtime is the business. Every business developer who ships from Lovable or Bolt is also, by default, hosted by Lovable or Bolt — and pays them monthly. The build economics are an acquisition story. The hosting economics are the company.
2. The vertical layer. A platform tuned for Indian healthcare workflows or regional financial compliance beats a generalist for any business developer doing serious work. Generalists race to the bottom on price and features. Verticals compound — every customer makes the platform smarter about the domain, and the domain knowledge is what business developers were paying for the platform to encode in the first place. The next decade will have a long list of *Lovable for X* — and most of them will outperform Lovable inside their X.
3. The handoff. Business developers ship faster than they understand what they shipped. The platforms abstract the build — but the consequences of handling real money or real PII don't abstract away. The category that wins won't just automate the build. It'll automate the guardrails: scoped credentials, audit logs, rate limits, payment idempotency, data retention defaults, sensible secret management, monitoring out of the box. The handoff from “working in demo” to “safe in production” is where most business-developer apps will fail. Solving that gap is worth a category.
The instinct that's missing
The instinct to check what an app is actually doing in production isn't inherited from the platform. It's built from years of seeing things break. We covered the engineer's version of this in The Month-Three Moment: even seasoned builders ship AI workflows without per-invocation attribution and end up unable to defend the bill three months later. If experienced engineers struggle with that discipline, what happens to a domain expert shipping their first app via natural language?
The business developer wave needs that instinct built in, because they don't have it themselves. Not because they're lazy or unskilled — because they've been domain experts, not infra experts, for their entire career. The right platform meets them where they are: it gives them the build speed, and it builds the operational discipline into the runtime defaults.
That's the interesting opening.