DEV Community: bnspopi

I Tried Installing OpenClaw on Windows in an Hour. Here's What Actually Happened.

bnspopi — Mon, 20 Apr 2026 08:02:33 +0000

This is a submission for the OpenClaw Writing Challenge

This is a submission for the OpenClaw Challenge — Wealth of Knowledge prompt.

I saw the OpenClaw Challenge on DEV yesterday and decided to give it an hour. I'm a CS student on Windows, no prior Claude Code experience, currently in placement season and desperate for anything that triages my inbox. Spoiler: I did not get a working Gmail triage in an hour. But I learned enough about how OpenClaw works that I think it's worth writing down — especially for other Windows-first students who'll hit the same walls.

This isn't a success story. It's the honest first-hour walkthrough I wish I'd found before starting.

What OpenClaw actually is

OpenClaw is a personal agent framework. You install it, give it "skills" (Markdown files that describe what it should do and when), and it uses an LLM to reason through tasks. The pitch that pulled me in: a skill is just a SKILL.md file. No code, no deploy, no API gymnastics. You write Markdown, the model handles the rest.

That pitch is true. But getting to the point where you can actually write and run a skill takes more setup than the DEV announcement suggests — at least on Windows.

The install

I opened PowerShell and ran:

iwr -useb https://openclaw.ai/install.ps1 | iex
~~~{% endraw %}

It worked. I got a welcome banner and a nice lobster ASCII logo. The installer did catch that I was on Windows and showed this:

> Windows detected — OpenClaw runs great on WSL2!
> Native Windows might be trickier.
> Quick setup: {% raw %}`wsl --install`{% endraw %} (one command, one reboot)

I missed this warning. Pushed past it. In hindsight: read the warning. If you're reading this post and you're on Windows, **install WSL first.** The rest of this story is partly a case study in what happens when you don't.

## The dependency I didn't know about

I got to the auth step and hit:{% raw %}

Error: Claude CLI is not authenticated on this host.
Run claude auth login first, then re-run this setup.


This surprised me. I hadn't realized **OpenClaw uses Claude Code as its LLM backend**. Claude Code is Anthropic's own terminal CLI, and it's a separate install with its own auth flow. So before I could use OpenClaw, I had to:

1. Install Claude Code: {% raw %}`irm https://claude.ai/install.ps1 | iex`
2. Run `claude` and log in via browser (requires a paid Claude plan — Pro, Max, Team, or Console credits)

I already had Claude Pro from doing coursework, so this wasn't a blocker. But if you don't have a paid Claude account, **you can't use OpenClaw this way.** That's a real gate nobody mentioned in the challenge announcement.

Worth knowing up front.

## Setup finished — then broke again

After Claude Code was logged in, I re-ran `openclaw setup`. It finished cleanly:

Wrote ~/.openclaw/openclaw.json
Workspace OK: ~/.openclaw/workspace
Sessions OK: ~/.openclaw/agents/main/sessions


Great. I ran {% raw %}`openclaw tui` to start chatting and got:

Error: Missing gateway auth token.
Fix: set OPENCLAW_GATEWAY_TOKEN/OPENCLAW_GATEWAY_PASSWORD, pass --token/--password,
or resolve the configured secret provider for this credential.


OpenClaw has a gateway architecture — there's a long-running process (the gateway) that the CLI connects to. You have to start the gateway separately, generate a token, then pass that token to the client. Straightforward in concept, but the setup flow doesn't walk you through it.

This was the wall I didn't get past in my hour.

## What I did learn by poking around

The one command that was genuinely illuminating: {% raw %}`openclaw skills`.

It lists every skill OpenClaw knows about. On a fresh install, I counted **52 bundled skills**, 8 of them ready to use out of the box. Highlights:

