← All issues

Build vs Buy: AI Agents Are the New SaaS Stack

Issue

Build vs Buy: AI Agents Are the New SaaS Stack

Distilling Deep AI Insights from Leading Podcasts

3 episodes3 podcastsFebruary 18, 2026
Cover art for The Official SaaStr Podcast: SaaS | Founders | Investors: SaaStr 842: The 90/10 Rule for AI Agents: What to Build vs Buy with SaaStr's CEO and CAIO

SaaStr 842: The 90/10 Rule for AI Agents: What to Build vs Buy with SaaStr's CEO and CAIO

The Official SaaStr Podcast: SaaS | Founders | Investors by SaaStr · 60 min

Listen to episode →

The episode centers on SaaStr's updated 90/10 rule for AI: buy 90% off-the-shelf and only build the 10% that delivers outsized, proprietary value. Hosts Amelia Lerutte (CAIO) and Jason Lemkin walk through real examples—an internal AI VP of Marketing and a sponsor/customer portal—showing how agent tooling like Claude Cowork made complex builds feasible and fast. They weigh the trade-offs of vibe-coding (rapid, low-code builds) versus buying SaaS, emphasizing hidden maintenance costs, security considerations, and the ongoing time sink for custom apps. The conversation stresses that AI is now table stakes: products without meaningful AI risk losing customers, while jaw-dropping AI experiences drive retention and growth.

Key Takeaways

  • 01

    Apply the 90/10 rule: buy 90% off-the-shelf, build only the 10% that drives outsized value.

    Significance: This rule guides pragmatic resource allocation—use mature SaaS and platforms for common needs and only invest engineering/time into bespoke functionality that creates a unique competitive advantage or materially impacts revenue. Relevant concepts/tech: vendor SaaS, vibe-coding, bespoke sponsor portals, AI VP of Marketing.

  • 02

    New agent platforms dramatically accelerate building production-ready AI features.

    Significance: Tools like Claude Cowork and agent runtimes let non-engineers or small teams spec, ingest local data, and automate workflows that previously required heavy engineering, cutting days of work to hours and lowering the barrier to deployable AI. Relevant technologies: Claude Cowork, Replit, Monaco, Lovable.

  • 03

    Hidden maintenance and people-time are the main long-term costs of custom vibe-coded apps.

    Significance: Initial speed and cost savings can be eclipsed by ongoing testing, SSO and integration bugs, security fixes, and feature creep—often consuming high-value employees' time and creating recurring costs that should factor into build vs buy decisions. Relevant concepts: single sign-on (SSO), security audits, platform-provided scans.

  • 04

    Zero AI in your product is a red flag—AI is now table stakes for differentiation.

    Significance: Buyers are allocating AI budgets and expect products to leverage AI; lacking AI can lead to being outcompeted or decaying product-market fit. Teams should prioritize AI features that create a 'jaw drop' reaction to retain/expand revenue. Relevant idea: the 'jaw drop' test for SaaS products in 2026.

  • 05

    Measure real operational ROI by testing agents on concrete workflows first.

    Significance: The episode demonstrated measurable gains—Claude Cowork processed 150+ contracts and reduced day-long manual tasks to 1–2 hours—showing you should pilot agents on high-impact workflows (e.g., contract processing, sponsor portals) to quantify benefits before broader rollout. Relevant tools: Claude Cowork, registration systems, automated promo-code generation.

  • 06

    Protect production-facing agents with regular security practices and clear guardrails.

    Significance: Deploying autonomous or semi-autonomous agents raises security and safety risks (leaked keys, rogue actions); use platform scans, periodic deep audits, and conservative guardrails to mitigate risk while enabling agent capabilities. Relevant practices/technologies: vendor security scans, monthly audits, constrained agent runtimes.

The episode outlines the operational foundations required to run reliable, cost-effective LLM-powered applications, focusing on observability, prompt management, and evaluation workflows. Aman Agarwal presents OpenLit's OTEL-first approach to convert opaque model interactions into stepwise traces, enabling debugging across models, tools, and data stores. He emphasizes common blind spots—runaway token costs, brittle prompt/secret handling, and lack of reproducible experiments—and shows how vendor-neutral standards and centralized collector management (OPAMP) reduce lock-in. The conversation also covers experimentation patterns (multi-model comparisons, routing), closing the loop from evals to prompt/dataset improvements, and trade-offs where OpenLit may not fit (proprietary stacks or hosted SaaS requirements).

