DEV Community: trycatchclaw

I Vibe-Coded an AI Agent Marketplace in One Week — Here's What I Learned

trycatchclaw — Thu, 26 Mar 2026 05:55:11 +0000

I spent a week vibe coding a side project and ran into some surprisingly interesting problems along the way. Figured it's worth sharing while it's still fresh.

Why I Built This

I've been building AI agents for a while now, and recently started using OpenClaw. If you browse GitHub, there are already tons of great agent projects out there — agencies, code reviewers, writing assistants, you name it. The ecosystem already has ClawHub as an official skill marketplace for lightweight tools, and it works well for that.

But something was missing — there's a skill marketplace, but where's the agent marketplace?

A complete agent isn't just a prompt. It has a persona definition (SOUL.md), tool configs, behavioral rules, onboarding flow — all of that packaged together is what makes an agent actually usable. But right now, sharing an agent still means dropping a GitHub link or pasting a prompt in Discord. You know how that goes.

I kept thinking: what if there was something like npm or Docker Hub, but for OpenClaw agents? Standardized packaging, one-command install, a central place to browse.

So I built CatchClaw.

The One-Week Vibe Coding Journal

"One week" is a bit misleading — it was more like a week of late nights after my day job. The whole process was basically me talking to AI, having it write code while I steered the direction and made the decisions. A few moments stood out:

1. "Fighting" ClawHub's Security Checks Was Fascinating

From the start, I decided to use a skill-based approach for installation — users install a CatchClaw skill, then just tell their agent in plain language: "search for a code review agent." No CLI commands to memorize.

But publishing a skill to ClawHub means passing its security review. And it's thorough — it scans for all kinds of edge cases. My workflow became: submit → get the review report → feed it to Claude → let Claude fix the issues → resubmit → get rejected again → repeat.

After several rounds, I had this weird realization — I was essentially watching one AI help me satisfy another AI's security requirements. It was agent-vs-agent, and I was just the middleman. When it finally passed, the satisfaction was real.

Side note: Claude Opus 4.6 at max effort is genuinely impressive. Even after multiple rounds of complex back-and-forth context, it barely lost any information.

2. Chose the Wrong Frontend Framework — Burned a Ton of Tokens Rewriting

This was my biggest mistake. When I started vibe coding, the AI scaffolded a Vite + React SPA. I didn't think twice and just went with it. By the time it was mostly built, I realized — it's a pure SPA. Zero SEO. A public-facing developer platform that Google can't index? What's the point?

So I bit the bullet and rewrote it in Next.js. Not just swapping the framework — the entire rendering strategy had to be redesigned: SSG for the homepage, SSR for the marketplace browse page, ISR with 60-second revalidation for agent detail pages. Basically rewrote the entire frontend. Burned a lot of tokens, but looking back it was absolutely the right call.

Lesson learned: if you're building a public-facing platform, think about SEO on day one. Don't ask me how I know.

3. Should I Add Paid Features? Decided Against It

At one point I considered adding a cloud hosting upsell for agents — a paid tier that creates a nice commercial loop.

But I talked myself out of it. The platform has a few hundred agents. The community is just getting started. User habits aren't formed yet. Rushing to monetize at this stage would just scare away the few users I do have.

Build the community first, polish the experience, figure out the rest later. Once I internalized that, a lot of feature decisions became much easier.

Where It's At Now

Tech stack:

Backend: Java 17 + Spring Boot + MySQL
Frontend: Next.js 15 + React 19 + Tailwind + Radix UI
CLI: Pure Node.js built-ins, zero dependencies, single file ~1300 lines
Deployment: One Docker image with both frontend and backend, supervisord manages processes

There are currently 288 agents on the platform, converted from popular open-source agent projects on GitHub into OpenClaw's standardized format using AI. Covers Engineering, Marketing, Data, and more.

To install: run clawhub install catchclaw to add the skill, then just talk to your agent in plain language. You can also visit the website and copy the install command directly from any agent's detail page.

What's Next

Agent composition: chain multiple agents into workflows
Pre-install preview: see what an agent can do before installing it
Version tracking: one line of prompt change can completely alter agent behavior — need to track that

Try It Out

If you're using OpenClaw or building AI agents:

Browse agents: catchclaw.me
GitHub: github.com/OpenAgentar/catchclaw — skill source is fully open, PRs welcome
Quick install: clawhub install catchclaw

Find a ready-made agent, or publish your own for others to discover — it's all free.

Why the OpenClaw Ecosystem Needs an Agent Sharing Platform

trycatchclaw — Wed, 25 Mar 2026 03:45:57 +0000

You built a great Agent. Now what?

Over the past year, the barrier to building AI agents has dropped dramatically. From Claude's tool use to OpenAI's function calling, from LangChain to CrewAI — creating a working agent is no longer a rare skill.

But one problem remains stubbornly unsolved: once you've built an agent, how do you get it into other people's hands?

This isn't a minor inconvenience. It directly determines whether the agent ecosystem can truly flourish.

The current state of agent distribution: a mess

If you want to share an agent today, you're probably looking at one of these scenarios:

Scenario 1: Drop a GitHub link. The recipient needs to clone the repo, install dependencies, configure environment variables, set up API keys… then hits a Python version conflict and gives up.

Scenario 2: Share a raw prompt. No structured metadata, no version control. A month later, four variants are floating around in different Slack channels and nobody knows which one is current.