- `taskflow-inbox-triage` — an email triage example already built by the OpenClaw team
- `gog` — Google Workspace (Gmail, Calendar, Drive) integration
- `himalaya` — IMAP/SMTP email via CLI
- `skill-creator` — a skill that helps you write other skills
- `github`, `notion`, `obsidian`, `slack`, `discord` — standard productivity integrations
- `camsnap`, `openhue`, `sonoscli` — IoT stuff I didn't expect

Most are marked "needs setup" — meaning the skill file is there, but you need to install the underlying CLI tool and authenticate it. It's a plugin model: OpenClaw orchestrates, the real work happens in well-established CLIs like `gh`, `himalaya`, `obsidian-cli`.

That's actually a smart design. Instead of reimplementing integrations, OpenClaw wraps tools that already exist.

## Three things I genuinely learned

**1. A "skill" is a thin layer over an existing CLI.**
When I thought "skill," I pictured a self-contained script. It's not. A skill is mostly a `SKILL.md` that tells the model *how and when* to call an underlying command-line tool. Want Gmail triage? You don't write mail parsing — you configure `gog` or `himalaya`, and your skill just tells the model which commands to run against it.

This means the Markdown-only pitch is half true. The Markdown is your job. But the CLI underneath still needs to exist and be authenticated.

**2. Beta software has a dependency graph, and Windows makes it worse.**
My install chain ended up being: Windows → Node.js → Claude Code → paid Claude account → OpenClaw → Gateway → token → skill → underlying CLI → that CLI's own auth. Each layer is a point of failure. On WSL2 or Linux, most of these are smoother. Native Windows compounds the friction.

If you're on Windows and serious about using OpenClaw, spend the 15 minutes to install WSL2 first. Future you will thank you.

**3. The `SKILL.md` idea is still worth getting excited about.**
Even without finishing the install, reading through the bundled skills taught me something about how to structure *any* agent instruction. The good ones have: a sharp `description` (the trigger), explicit `when to use` rules, concrete examples with expected output, and explicit "don't do this" clauses. That structure is reusable even outside OpenClaw — it's just good prompt engineering discipline, enforced.

I started writing a skill for student inbox triage (URGENT / REVIEW / APPLIED / ARCHIVE buckets for placement-season email). I didn't get to run it. But writing it forced me to articulate what "important email" actually means to me, which is a clarity exercise I don't think I would've done otherwise. That alone was worth the hour.

## Would I keep using it?

Honestly? Probably not right now. I'm a student mid-placement-season. My bandwidth for debugging beta CLI tooling on native Windows is zero. If I come back to OpenClaw, it'll be on WSL2 during a break.

But I'd recommend it to someone with a Mac, spare time, and an inbox they want to tame. The underlying idea is right. The Windows-native onboarding is just rough.

## TL;DR for Windows students

- **Install WSL2 first.** Don't skip the warning.
- **You need a paid Claude plan** (Pro or above). The free tier won't work.
- **Budget 2–3 evenings**, not 1 hour. There are multiple auth flows to get through.
- **Explore `openclaw skills` immediately** — it's the fastest way to understand the model.
- **The `SKILL.md` structure is useful even if you never run the skill.** Treat writing one as a clarity exercise.

Good luck, and happy clawing. 🦞

I Tried Installing OpenClaw on Windows in an Hour. Here's What Actually Happened.

bnspopi — Mon, 20 Apr 2026 07:57:02 +0000

Liquid syntax error: 'raw' tag was never closed

I'm a CS Student in Placement Season. I Replaced My Inbox Anxiety With 80 Lines of Markdown.

bnspopi — Mon, 20 Apr 2026 07:55:01 +0000

This is a submission for the OpenClaw Challenge.

What I Built

