Building an OpenClaw Skill in 2 Hours: From Zero to Lead Pipeline

I needed a CRM. Not a fancy one—just something to track consulting leads, store outreach drafts, and flag which ones were ready to send.

The obvious path: sign up for HubSpot, spend a week configuring it, pay $50/month.

The Agentic-First path: build exactly what I need in an afternoon.

I chose the second option. Here's what happened.

Why OpenClaw

I'll be honest: I got caught up in the hype. And I'm glad I did.

In late January, I was out for a run listening to This Week in Startups. Jason Calacanis was five days into using OpenClaw and already calling it "an inflection point in AI history." He had power users on the show — people automating tea shops, building news bots, running one-person SaaS startups with an AI assistant doing the heavy lifting. The episode was electric. I signed up that night.

Jason wasn't wrong. He's gone even deeper since — subsequent episodes covered giving OpenClaw eyes via Meta Ray-Bans and killing startup knowledge chaos with OpenClaw skills. The community around it is moving fast.

What made OpenClaw the right choice for me specifically: it's open source, it runs in Docker (so I control my data), and the skill system is dead simple — just markdown and shell scripts. No SDK to learn. No framework lock-in. If I can describe what I want and write a bash command, I can extend my AI assistant. That matched exactly how I wanted to work.

The Problem

I've been running OpenClaw as my personal AI assistant. It's powerful—it can search for leads, research companies, draft outreach. But it had one glaring gap: no native Google Sheets integration.

Every time I found a promising lead, I'd have to manually copy it somewhere. The agent couldn't track what it found. It couldn't update statuses. It couldn't tell me what was pending.

I searched for an existing skill. Nothing.

So I built one.

The Build

Total time: ~2 hours

API costs: ~$3

Here's what I created:

• A gsheets CLI tool that handles auth, reading, writing, searching
• A SKILL.md that teaches OpenClaw how to use it
• Full CRUD operations: create sheets, append rows, find by column, update records
• OAuth flow that works in a headless Docker environment

The skill does exactly what I need:

gsheets create "Lead Pipeline"
gsheets append <id> "Sheet1" '["Acme Corp","John","CTO","LinkedIn","New"]'
gsheets find-row <id> "Sheet1" "Company" "Acme"
gsheets update-row <id> "Sheet1" 5 '["Acme Corp","John","CTO","LinkedIn","Contacted"]'

Now OpenClaw can manage my entire lead pipeline autonomously.

Under the Hood: Core Integration Logic

The heart of the skill is surprisingly simple. Here's the core function that appends a lead to the pipeline — the operation that runs dozens of times a day:

async function appendRow(spreadsheetId, sheetName, values) {
  const auth = await getAuthClient();
  const sheets = google.sheets({ version: 'v4', auth });

  const response = await sheets.spreadsheets.values.append({
    spreadsheetId,
    range: `${sheetName}!A:A`,
    valueInputOption: 'USER_ENTERED',
    requestBody: {
      values: [values],
    },
  });

  return {
    updatedRange: response.data.updates.updatedRange,
    updatedRows: response.data.updates.updatedRows,
  };
}

And the find-by-column function that powers the "show me pending leads" query:

async function findRow(spreadsheetId, sheetName, columnName, searchValue) {
  const auth = await getAuthClient();
  const sheets = google.sheets({ version: 'v4', auth });

  const response = await sheets.spreadsheets.values.get({
    spreadsheetId,
    range: sheetName,
  });

  const rows = response.data.values || [];
  const headers = rows[0] || [];
  const colIndex = headers.indexOf(columnName);

  if (colIndex === -1) return [];

  return rows
    .map((row, i) => ({ row, index: i + 1 }))
    .filter(({ row }) => row[colIndex] === searchValue);
}

That's it. Two functions, standard Google Sheets API, no magic. The power isn't in the code — it's in the SKILL.md that teaches OpenClaw when and how to call these functions autonomously.

Zero to Lead Pipeline: How the Data Flows

Here's the full data flow from source to spreadsheet:

The key insight: steps 1-5 happen autonomously. I don't touch anything until step 6 — a WhatsApp notification asking me to review. The agent does the work; I make the judgment calls.

The Workflow

Here's what my lead gen process looks like now:

1. OpenClaw scans for opportunities

• Checks job boards for "Fractional CTO" postings
• Monitors HN, LinkedIn, funding announcements
• Filters for signals that match my services

2. When it finds a match, it adds to the pipeline

3. I review and approve via WhatsApp

Me: "show me pending leads"
OpenClaw: "3 leads pending approval: 9am, TechCorp, BuildFast"

Me: "approve 9am"
OpenClaw: "✓ 9am approved. Say 'send 9am' when ready."

4. OpenClaw executes approved outreach

The agent only sends when I explicitly approve. Full control, zero manual data entry.

Why This Matters

This isn't about saving 2 hours on a Google Sheets integration.

It's about a fundamentally different way to build software.

Traditional approach:

1. Define requirements (2 hours)
2. Research libraries (1 hour)
3. Set up project (30 min)
4. Write code (4-8 hours)
5. Debug OAuth flow (2 hours of frustration)
6. Test (1 hour)
7. Document (1 hour)

Total: 12-16 hours over multiple days

Agentic-First approach:

1. Describe what I need to Claude
2. Review and iterate on generated code
3. Test
4. Ship

Total: 2 hours in a single session

The difference isn't just speed. It's cognitive load.

I didn't have to context-switch between Stack Overflow tabs. I didn't debug a cryptic OAuth error at 11pm. I described the problem, the agent generated solutions, I picked the best one.

The Code Quality Question

"But is the code any good?"

Yes. Here's why:

1. It works. That's the first bar, and it clears it.

2. It's readable. Claude generates clean, well-commented code. Better than most Stack Overflow copypasta.

3. It does exactly what I need. No bloat. No features I'll never use. No abstraction astronautics.

4. I understand it. I reviewed every line. I can maintain it. I can extend it.

Is it perfect? No. Would a senior engineer write it differently? Probably. Does that matter for a personal tool that took 2 hours? Absolutely not.

What I Learned

1. Skills are just markdown + scripts

OpenClaw skills aren't complicated. A SKILL.md file that describes capabilities, and scripts that execute them. That's it. The barrier to extending your AI assistant is remarkably low.

2. The agent handles the tedious parts

OAuth flows, API boilerplate, CLI argument parsing—these are solved problems. Let the agent write them. Save your brainpower for the interesting decisions.

3. Build for your workflow, not "best practices"

I didn't need a robust multi-tenant SaaS. I needed my lead pipeline. Agentic-First Development excels at building exactly what you need, not what some framework assumes you need.

4. The meta-layer is powerful

I now have an AI that can autonomously manage another tool (Google Sheets) to track the output of yet another autonomous process (lead generation). The compounding effects are real.

What's Next

I'm open-sourcing this skill. If you're running OpenClaw and want Google Sheets integration, it's yours.

More importantly: this is how I build everything now.

Need a feature? Describe it. Review the output. Ship it.

The 10x productivity isn't hype. It's Tuesday afternoon.

---

Building software with AI agents isn't about replacing developers. It's about removing the friction between "I need this" and "I have this."

If you're a founder or CTO interested in implementing Agentic-First Development at your company, let's talk.