Riley Brown thumbnail

đź“ť Riley Brown Blog

Why Narrow AI Agents Are the Future: Lessons from Building Hundreds of Workflows

Over the past two weeks, I’ve been deep in the trenches, building hundreds of AI agent workflows using tools like OpenClaw, Manisclaw Code, and the recently launched Perplexity Computer. This hands-on experimentation has led me to a key insight about the future of AI agents in business: narrow AI agents operating as a coordinated team will outperform broad, generalized AI agents. In this post, I’ll share why I believe this is the case, explain how OpenClaw fits into this vision, and outline the strategy I’m adopting to build a suite of focused AI agents to run the entire growth division at vibco.dev.

Exploring the AI Agent Landscape: Perplexity Computer, Manis, and OpenClaw

Perplexity Computer and Manis: AI Agents with Cloud Computers

Perplexity Computer and Manis are fascinating because they provide each AI task with its own cloud-based “computer.” You input a task, and the AI spins up a sandboxed cloud environment to execute it — creating files, editing, and running processes autonomously. Think of it as a command center where each task has its own workspace.

While this architecture is powerful for certain use cases, it requires you to proactively manage and communicate with the command center. This model can feel less like having a helpful employee and more like running a complex machine that needs constant supervision.

OpenClaw: A Single AI Agent with Structured Skills and Memory

OpenClaw takes a different approach by running a single AI agent on one computer, with robust memory and structured, clearly defined skills. This agent integrates seamlessly into everyday communication tools like Telegram, WhatsApp, Discord, and Slack, making it accessible and easy to interact with.

OpenClaw’s strength lies in its ability to connect with your existing apps and workflows, providing a more natural and proactive AI assistant experience without fragmenting tasks across multiple ephemeral cloud computers.

The Pitfalls of Overloading AI Agents with Too Many Skills

In my initial OpenClaw agent build, I loaded it with a broad array of skills — social media transcript analysis, Google Workspace control, project management via Linear, Figma manipulation, media generation, and even video editing. While this “super agent” could do many things, it quickly became less dependable:

  • The agent struggled to prioritize and use the right integrations at the right time.
  • Its personality and decision-making became inconsistent.
  • Context became muddled, reducing effectiveness.

The takeaway? There is a sweet spot of about 7-10 skills per AI agent. Beyond that, performance and reliability degrade. This pushed me to rethink the model toward multiple narrow agents, each with a focused skillset and clear purpose.

Why People Want an AI “Employee” — Not Just a Tool

People want AI that acts like a reliable employee — someone who not only gets things done but can also surprise you with useful suggestions and proactively make decisions aligned with clear goals. This requires giving AI agents intent or purpose.

As EMTT Shear, interim CEO of OpenAI once said, “Prompts are so late 2025. We are giving models intents now.” Moving beyond just prompting AI to truly giving agents specific, measurable goals is a game-changer.

Broad, generalist agents without clear intent struggle to focus and deliver meaningful results. Narrow agents with defined objectives are better positioned to act autonomously and effectively.

Testing Narrow AI Agents – The Power of Focus

After two weeks of running multiple AI agents in Telegram and other platforms, the evidence is clear: focused agents with specific personalities, goals, and “heartbeats” perform better.

For example, my favorite agent is the YouTube AI agent, which focuses exclusively on creating YouTube videos. It operates with three clear goals:

  • Increase subscribers
  • Increase views
  • Increase conversions

Because its goals are narrow, the YouTube agent only uses relevant skills like YouTube research (powered by SER API and Supera Data for scraping transcripts), thumbnail generation (using Nano Banana with photos of me), and Notion integration (where all scripts are stored).

This focused approach makes it easy to add or remove skills based on whether they help achieve the agent’s goals, keeping it efficient and effective.

Building a Team of Narrow AI Agents: Benefits and Strategy