I built inbox-triage — a personal email triage skill for OpenClaw. It's a single SKILL.md file, 80 lines of Markdown, no code, no API keys, no deployment. When I paste email subject lines or a screenshot of my Gmail into OpenClaw, it sorts them into four buckets:
🔴 URGENT — open now (OA deadlines, interview invites, placement cell mail)
🟡 REVIEW — today-ish (interview prep, company research, professor mail)
🟢 APPLIED — active applications awaiting response (Microsoft, Dbert Labs, Bluestock)
⚫ ARCHIVE — silently filed (LinkedIn noise, daily digests, noreply promos)
The problem it solves is specific: I'm a CS student in active placement season. My inbox gets 200+ mails a week and maybe 10 of them matter. I was missing OA deadlines while reading "5 people viewed your profile" notifications. The script version I built first (Gmail API + regex) broke every time a recruiter emailed from a domain I hadn't hardcoded. A skill handles the fuzzy cases a script can't.

How I Used OpenClaw

The whole project is one SKILL.md. OpenClaw's skills architecture does the heavy lifting — I just describe when the skill fires and what the rules are, in plain Markdown. Three pieces make it work:

The description frontmatter is the trigger. I wrote it to fire whenever I paste email info or ask "what should I open first." OpenClaw reads this and routes the request correctly without me invoking the skill explicitly.
Layered classification rules. The rules go URGENT → REVIEW → APPLIED → ARCHIVE, with an explicit tie-breaker: the more urgent bucket always wins. That single rule handles the hardest case — a no-reply@bluestock.in email with subject "Interview scheduled Thursday 3 PM" is URGENT, not ARCHIVE, because the subject rule beats the sender rule.
A worked example in the skill itself. My first draft was rules-only and hit about 60% accuracy. Adding one fully-worked example with real sender names and expected output pushed it past 95%. Models pattern-match on examples harder than they follow abstract rules.

Demo

Input:

From: cellplacement507@gmail.com — "Microsoft OA link — complete by 11 PM today"
From: LinkedIn — "5 people viewed your profile this week"
From: recruiting@microsoft.com — "Re: Your application — next steps"
From: Unstop — "Daily digest: 12 new hackathons"
From: no-reply@bluestock.in — "Interview scheduled: Thursday 3 PM"
From: Medium Daily Digest — "Top stories in AI"

Output:
🔴 URGENT (open now)

cellplacement507@gmail.com — Microsoft OA link — complete by 11 PM today — Placement cell + deadline today
recruiting@microsoft.com — Re: Your application — next steps — Applied company responding to your thread
no-reply@bluestock.in — Interview scheduled: Thursday 3 PM — Applied company + interview keyword beats noreply rule

⚫ ARCHIVE (3 items archived)

What I Learned

The hardest part of this build wasn't writing the rules. It was being specific enough about what "important" means to me that a model could apply it consistently.
"Placement cell emails matter" is obvious. But what about a LinkedIn notification that happens to mention Microsoft because I follow Microsoft? What about a noreply@ from a company I applied to last week? What about an Unstop email — is it a daily digest (archive) or a status update on something I applied to (surface)?
Every edge case forced me to articulate a preference I'd never actually put into words. By the time the skill was accurate, I understood my own email-reading heuristics better than before I started.
Two other things clicked:

A skill's description field is doing real work — it's not a comment for humans. Vague descriptions don't trigger reliably. Specific ones do.
Explicit output formats make skills reusable. The four-bucket structure with emojis means I can scan the output in two seconds. An open-ended format would've given me paragraphs — which is what I was trying to escape.

Skills are a forcing function for self-knowledge. I didn't expect that going in.

ClawCon Michigan

I didn't attend ClawCon Michigan — I was running Gmail triage from Baharampur, West Bengal, which is a few time zones and an ocean away. But the community around it is what made me want to ship something for this challenge instead of just reading the announcement.

## Deploying My Fintech Project with AI Using Kuberns

bnspopi — Wed, 04 Mar 2026 11:34:51 +0000

## The Project: WePay

bnspopi ・ Mar 4

#ai #devops #chatgpt #cloud

## The Project: WePay

bnspopi — Wed, 04 Mar 2026 11:33:48 +0000