Anthropic Develops Features Similar to Lovable

Recently, a user on X with the ID @marmaduke091 revealed that following the leak of Claude Code’s source code, Anthropic has experienced another leak. They are creating a feature similar to Lovable, allowing users to easily build full-stack applications. They are catching up with everything.

Another user, @k1rallik, even uncovered details of this leak, stating, “Anthropic has leaked another message; they are building a full-stack Vibe coding platform that competes directly with Lovable, Bolt, and v0.”

The leaked content includes:

• “Let’s deliver something great” — build applications through text input
• Real-time preview in the built-in browser
• One-click deployment
• Features: dark mode, login, security scanning, database setup
• Project settings: database, storage, authentication, users, logs

This is not just a code generator; it’s a complete underlying architecture. Hosting, databases, authentication, analytics — everything is integrated into Claude.

Speculation is rife that Anthropic is about to launch new features.

Currently, it is unclear whether the information leaked by these users on X regarding Anthropic’s new features is accurate, but Anthropic has indeed been pushing Claude from a “chat model” towards a “platform for creating, hosting, and sharing applications” over the past year.

Anthropic Accelerates Development of the Entire AI Stack

A compelling piece of evidence comes from the Claude Code source code leak on March 31, 2026. Due to a source map file mistakenly included in an npm package, Anthropic’s Claude Code CLI was fully exposed, involving about 1,900 TypeScript files and over 510,000 lines of code, almost equivalent to revealing the entire implementation details of the “AI programming agent system”.

More critically, this leak did not just expose a “code generation tool”; it showcased a complete engineering system around AI agents: including file editing, command execution, Git operations, task orchestration, and full development process capabilities. This means that Anthropic is actually building an “execution layer” that can directly participate in the entire software development process, rather than just providing model inference capabilities.

According to a report from InfoQ, the leaked source code hides many unreleased features behind feature flags. KAIROS describes a persistent background agent mode, where Claude Code runs as a background agent, executing memory consolidation when the user is idle. ULTRAPLAN seems designed to offload complex planning tasks to cloud infrastructure.

These designs point to a more radical direction: AI is not just responding to requests but possesses continuous operation, long-term task management, and contextual memory capabilities. Media reports also mentioned that the code exposed an “always-on agent” and a complex memory system, which essentially approaches a “long-running development assistant” rather than a one-off interactive tool. This architecture is the core infrastructure for building applications (rather than just generating code).

By looking back further, it can be seen that Anthropic is systematically filling in the entire AI development stack.

Since 2025, its products have gradually expanded from the Claude model itself to Claude Code (CLI programming agent), Claude Cowork (GUI tools for non-developers), and “computer use” (direct computer operation) capabilities, forming a closed loop from the interface layer to the execution layer.

Notably, the “computer use” research preview released two weeks ago marks the model’s ability to operate operating systems and real software environments, directly breaking the boundaries of traditional SaaS applications, allowing AI to bypass APIs and complete tasks directly in the user environment.

This combination of capabilities is essentially reconstructing an “AI-native software execution environment” rather than enhancing existing software.

It is worth noting that Anthropic is also attempting to solve the most critical engineering problems in AI application development: consistency and reliability in long-term, multi-step tasks.

On March 24, Anthropic announced the launch of a multi-agent framework, which is a typical example — by breaking tasks into multiple agents for planning, generation, evaluation, and maintaining consistency over sessions lasting hours, it supports the complete application building process. This architecture has clearly surpassed “code completion” or “script generation” and is evolving towards “automatically completing a full software project”.

From these signals, it can be seen that Anthropic’s strategy is not just to stay at “stronger models” but to consume the entire development toolchain: from model (Claude) → agent (Claude Code) → collaborative interface (Cowork) → execution environment (computer use) → multi-agent orchestration (multi-agent framework).

The internal structure revealed by the Claude Code leak indicates a signal: it already possesses the foundational capabilities to build, run, debug, and even maintain applications.

This also explains why there is growing discussion about whether Anthropic is transitioning from a model company to an “AI application platform company,” potentially replacing upper-layer application building tools like Lovable and Base44.

AI Programming Enters the “Harvest Era”: What Is Vibe Coding’s Moat?

The new features leaked from Claude sparked intense discussions on X. One highly upvoted comment stated that the one-click publishing feature changes everything. The user wrote:

“Currently, most Vibe-based coding tools still face a huge gap between ‘I made something cool’ and ‘people can actually use it.’ If Anthropic can integrate deployment, authentication, and database into one process, then Lovable and Bolt will truly face severe challenges.”

Some users mentioned that they previously used Lovable but switched to Claude Code, finding that developing with Claude Code is actually cheaper than using Lovable.

Users expressed that while Lovable is great for prototyping, Claude Code and Codex will eventually provide similar functionalities; it’s only a matter of time.

Others noted that applications like Lovable have no real technical barriers. One user remarked:

“A few months ago, I switched from Lovable to Claude Code, and now there’s no reason to choose Lovable anymore.”

Some users believe that not only Anthropic but other model giants are also transitioning to full-stack building tools, indicating that this field is merging, with everyone pursuing the ultimate goal of unification.

An interesting discussion on Hacker News previously asked what the biggest illusion is among cutting-edge AI startups. One answer was that these companies believe they truly have a moat.

For a long time, platforms like Lovable, Base44, and Bolt have become the “last mile” for users to access AI-native applications by encapsulating underlying model capabilities through extreme UI/UX optimization and workflow integration.

They seized the window of opportunity when model vendors focused solely on the “brain” and neglected the “limbs,” quickly winning momentum through the logic of “model + editor + deployment.”

However, as Anthropic, OpenAI, Google, and other model giants begin to reconstruct the “AI interaction layer,” this logic is collapsing.

On November 18, 2025, Google released Gemini 3, heralding the “beginning of a new intelligent era.” Gemini 3 supports Antigravity, a new integrated development environment (IDE) that allows autonomous agents to handle complex coding tasks.

OpenAI, Anthropic, Amazon, and other giants are certainly not idle either. Originally existing as vertical applications, Claude Code and OpenAI Codex can now be integrated into VS Code or Cursor with a single click; Amazon launched the AI-enhanced IDE Kiro; the established cloud collaboration platform Replit also pivoted to an AI Agent model. Even in the acquisition market, the Vibe Coding tool Base44 was acquired by Wix for $80 million in cash and subsequent earn-out agreements.

Behind this prosperity lies a harsh reality: AI programming has entered the “harvest era,” with model vendors gradually swallowing all tool trends.

Today, all AI coding tools are essentially advanced encapsulations of GPT 5.1, Claude 4.5, or Gemini 3 Pro.

Developers are collectively hitting a wall: 90% of traditional programming skills are being commoditized, becoming cheap and accessible, while the remaining 10% — the ability to effectively coordinate AI for complex architectural design — has increased in value by 1000 times, but this 10% does not depend on which UI wrapper you use.

This raises an awkward question for star startups like Lovable: What is your true moat?

An article titled “$6 Billion Lovable: Where’s the Moat?” published on LinkedIn and a YouTube video titled “Stop Vibe Coding. Start Getting Customers” analyze the logic behind Lovable’s $6 billion valuation.

Combining the viewpoints from the article and video, if we look at Lovable in the context of the evolution of the entire AI software stack, its so-called “moat” does not come from underlying technology but from redefining user structure, content ecology, and usage paths.

In other words, it is not competing with model companies on “capability ceiling” but vying for “who will meet the user demands released by the models.” The question thus becomes: In an era of rapidly commoditized model capabilities, can Lovable build a structural advantage on top of the models that supports its high valuation?

First, the moat that Lovable is most likely to establish is a deliberate misalignment in the target market — the path of “code version of Canva.”

It does not attempt to serve professional developers but targets a group of people who are unlikely to enter traditional development environments: entrepreneurs, designers, product managers, and small business operators. These users have strong software needs but lack programming skills; they also won’t use tools like Visual Studio Code or integrate into engineer-centric development paradigms.

In this sense, Lovable’s true competitors are not development tools but the real constraints of “people who can’t code but want to make software.” If it can encapsulate complex capabilities into intuitive operations like Canva did in the design field and build brand and community recognition around non-technical users, it indeed has the opportunity to establish a solid position in a long-ignored market. This market’s scale may even exceed that of professional developers, as it essentially brings “software production capability” to a broader audience.

Secondly, the second layer of moat Lovable is trying to build is based on user-generated content (UGC) templates and application ecology, or more straightforwardly, Lovable’s super-strong distribution channels.

Platforms like Lovable release 200,000 new projects daily. If the platform generates a massive number of applications daily and can solidify these applications into a reusable template library, further developing into a searchable, tradable, and combinable market, then its value will leap from “generation tool” to “application distribution and reuse network.” This model is closer to Envato or ThemeForest: the real barrier lies not in technology but in the network effects between content supply and demand. Once developers or creators start producing templates around the platform, users can build applications by consuming these templates, forming a self-reinforcing positive feedback loop for the platform.

However, this path has stringent prerequisites — it must solve issues like content quality, copyright ownership, template maintenance, and incentive mechanisms; otherwise, the so-called “ecology” can easily degrade into a pile of low-quality, unmaintained projects, thereby harming user experience.

The third possible moat comes from embedding workflows on the enterprise side. Lovable has begun to enter enterprise customer scenarios; if it can deeply embed itself into enterprise development and operational processes, such as participating in internal tool development, automating business processes, or even becoming a “software production interface” for non-engineering teams, it may create a certain degree of lock-in effect. This lock-in is usually achieved through several dimensions: first, workflow integration, making the tool part of daily operations; second, data sedimentation, allowing historical projects, templates, and usage habits to gradually attach to the platform; third, compliance and security systems, such as meeting SOC2, GDPR, and other standards, thus increasing replacement costs; fourth, team collaboration capabilities, including permission management, approval flows, and version control.

