Why So Much AI Feels Like Slop — And How Replit Is Chasing ‘Vibe Coding’ Instead

Generative AI is everywhere in the developer tooling ecosystem, but much of what it produces still feels the same: generic images, boilerplate code, and assistants that promise a lot yet only nudge productivity forward. Replit CEO Amjad Masad has a blunt word for this output: slop.

For software engineers and product leaders trying to build credible AI agents and development workflows, Masad’s critique is less about dismissing the technology and more about identifying what’s missing. In a recent appearance on VentureBeat’s “Beyond the Pilot” podcast, he argued that AI tools today are mostly “toys” — unreliable, marginally effective, and lacking any sense of “taste.”

Replit’s answer is a mix of design choices, rigorous testing loops, and a strategic bet on what Masad calls “vibe coding”: a future where far more people can shape software behavior without being traditional developers, and where AI agents do more than autocomplete code or chat about tickets.

The problem with today’s generic AI

Masad’s starting point is a frustration many builders share: despite rapid model advances, there’s “a lot of sameness out there.” Whether you’re generating images or scaffolding an application, outputs often converge on a bland median. The interfaces differ, but the feel of the results is nearly identical.

He describes today’s crop of AI features as “toys” — not because they’re useless, but because they’re still unreliable and only marginally improve core workflows. They tend to live around the edges of a product rather than inside the critical paths of design, development, and operations.

This sameness, the “slop,” comes from more than just weak prompts. Masad points to a deeper absence: AI systems and tools that lack any strong, opinionated taste. Without that, even powerful models regress toward generic output that feels detached from a product’s unique point of view.

For practitioners, this shows up as assistants that look impressive in demos but struggle to uphold a house style, a team’s coding standards, or the nuanced constraints of a real product. They can produce something, but not necessarily something that reflects your team’s identity or priorities.

What Masad means by ‘slop’ and ‘taste’

“Slop” has become a shorthand in AI circles for low-effort, low-fidelity output — often the result of a single prompt pushed through a general-purpose model. Masad extends that critique to the broader ecosystem: one-shot calls with no feedback loop, no refinement, and no embedded understanding of what “good” looks like for a specific team or product.

He argues that fixing this is less about magical prompts and more about platform responsibility. “The way to overcome slop is for the platform to expend more effort,” he says, and for its builders “to imbue the agent with taste.”

In this framing, “taste” is the missing ingredient: the encoded sense of what your product should look and feel like, how code should be structured, which tradeoffs matter, and what quality standards apply. It’s the reason two human engineers given the same spec can produce very different results — one functional but rough, the other elegant and robust.

For AI agents, taste has to be engineered into the stack. That means structured prompting, architectural choices, and systems that evaluate work against expectations, not just generate plausible answers. Without those layers, even the strongest underlying models tend to drift toward generic output that no one really owns.

Inside Replit’s anti-slop strategy

Replit’s approach to avoiding generic AI isn’t based on a single trick; it’s a composite of techniques built into its development environment and agent workflows.

First, the company leans on specialized prompting rather than treating the model as a blank slate. Prompts are tuned for specific coding and product tasks, and Replit’s own design systems include classification features that help shape how output is structured and categorized. This helps the agent respond in ways that match the platform’s expectations, rather than just emitting free-form text or code.

Second, Masad highlights Replit’s use of proprietary retrieval-augmented generation (RAG). While he doesn’t detail the implementation, the intent is clear: inject relevant context from your environment or artifacts so the model isn’t working in isolation. This reduces the tendency toward generic responses by grounding outputs in concrete, product-specific information.

Third, the team is willing to use more tokens — essentially, to pay for more context and more processing per interaction — in exchange for higher quality. Rather than optimizing purely for minimal cost per call, Replit accepts that richer prompts and longer internal exchanges can materially improve output quality.

Crucially, testing is in the loop from the start. After the first generation of an app, Replit sends the result to a testing agent. That agent analyzes features, identifies what worked and what didn’t, and reports back to a coding agent. “If you introduce testing in the loop, you can give the model feedback and have the model reflect on its work,” Masad explains.

This creates an iterative flow where models don’t just emit a one-shot answer; they participate in a feedback cycle that resembles how human developers refine features based on tests and reviews.

Using multiple models and agents to add ‘taste’

Another element of Replit’s strategy is to deliberately pit models against one another. Testing agents may be built on one large language model, while coding agents run on another. The aim is to leverage differences in their “knowledge distributions” so that one system can critique or complement the other.

Masad describes this as a way to increase effort and variety: “That way the product you’re giving to the customer is high effort and less sloppy. You generate more variety.” Instead of a single model grading its own work, separate agents with different strengths and biases interact to shape the result.

This multi-agent, multi-model pattern aligns with how engineering teams already work. For example, a QA engineer may have different instincts than a feature developer, and their feedback loop produces a more robust product. Replit is formalizing that dynamic among AI agents.

On top of the agents themselves, Masad talks about a “push and pull” between what models can currently do and what engineering teams have to build around them to deliver value. The base capabilities change quickly, but the need for scaffolding, orchestration, and strong defaults remains constant.

There’s also a cultural dimension: “If you wanna move fast and you wanna ship things, you need to throw away a lot of code,” he notes. In an environment where models, prompts, and workflows evolve rapidly, clinging to old abstractions can hold teams back. For builders of AI tooling, that means being ready to refactor or discard substantial pieces of agent infrastructure as capabilities improve.

From chatbots to ‘vibe coding’

Despite high expectations, Masad acknowledges that the current generation of AI hasn’t fully delivered on the hype. Chatbots, while widely adopted, often provide only a “marginal improvement” in workflows. They answer questions and draft content, but stop short of fundamentally reshaping how software is created or maintained.