Why Narrow Agents?

  1. Easy to Duplicate and Remix: A proven YouTube agent can be repurposed to create a TikTok agent or a Substack agent without the complexity of a massive multi-skill agent.

  2. Simple to Share with Teams: Narrow agents with limited skills are easier for others to understand, duplicate, and customize.

  3. Clear Accountability: With specific KPIs (like open rates, conversions, views), it’s easy to evaluate whether an agent is succeeding or failing and make data-driven decisions to keep or cut it.

  4. Autonomous Loops: Narrow agents can operate on simple, predictable task loops (cron jobs), enhancing autonomy and reducing the need for constant human oversight.

Example: The Journal Agent

Another agent I built is the Journal Agent, which proactively checks in every 30 minutes to analyze meetings, videos, and activities, writing detailed journal entries in Notion. This agent informs other agents — for example, the Email Newsletter agent reads the journal to generate relevant content for our 300,000 subscribers.

Because each agent has a narrow focus and defined goal, collaboration between agents mimics a real human team, with clear roles and communication channels.

Looking Ahead: The Future of AI Agent Teams

I’m committed to building at least 15 high-quality narrow AI agents that together run the growth division at vibco.dev. While tools like Perplexity and Manis pioneered giving AI agents access to cloud computers, I believe the future lies in running OpenClaw-like agents on persistent cloud computers with:

  • Efficient resource management to run hundreds of agents
  • Seamless sharing and onboarding for team members
  • Intelligent memory-sharing and communication between agents to simulate team collaboration

This approach will unlock a new paradigm of AI-powered teams where specialized agents work together, just like a well-oiled human team, to drive business goals forward.

Final Thoughts

The AI agent space is rapidly evolving, but my experiments reinforce one key truth: narrow, goal-driven AI agents operating as a coordinated team will be the most valuable and effective tools in the near future.

If you’re building AI workflows or thinking about AI adoption in your business, focus on creating agents with specific intents and limited, relevant skillsets. Build teams of these agents that can communicate and collaborate to achieve complex outcomes.

I’ll be sharing more insights and tutorials on how to build and manage these AI agent teams in upcoming posts — stay tuned!

About the Author

[Your Name] is the founder of vibco.dev, where they lead AI-driven growth initiatives using cutting-edge AI agent workflows. Passionate about combining AI and productivity, they share hands-on experiments and strategies for leveraging AI in business.

Interested in building your own narrow AI agents? Follow along for detailed guides, tool recommendations, and real-world case studies to help you unlock the full potential of AI in your workflow!

🎥 We Made Claude Code Build Lovable in 75 Minutes (With No Code)

⏱️ Duration: 83:00
đź”— Watch on YouTube

đź“š Video Chapters (16 chapters):

Overview

This video provides a step-by-step walkthrough of building a "Lovable" clone—a
website that builds websites—using Claude Code and its SDK, with a focus on
“vibe coding” (rapid, AI-powered development). Across 16 chapters, the
presenters demonstrate every stage: from setting up Claude Code, to integrating
its SDK, to handling complex infrastructure like isolated code execution
environments, culminating in a functional clone that mirrors the features of
Lovable. The chapters build sequentially, each introducing new technical and
conceptual challenges, and together illustrate both the power and current
limitations of AI-driven coding tools.

Chapter-by-Chapter Deep Dive

Introduction & Setup (00:00)

Core Concepts:
The video sets the stage by introducing Claude Code as a potentially superior
alternative to Cursor for AI-assisted coding. Khan Zang, an expert in AI coding
tools, will attempt to build a full application—a Lovable clone—using Claude
Code in one session.

Key Insights:
- Claude Code is being tested for end-to-end application development.
- The main goal is to see if it can autonomously build a web app.

Actionable Advice:
- The viewer will learn how to set up Claude Code and use its SDK.

Connection to Overall Theme:
Establishes the challenge and outlines the journey: using Claude Code to build a
real product from scratch.

Explaining Claude Code and SDK (00:31)

Core Concepts:
An in-depth explanation of what Claude Code is: an AI coding assistant that
operates via the command line interface (CLI), distinct from cursor-based tools.

Key Insights:
- Claude Code is designed primarily for coding, unlike generalist LLMs.
- Developers can build wrappers (custom interfaces/tools) using the Claude Code SDK.

Actionable Advice:
- Opportunities exist to develop and monetize wrappers around Claude Code, similar to ChatGPT wrappers.