However, it is important to note that this moat is essentially “soft.” Enterprises are extremely pragmatic in tool selection; if a higher cost-performance ratio or a stronger capability alternative emerges, they will quickly migrate. If the underlying AI capabilities come from general models rather than proprietary technology, then Lovable’s differentiation on the enterprise side can easily be replicated.

Finally, the most immediate layer of moat is brand and community momentum. Lovable has already occupied a certain mental position in the context of “Vibe Coding” through early viral dissemination and product storytelling; its founder has also become an important voice in this field. This advantage is highly valuable in the early stages, as it can bring self-propagation, reduce customer acquisition costs, and create emotional connections among users — users choose it not only because it works but also because of “identification.” However, the problem is that this moat is typically very fragile in the development tools and even AI tools space. Users — especially those with a certain level of technical judgment — have very low loyalty to tools; once Google, Anthropic, or other platforms provide stronger, cheaper, or more stable capabilities, migration can happen almost instantly.

Time Is Running Out for Lovable

Although Lovable’s CEO Anton Osika claims the company is building “The Last Software,” which sounds like a powerful slogan.

But peeling away the marketing fog reveals that its essence is still wrapping the truly “last software” — those third-party cutting-edge models serving as underlying intelligent engines — in a beautiful user interface.

When Anthropic’s Claude Code can directly integrate with local development environments through CLI and even autonomously handle incremental refactoring and complex logic, why would users take an extra step to use third-party encapsulation tools?

When the “brain” learns to directly manipulate “tools,” those UI plugins, deployment templates, and middleware once referred to as “moats” instantly degrade into a “function plugin” of the model.

This is the “ecological dimensionality reduction strike”: every step forward by model vendors reduces the air available for middle-layer entrepreneurs.

Lovable, Base44, and Bolt’s once-proud “speed” and “ease of use” are facing comprehensive reclamation from the bottom.

In fact, what truly determines whether Anthropic will “swallow” application building tools like Lovable and Base44 is not how many features they have but whether the layering of the software stack still holds.

The traditional software system is clearly layered: above the model layer (LLM API) is the application building layer (such as low-code/AI application generation platforms like Lovable and Base44), and above that are specific applications. Anthropic is systematically breaking through these layers, internalizing “application building capabilities” directly into the model and agent execution system.

The structure revealed by the Claude Code leak is already very close to a “self-contained development environment”: the model not only generates code but also directly participates in file system operations, command execution, version control (Git), task decomposition, and scheduling.

This means that the core capabilities originally belonging to Lovable and Base44 — such as application generation, component assembly, and deployment process management — are being migrated to a lower, more general execution framework. When the “development process” itself becomes part of the model, the value of upper-layer tools will be compressed to interface encapsulation, and this is the easiest part to replace technically.

More critically, Anthropic’s path is not about “being a stronger builder” but about building a continuously running agent computing model. From the persistent agents (like KAIROS) in the leaked information, feature flag systems, to the “planning - generation - evaluation” closed loop in the multi-agent framework, it is clear that their goal is to enable AI to autonomously advance complex tasks over long time scales.

This fundamentally differs from Lovable/Base44’s “instant generation of an application prototype”: the former is a system that can continuously iterate, maintain, and even refactor software, while the latter is closer to a one-time generation tool. When the software lifecycle (development → deployment → iteration → maintenance) is entirely taken over by agents, single-point “application generation tools” will be marginalized.

Looking further down, the introduction of “computer use” capabilities further weakens the foundational existence of application layer tools. One premise of traditional application building platforms is that: all capabilities must be exposed through APIs or predefined components. But once models can directly operate operating systems, browsers, and existing software, they no longer rely on these intermediate layer abstractions. In other words, AI can directly “use the software in the world” rather than “generate new software through the platform.” In this paradigm, the role of Lovable/Base44 as an “application generation intermediary” will be replaced by a more general agent execution layer.

From an architectural evolution perspective, this is essentially a typical “layer collapse”:

• Model layer consumes application logic (through tool use, agent orchestration)
• Execution layer consumes operating environment (through computer use)
• Agent layer consumes development process (through multi-agent collaboration)

When these three things happen simultaneously, the originally middle-positioned “AI application building platforms” will lose the necessity of independent existence. Because they neither possess lower-layer execution capabilities nor can provide higher-level abstractions than agents, they can only remain at the UI and process encapsulation layer.

Thus, the question is no longer whether Anthropic will “make a Lovable,” but rather: When Claude itself is a system that can build, run, and continuously evolve applications, what irreplaceable capabilities do products like Lovable have left?

If the answer is merely “a better interface” or “a lower barrier to entry,” then these advantages typically will not hold long-term in the face of continuously enhanced model capabilities.