This is where he sees “vibe coding” starting to emerge. While the term is loose, his description is concrete: it’s a way for companies to adopt AI such that “everyone in the enterprise” can effectively become a software engineer. Instead of writing traditional code, employees solve problems and improve efficiency by shaping agents and automations based on their intent, context, and constraints.

Under this model, workers interact with AI at a higher level of abstraction — describing outcomes, processes, and preferences — while agents translate those “vibes” into executable workflows or applications. The net effect is less dependence on traditional SaaS tooling and more internal customization driven by the people closest to the work.

Masad predicts that the population of professional developers with formal computer science training “will shrink over time,” while the number of vibe coders who can solve problems with software and agents will grow “tremendously.” For engineering leaders, that implies a shift from being the sole authors of software to being enablers and governors of a broader, more distributed creation process.

In practice, this doesn’t erase the need for specialists. Instead, it changes the balance: core systems, architectures, and guardrails still require deep expertise, but a larger share of day-to-day logic and workflow optimization can move into the hands of domain experts using AI-native tools.

How enterprises must rethink software roadmaps

If vibe coding and agent-centric workflows take hold, the traditional way enterprises plan software will come under pressure. Masad argues that companies need to “fundamentally change how they think about software,” because AI capabilities are evolving so quickly that long-range roadmaps lose precision.

Rather than committing to rigid, multi-quarter feature plans, builders can only “roughly” estimate what things might look like even a few months or weeks ahead. New models, tools, or techniques can render a carefully plotted sequence obsolete overnight.

Replit’s internal posture reflects this volatility. Masad notes that his team is willing to “drop everything” when a new model appears, in order to run evaluations and see how it might reshape their product. This agility isn’t a side project; it’s integral to staying relevant when your core differentiation depends on how effectively you harness evolving AI systems.

He describes the broader AI landscape as something that will “ebb and flow,” requiring a mindset that’s “very zen” and “not have an ego about it.” For engineering and product leaders, that translates into a willingness to revisit earlier assumptions, retire recently built components, and let empirical performance drive decisions more than sunk cost.

For enterprises, the challenge is to marry this flexibility with governance and reliability. Teams need processes for quickly evaluating new AI capabilities, safely experimenting — often in isolated environments — and then incorporating what works into production without destabilizing existing systems.

Agents, sandboxes, and the path beyond toys

Masad’s broader vision for AI agents extends well beyond chat interfaces. In his conversation with VentureBeat, he emphasizes that true agents are defined not just by retrieval or reasoning, but by how they operate: they “work autonomously, repeatedly, without human intervention.”

To support this, Replit emphasizes mechanisms that let agents experiment and specialize safely. One approach he describes is “forking” the development environment to create isolated sandboxes. Within these sandboxes, agents can explore variations, test features, and iterate without risking core systems.

This sandboxing complements Replit’s focus on testing agents and feedback loops. Combined, they turn AI from a one-off assistant into something closer to a junior engineer who can continuously refine its work, guided by tests and constraints rather than direct human prompting for every action.

Masad also references a “squishy” divide in AI intelligence that makes specialization tricky: models are broadly capable but not cleanly partitioned into narrow expert roles. That makes orchestration — deciding which agent does what, under which conditions — an important part of any serious agent platform.

On the ecosystem side, he discusses the classic “cathedral versus bazaar” debate in open source and suggests a hybrid view: a “cathedral made of bazaars.” In the AI context, that means combining structured, opinionated systems with a diversity of contributions and experimentation at the edges. For teams building on AI, this translates into having strong, central guardrails and frameworks, while still enabling local exploration and domain-specific extensions.

Finally, Masad touches on the importance of context compression: making sure agents can access the right information without being overwhelmed by noise. While he doesn’t delve into technical detail, the principle aligns with Replit’s emphasis on classification, RAG, and structured prompts — all ways of ensuring that when an agent acts, it acts with focused, relevant context rather than an undifferentiated mass of data.

Taken together, these ideas sketch a path beyond “toy” AI. For engineers and product leaders, the lesson is clear: beating slop requires more than plugging in a model. It demands taste encoded in your systems, deliberate agent architectures, tight testing loops, and a willingness to keep reshaping your stack as the underlying capabilities evolve.

What technical leaders should watch next

Masad’s critique of generic AI and his vision for vibe coding offer a set of practical signals for technical leaders:

• Look for tools and platforms that encode opinionated “taste” — through design systems, prompt structures, and built-in feedback loops — rather than those that simply expose a raw model.
• Expect multi-model, multi-agent patterns to become more common, with different models critiquing and complementing each other in structured workflows.
• Plan for a growing population of “vibe coders” inside your organization: domain experts who use AI agents to shape software behavior without writing traditional code.
• Adjust software planning to account for rapid AI capability shifts, favoring adaptable roadmaps and continuous evaluation over strictly fixed long-term plans.
• Invest in safe experimentation environments — such as forked sandboxes — and in mechanisms like testing agents and context compression that move AI beyond static chatbots toward autonomous, dependable agents.

For teams already experimenting with AI in developer tools or product workflows, Masad’s message is less about abandoning the current generation of assistants, and more about not stopping there. The gap between slop and genuinely useful AI is being filled by platforms that expend real effort: orchestrating agents, embedding taste, and constantly re-evaluating as the underlying models change.

To hear Masad’s full discussion — including more detail on Replit’s agent architecture, the cathedral-versus-bazaar debate in open source, and how his team evaluates new models — VentureBeat’s “Beyond the Pilot” podcast episode is available on Apple Podcasts, Spotify, and YouTube.