Scenario 3: Record a demo video. Looks impressive, but nobody can reproduce your workflow. The agent's value is trapped on your local machine.

The common thread: there's no standardized way to package, distribute, and install agents.

Compare this with npm for JavaScript, pip for Python, or Docker Hub for container images. Every successful technology ecosystem has a solid package management and distribution layer. The agent ecosystem doesn't — not yet.

This goes deeper than convenience

The absence of a distribution platform has consequences far beyond "it's annoying":

1. Duplicated effort everywhere

You built an agent that analyzes GitHub issues and suggests fixes. So did I. So did someone in another timezone. Our work overlaps heavily, but because there's no way to discover each other's agents, we all reinvent the wheel in isolation.

2. Quality can't be filtered

Without a unified platform, there's no rating system. A battle-tested agent that handles edge cases gracefully looks the same in the distribution chain as a weekend hackathon prototype.

3. Composability is blocked

The real power of agents lies in composition — a code review agent plus a documentation agent plus a test generation agent can form a complete development workflow. But if every agent is an island, that composition never happens.

4. Developer work goes unrecognized

Building a good agent requires serious prompt engineering, tool orchestration, and edge case handling. Without a place to showcase that work, developers lack the motivation to keep investing. Open source has taught us: visibility is the core fuel of contribution.

What should an agent sharing platform look like?

Based on the above, a viable agent platform needs at least these properties:

Standardized packaging

An agent isn't a bare prompt. It should have structured metadata — name, description, capability declarations, tool dependencies — plus a version number and a machine-readable install manifest. Just as an npm package has package.json, an agent needs its own manifest.

One-command install

No manual cloning. No environment setup. No three-page README. Install and go.

Say you need a code review agent. If you're using OpenClaw, first install the CatchClaw skill:

clawhub install catchclaw

Then just tell your agent in plain language:

"Search for a code review agentar"

Your agent handles the search through the CatchClaw skill automatically:

Found what you need? Just say:

"Install code-reviewer, name it my-reviewer"

After installation, you get a complete agent workspace with structured files — persona definition (SOUL.md), tool configuration (TOOLS.md), onboarding flow (BOOTSTRAP.md), and more:

Open SOUL.md and you'll see that this agent's behavioral rules are structured, auditable, and editable — not an opaque black-box prompt:

## 🧠 Your Identity & Memory
- **Role**: Code review and quality assurance specialist
- **Personality**: Constructive, thorough, educational, respectful

## 🔧 Critical Rules
1. **Be specific** — "This could cause an SQL injection on line 42"
   not "security issue"
2. **Explain why** — Don't just say what to change, explain the reasoning
3. **Suggest, don't demand** — "Consider using X because Y"
4. **Prioritize** — Mark issues as 🔴 blocker, 🟡 suggestion, 💭 nit
5. **Praise good code** — Call out clever solutions and clean patterns

You don't need to memorize any CLI commands — your agent handles it for you. That's what standardized distribution should feel like.

Discoverability

Browse by category, search by keyword, sort by usage. Developers should find what they need through structure, not through social media algorithms.

Trust signals

Download counts, user ratings, developer verification. Help users distinguish "proven tool" from "experimental project."

Open, not locked in

The platform shouldn't be tied to a single LLM or framework. A good agent should work across environments — in Claude Code today, potentially in other AI development environments tomorrow.

CatchClaw: our attempt at this

This is why we're building CatchClaw.

CatchClaw is the agent marketplace for the OpenClaw ecosystem. It tackles the problems outlined above:

Agentar format — a standardized agent packaging spec with metadata, persona definitions, skill declarations, and install support
Skill-driven install — install the CatchClaw skill via ClawHub (clawhub install catchclaw), then your agent can search, install, and export using natural language — no CLI commands to memorize
Skill system — beyond full agents (agentars), lightweight Skills serve as composable capability modules any agent can call
Public marketplace — all published agents and skills are browsable and searchable on the web

In the marketplace, you can browse all published agents by category — Engineering, Marketing, Data, and more:

Click into any agent to see detailed capability descriptions, file structure preview, ratings, and user reviews:

We don't claim this is the only right approach. Agent distribution is important and complex enough to warrant exploration from the entire community. CatchClaw is one answer we're offering — and it's just the beginning.

Practical advice for agent developers

Regardless of which platform you use, these practices are worth adopting:

Write metadata for your agent. Name, description, capability boundaries, dependency list. Even if it's just so you can understand your own work six months from now.
Version your agents. Agent behavior changes with every prompt tweak. Track those changes.
Declare what your agent can't do. Capability boundaries matter more than capability claims — they help users set correct expectations.
Design for composability. Build your agent as a module that can collaborate with others, not as a monolithic black box.

Closing thought

Agent development is being democratized, but agent distribution is still in the artisan era. If this gap isn't closed, we'll remain stuck in a world where everyone builds wheels but nobody stands on each other's shoulders.

A good sharing platform isn't just a tool — it's ecosystem infrastructure. npm didn't invent JavaScript. Docker Hub didn't invent containers. But they made their ecosystems come alive.

The agent ecosystem needs its own version of that moment.

Curious to explore or publish your own agents? Check out CatchClaw. Contributions to the OpenClaw ecosystem on GitHub are also welcome.