Connection to Overall Theme:
Frames Claude Code as both a developer tool and a foundation for building more
complex coding agents.

Starting the Lovable Clone Build (02:11)

Core Concepts:
The project begins with setting up a fresh environment in Cursor for the Lovable
clone, using Claude Code.

Key Insights:
- Claude Code can proactively start building based on file/project names.
- The tool is eager—sometimes overly so—requiring user intervention to control.

Actionable Advice:
- Set up a standard development environment and learn to manage Claude Code’s auto-initiated actions.

Examples:
- Claude Code recognized the "lovable clone" project name and began suggesting full-stack scaffolding.

Connection:
Initiates the hands-on experiment, highlighting the tool’s capabilities and
quirks.

Memory and Configuration Setup (04:04)

Core Concepts:
Explains project vs. user memory in Claude Code, introducing markdown-based
memory storage that informs the AI’s context.

Key Insights:
- Project memory enables persistent context for specific tasks, improving coherence.
- Proper configuration is critical for controlling Claude Code’s actions and permissions.

Actionable Advice:
- Use project memory for project-specific instructions.
- Use user memory for global, recurring preferences.

Connection:
Demonstrates best practices in context management—a recurring theme for
effective AI code generation.

Using Plan Mode and SDK Docs (05:51)

Core Concepts:
Leverages “plan mode” to guide Claude Code using documentation and structured
prompts.

Key Insights:
- Claude Code can use online resources but needs direction.
- Scoping tasks (breaking them down) improves outcomes.

Actionable Advice:
- Direct Claude Code to focus on SDK-based code generation.
- Limit project scope to manageable chunks.

Examples:
- Feeding the Claude Code SDK documentation to the tool and specifying backend-oriented objectives.

Connection:
Highlights the importance of guiding AI tools with clear scope and resources.

Generating a Simple Function (07:00)

Core Concepts:
Tasking Claude Code to generate a basic function: accept a prompt and generate
code accordingly.

Key Insights:
- Simplicity in requirements yields more predictable AI outputs.
- Permissions and configuration remain central.

Actionable Advice:
- Request raw code snippets rather than complex, multi-step outputs.

Examples:
- Requesting a simple TypeScript function that takes a prompt and interacts with Claude Code SDK.

Connection:
Demonstrates iterative, lean development with AI assistance.

Executing with Claude Code (09:00)

Core Concepts:
Runs the generated function, focusing on backend execution before UI
development.

Key Insights:
- Claude Code’s knowledge of its own SDK is imperfect; online research fills gaps.
- AI-generated pseudocode needs human review and iterative refinement.

Actionable Advice:
- Test simple functions in isolation before integrating into a larger app.

Connection:
Continues the foundational, backend-first approach—building and validating
codegen logic.

Building a Tic Tac Toe Game (11:00)

Core Concepts:
Tests the code generation function by prompting it to build a simple tic-tac-toe
HTML game.

Key Insights:
- Permissions and file-writing issues can block progress.
- Real-time feedback and iterative debugging are essential.

Actionable Advice:
- Isolate risky code generation (discusses Docker and containers).
- Use HTML for quick, low-overhead prototyping.

Examples:
- Successfully generates and plays tic-tac-toe, validating core functionality.

Connection:
First tangible proof that the codegen loop works, setting the stage for more
complex integration.

Front-End UI Build for Lovable Clone (16:33)

Core Concepts:
Moves from backend logic to frontend development, aiming to replicate Lovable’s
UI.

Key Insights:
- Claude Code can use image inputs (screenshots) for UI cloning.
- Prompt specificity (e.g., gradients, button icons) improves UI fidelity.

Actionable Advice:
- Provide visual references and detailed UI requirements to the AI.
- Iterate on design elements through targeted prompts.

Connection:
Bridges backend codegen with user-facing interfaces, emphasizing full-stack
workflows.

Connecting Front-End with Backend Function (21:24)

Core Concepts:
Integrates the front end with the backend function, enabling prompt-driven code
generation from the UI.

Key Insights:
- API routes connect UI input to codegen logic.
- Real-time feedback and message display are important for UX.