Key Takeaways

  • 01

    Runaway token usage and cost are a major operational risk for LLM apps.

    Teams frequently underestimate token consumption, which can quickly blow up costs and make experiments expensive. Instrumenting and tracking token counts per request (and per model/provider) lets teams identify costly patterns and choose appropriate model routing or prompt engineering to reduce spend.

  • 02

    Observability and stepwise tracing are essential to understand and debug LLM behavior.

    Treating LLM interactions as traceable, stepwise workflows (logged with OpenTelemetry) turns black-box responses into debuggable artifacts, revealing which context, tools, or prompts led to outcomes. This enables root-cause analysis of hallucinations, latency spikes, or unexpected token usage and supports better design decisions from prototype to production.

  • 03

    Adopt vendor-neutral, open standards (OpenTelemetry / OPAMP) to avoid lock-in and enable flexible tooling.

    Emitting traces in OTEL format and managing collectors via OPAMP means any observability backend can consume the data, simplifying migrations and integrations. OpenLit's fleet-managed collectors and central hub illustrate how teams can switch exporters or filter traces without touching each host or app code.

  • 04

    Decouple prompt and secret management from application code for reliable, mutable production behavior.

    Hard-coding prompts or secrets into app logic makes iterative improvements and emergency fixes riskier and slower. Using centralized prompt/secret stores enables versioning, rollbacks, and safe mutations in production—improving reproducibility, security, and the ability to A/B prompts or route by version.

  • 05

    Close the loop with experimentation, automated evals, and routing to continuously improve models and prompts.

    Side-by-side comparisons (OpenGround), model routing metrics (cost/latency/quality), and LLM-assisted evals for hallucination, bias, and toxicity let teams quantify performance and prioritize fixes. Feeding evaluation results back into prompt/dataset changes or routing policies enables iterative, data-driven improvements rather than ad-hoc tinkering.

The episode is a deep dive into Factory's AI coding agent, Droid, emphasizing an enterprise-first approach with controls, ROI analytics, and multi-surface integrations. Eno Reyes demos building an app from meeting notes and contrasts 'spec mode' (what to build) with 'plan mode' (how to build it), showing how agents fit into real engineering workflows. The conversation covers model-agnostic strategies (mixing planners like Opus with executors like GPT-5.2), rigorous self-validation (linters, tests, screenshots) to raise output quality, and practical choices about skills, MCPs, and hooks. It also explores organizational implications: hiring 'product engineers' over traditional PMs, autonomy vs manual approval trade-offs, and how a small focused team competes with larger players in the AI coding space.

Key Takeaways

  • 01

    Enterprise-first design matters: Droid prioritizes controls, analytics, and integrations for large orgs.

    Factory built Droid to meet enterprise needs—air-gapped deployments, ROI dashboards, org-level skills, and codebase analysis—rather than consumer convenience alone. This matters because enterprises require governance, security, and measurable impact to adopt agent-driven development at scale, making features like audit trails and central skill management critical for adoption.

  • 02

    Use spec mode for 'what' and let agents plan 'how' in plan mode.

    Providing a clear specification (the desired outcome) while allowing the agent to generate the implementation plan reduces ambiguity and improves agent effectiveness. This separation helps teams keep product intent high-level while leveraging agents' planning abilities, which is especially useful when combining different models or toolchains for execution.

  • 03

    Model-agnostic workflows and mid-session model switching improve performance and cost-efficiency.

    Combining specialized models—e.g., using Opus for planning and GPT-5.2 for execution—can outperform single-model approaches and lets teams balance planning quality, execution fidelity, and expense. Model switching mid-session enables using cheaper or faster models where appropriate and higher-capacity models for critical steps, a practical technique for production-grade agent pipelines.

  • 04

    Rigorous self-validation (QA, linters, tests, screenshots) is crucial to trustworthy agent outputs.

    Droid emphasizes iterative validation—automated tests, screenshots, DevTools checks, logging and linting—so agents 'measure many times' rather than producing brittle outputs that require costly manual rework. Investing in validation tooling raises reliability for engineering teams and reduces the risk of shipping buggy or insecure code when agents act autonomously.

  • 05

    Organizational roles and tooling evolve: product engineers and centralized skills gain prominence.

    Factory prefers hiring 'product engineers' and expects many non-engine roles to operate through agents, while offering org-level skills and MCPs for shared customization. This shift matters because it changes hiring practices, team workflows, and who owns product decisions—implications that affect training, accountability, and how PM work gets codified into agent skills and PRD-generating tools.

Questions answered in this issue

What is the 90/10 rule and when should you break it?

The 90/10 rule is to buy 90% of needed functionality off the shelf and only build the 10% you can't find or that provides outsized value. You should break it when off‑the‑shelf tools are mediocre, lack AI entirely, or when a custom app directly impacts significant revenue or unique proprietary workflows (e.g., sponsor portal, AI VP of Marketing).

How did Claude Cowork change what Amelia could build?

Claude Cowork, running locally and able to inspect the browser, helped Amelia spec, ingest local contract data, and take actions — enabling her to complete the sponsor portal and automate contract processing much faster than before. It served both as an authoring assistant and as an execution aide when she got stuck on technical bits like SSO.

What are the main operational blind spots teams face when building LLM-powered apps?

Teams commonly face opaque model behavior (what context is used and how responses are formed), runaway token/cost usage, and brittle prompt management tied to code. Addressing these requires observability/tracing, cost tracking and decoupled prompt/secret management.

How does OpenLit help manage distributed OpenTelemetry collector configurations?

OpenLit provides a Fleet Hub using OPAMP to centrally manage multiple OTEL collector configs and exporters so teams can change where traces are sent without logging into each host or modifying app code. This simplifies switching observability backends and filtering traces.

What differentiates Droid from consumer-focused coding agents?

Droid focuses enterprise-first: enterprise controls, ROI analytics, the ability to run in air-gapped environments, and tooling to analyze whole company codebases — features prioritized for VPs of engineering and large organizations.

How does Droid ensure the quality of agent-produced code?

Droid integrates validation steps (screenshots, Chrome DevTools QA, console logging, linters, type checking, unit tests) and prompt caching/compaction to iteratively validate work, reducing costly rework and improving reliability.