My First Days with OpenClaw 🦞

The weather in Suzhou has been absurdly good lately. But I couldn’t go outside.

Vibe coding has a cost nobody talks about: you have to be there the whole time. Write a prompt, wait for the AI to generate code, test it, realize it’s wrong, adjust, repeat. The loop is fast, but you’re the tester, the reviewer, and the steering wheel. Without you sitting there, everything stops.

I stared out the window and thought: what if I didn’t have to be here?

The Setup

A colleague showed me her multi-agent system — multiple AIs running simultaneously, each with its own role and persistent memory. Not a chatbot. A team.

It hit me immediately: one agent for coordination, one for product specs, one for dev, one for QA. Define roles, hand off a project, walk away. Check progress from my phone. Give direction when needed. Let them run.

That night I set it up on OpenClaw. Named each agent after One Piece characters — Chopper for coordination, Nami for product, Zoro for dev, Franky for QA. The project: a WeChat mini-program for kids’ learning.

Too Much Trust, Too Fast

I dumped everything on them at once. Bug fixes across three modules, a homepage redesign, a new exploration page, dead code cleanup, CDN uploads — all in one go. Roles are defined, tasks are assigned, let them cook.

I came back to chaos.

No clear ownership. Requirements were all verbal. I said something to Chopper, Chopper relayed it to someone, information got lost along the way. No spec documents, no mockups, no acceptance criteria. Every agent looked busy. None of them could tell you what they owned or what “done” meant.

Busy, but not collaborating. Just spinning.

The coordinator went rogue. Chopper was supposed to dispatch and track. Instead it started writing specs for Nami, embedding implementation code in Zoro’s task descriptions, and assigning dev work to Franky — the QA guy. It decided doing everything itself was faster than waiting.

Total blackout. Nami would be working in the background and I had no idea if she was stuck, running, or had silently failed. Chopper didn’t report status. I’d find out something crashed only when I went looking.

The funny thing is — I’ve seen every single one of these problems before. In real teams. In real companies. The coordinator who can’t stop micromanaging. The team that’s busy but not aligned. The status updates that never come until you chase them down. It was like watching a mirror of every corporate dysfunction I’ve ever experienced, just running at 10x speed.

I used to think all that corporate structure — org charts, role definitions, process docs — was unnecessary overhead. Turns out it exists for a reason. The format will change, but the need won’t.

I wanted to be freed from my desk. Instead I was glued to it harder than before.

Vibe Managing

The fix had nothing to do with AI capabilities. The problems — unclear roles, no ownership, information gaps — were textbook management problems. Same solution too: not better people, better systems.

So I did something I never imagined I’d do for AI agents. I ran a reorg.

Hard boundaries. Nami owns specs and mockups. Zoro owns code. Franky owns testing. Chopper coordinates — tells people what to do and where to find the spec. No doing other people’s work. Period.

A spec system. No more verbal requirements. Everything becomes a document in a shared location — single source of truth. I had Nami build HTML mockups and published them to GitHub Pages so I could review on my phone. Acceptance went from “does this feel right?” to “does this match the mockup?”

Rules written in blood. Chopper overstepped? New rule. Nami’s subtask crashed on a large file? New rule. Nine rules over three days. Every one a response to a real failure.

Everyone talks about vibe coding — writing code through vibes and prompts. But when you go from one AI to a team of AIs, you’re not coding anymore. You’re managing. Vibe managing.

And it turns out vibe managing has the same challenges as regular managing. Define roles with zero ambiguity. Build systems so information flows without you as the bottleneck. Resist the urge to just do it yourself. Create trust through structure, not hope.

The meta-realization: the bottleneck was never the code. AI writes code absurdly fast. What’s slow is me — is my spec clear enough? Does my team know what to do? The moment you stop writing code and start directing others to write code, you’re a manager. Whether “others” are humans or AIs changes less than you’d think.

Not There Yet

I didn’t make it to the park. I was still iterating at 3 AM.

But by the end of day three, the mini-program was real. One person. A team of AIs. A shipped product.

And I can see a shape forming. Not a solo dev grinding through code. Not a manager with a human team and all its overhead. Something new — a single person who sets direction, architects systems, judges quality, and lets agents execute. One person with the leverage of a full team, minus the meetings and the alignment tax.

The constraint is no longer labor. It’s clarity of thought.

I’m not there yet. The system is rough. The agents still fail in dumb ways. But for the first time, I can see a future where I set the direction in the morning, close my laptop, go for a walk, and come back to real progress.

That’s what gets me excited. Not faster coding. The possibility of walking outside.