Actionable Advice:
- Modularize code for easier integration.
- Use long-term memory for recurring process instructions (e.g., dev server management).

Examples:
- Successfully generates a Connect 4 game, but notes file organization and scaling challenges.

Connection:
Completes the first end-to-end loop, highlighting integration challenges and UX
considerations.

Scaling & Issues with Local Code Writes (26:01)

Core Concepts:
Discusses the risks and limitations of letting AI write code directly to the
project’s local file system.

Key Insights:
- Security and scalability are concerns: generated code could overwrite or corrupt the main codebase.
- Positive reinforcement helps guide Claude Code’s behavior.

Actionable Advice:
- Consider real-time logging and friendlier message rendering.
- Plan to isolate generated code (containers, sandboxes).

Connection:
Transitions from basic prototyping to thinking about production-grade
architecture.

Creating Isolated Bubbles with Daytona (30:04)

Core Concepts:
Introduces the concept of "bubbles"—isolated execution environments for safe
code generation, leveraging external services like Daytona and E2B.

Key Insights:
- Isolated sandboxes prevent main codebase corruption.
- Providers like Daytona offer ready-made solutions for “bubbles.”

Actionable Advice:
- Use third-party isolated environments for user-generated code.
- Research and select tools based on documentation and integration capabilities.

Connection:
Marks a shift toward advanced infrastructure, essential for scaling and
security.

Debugging & Testing Bubbles (34:24)

Core Concepts:
Attempts to set up and debug isolated environments using Daytona, focusing on
clear task definition and prompt engineering.

Key Insights:
- Effective prompt engineering requires specifying both immediate and long-term goals.
- Human oversight is necessary: AI can get stuck or misinterpret documentation.

Actionable Advice:
- Scope tasks carefully for the AI.
- Use pseudo/real code plans to validate AI understanding.

Connection:
Demonstrates the interplay of AI autonomy and human-in-the-loop debugging.

Test Execution in Daytona Sandbox (42:48)

Core Concepts:
Executes and validates the sandboxed code generation process, iteratively
debugging failures.

Key Insights:
- Testing in isolated environments surfaces new challenges (e.g., permissions, networking, previewing).
- AI may require manual intervention and additional documentation.

Actionable Advice:
- Validate every step (e.g., can you preview the generated site?).
- Use logs, SSH, and manual checks to supplement AI outputs.

Connection:
Continues the theme of iterative, multi-layered debugging and validation.

All Components Working Together (52:32)

Core Concepts:
Successfully integrates all components: a front end, backend codegen logic, and
isolated execution environments.

Key Insights:
- Achieving full integration requires both AI and human-driven problem solving.
- Context management (updating AI memory) is crucial for complex projects.

Actionable Advice:
- Continually update project memory and documentation for AI context.
- Run and test the integrated pipeline before deploying.

Connection:
Represents the culmination of the build: a functional, safe, and modular Lovable
clone.

The Big Reveal & Testing (54:17)

Core Concepts:
Final demonstration and testing of the Lovable clone; side-by-side comparison
with the original Lovable.

Key Insights:
- The AI-built clone is impressively close to the original in both function and appearance.
- Most issues stemmed from context or documentation gaps, not AI capability.
- Human skills in guiding LLMs and navigating docs remain critical.

Actionable Advice:
- Test various use cases (blogs, image tools, link trees) to validate robustness.
- Plan to open source the code for community testing.

Connection:
Delivers on the initial promise: an AI-powered, end-to-end developed clone,
built in two hours with minimal manual coding.

Cross-Chapter Synthesis

Recurring Themes:
- Iterative Development: Each chapter builds on the previous, moving from backend logic to UI, integration, scaling, and advanced infrastructure.
- Prompt Engineering & Context Management: Effective use of Claude Code requires clear, scoped instructions and ongoing context updates (Ch. 4, 5, 12, 13).
- Human in the Loop: Despite AI’s power, human oversight, debugging, and documentation remain essential (Ch. 7, 13, 14).
- Isolation for Safety: Transition from local file writes to isolated sandboxes is crucial for production-ready AI codegen (Ch. 11, 12).
- Testing & Validation: Continuous testing at every stage prevents compounding errors and ensures functional integration.

Progressive Learning Path

  1. Tool Introduction: Understand Claude Code’s value proposition and setup (Chs. 1–2).
  2. Foundational Skills: Learn context management and SDK basics (Chs. 3–5).
  3. Backend Prototyping: Build and test simple codegen functions (Chs. 6–7).
  4. Proof of Concept: Validate functionality with simple projects
    (tic-tac-toe) (Ch. 8).
  5. UI Integration: Transition to building and refining the front end (Ch.
    9).
  6. Full-Stack Integration: Connect frontend and backend, test user flows
    (Ch. 10).
  7. Scaling Considerations: Address safety, scalability, and code
    organization (Ch. 11).
  8. Advanced Infrastructure: Implement isolated execution with third-party
    tools (Chs. 12–14).
  9. Comprehensive Testing: Debug, validate, and synthesize all components
    (Chs. 15–16).
  10. Final Reflection: Evaluate successes, limitations, and next steps.

Key Takeaways & Insights

  • AI coding tools are powerful but require human guidance. (Chs. 7, 13)
  • Context management is critical: Use project/user memory and continually update AI context. (Ch. 4, 15)
  • Start small and iterate: Simple, scoped tasks yield better results. (Ch. 6)
  • Isolate codegen for safety: Use sandboxes/containers to prevent codebase corruption. (Chs. 11–12)
  • Prompt engineering is an evolving skill: Be explicit about both current and end goals. (Ch. 13)
  • AI’s knowledge of new tools may lag: Supplement with documentation and manual research. (Ch. 7, 14)
  • Testing at every stage is essential: Validates assumptions and uncovers hidden issues. (Chs. 8, 14, 16)
  • Positive reinforcement steers AI behavior. (Ch. 11)
  • Open sourcing and community feedback can drive further improvements. (Ch. 16)

Actionable Strategies by Chapter

  • Ch. 2: Develop wrappers using the Claude Code SDK to extend its utility.
  • Ch. 4: Use project memory for task-specific context; user memory for global preferences.
  • Ch. 5: Feed relevant documentation and use plan mode for scoped, research-driven tasks.
  • Ch. 6: Request minimal, standalone code for clarity and testability.
  • Ch. 8, 10: Validate each module (backend, frontend, integration) before proceeding.
  • Ch. 11: Start considering containerization early for security and scalability.
  • Ch. 12: Research and leverage third-party sandbox providers (Daytona, E2B).
  • Ch. 13: Scope prompts tightly and clarify both immediate and long-term objectives.
  • Ch. 14: Combine AI-generated plans with manual debugging and SSH access.
  • Ch. 15: Update project memory and documentation to maintain context.
  • Ch. 16: Test a variety of outputs and compare against reference implementations.

Warnings & Common Mistakes

  • Letting AI write directly to the main codebase is risky. (Ch. 11)
  • Insufficient permissions/configuration can block functionality. (Ch. 8)
  • AI may not be current on new SDK/tooling—always supplement with docs/manual research. (Ch. 7, 14)
  • Assuming AI knows the end goal without explicit context leads to errors. (Ch. 13)
  • Overly broad prompts can result in confusion or suboptimal code. (Ch. 13)
  • Not testing each component in isolation compounds debugging challenges. (Chs. 8, 14)

Resources & Next Steps

  • Ch. 2, 5: Claude Code SDK documentation (searchable via Google).
  • Ch. 12, 13: Daytona (https://www.daytona.io/) and E2B (https://e2b.dev/) docs for isolated environments.
  • Ch. 15: Use markdown files and persistent memory in Claude Code for ongoing project context.
  • Ch. 16: GitHub repo (to be shared in video description) for the finished Lovable clone.
  • Next Steps:
  • Explore advanced prompt engineering to further streamline AI-assisted coding.
  • Experiment with other isolated environment providers.
  • Contribute to or fork the open-sourced Lovable clone.
  • Continue refining integration and UX for production readiness.

This comprehensive summary distills each chapter’s key contributions, highlights
cross-cutting themes, and provides a clear, actionable blueprint for viewers
inspired to emulate or extend the project.