DEV Community: hakiimi

How I Automated My Passive Income Content Pipeline With OpenClaw

hakiimi — Mon, 10 Aug 2026 05:32:45 +0000

If you have been following my series on building passive income with AI agents, you already know I publish regular English technical articles to dev.to. This post is different. This is the story of how I turned the whole thing into a fully unattended, self-running system 鈥?so that content keeps going out even when I am asleep, offline, or working on something else.

The tool that made this possible is OpenClaw. It is an open-source, local-first AI agent platform. Here is exactly how I set up an automated content pipeline, the mistakes I made along the way, and the parts you cannot automate (yet).

The Goal

I wanted a system that could, on a schedule:

Generate a new SEO-oriented technical article from a topic list
Format it as Markdown
Push it to dev.to through a logged-in browser session
Record that it was published so it never duplicates
Repeat, forever, with zero human input between runs

The Building Blocks

1. A scheduled task that checks for new content

The heart of the system is a scheduled job (a cron in OpenClaw) that runs every 20 minutes. On each run it:

Reads a local file called published-state.json
Lists the Markdown files in a content/articles/ folder
Publishes any file whose name is not already in the published list
Updates the state file only after a successful publish

That file is my deduplication key. It is the single most important design decision in the whole system, because it is what stopped me from accidentally posting the same article twice.

2. A generating step

I queue topic ideas as Markdown files. When the folder has a new file, the pipeline generates the full article (title + ~1600 words of body) from that topic. I keep the topics in a specific vertical 鈥?AI agents, automation, and OpenClaw 鈥?because that is the corner of search where my audience actually lives.

3. A publishing step that talks to the real editor

Here is the part most tutorials skip. dev.to's editor is a React app, so you cannot just POST a string and have it work reliably. I drive a real logged-in browser tab over CDP (Chrome DevTools Protocol) and:

Fill the title field by DOM id
Fill the body by textarea name, using the native value setter plus an input event so React actually notices
Simulate a real mouse click on the Publish button

The trick that made it reliable: after setting the value, you often have to append a space and delete it to force React's onChange to fire. Without that, the publish click silently does nothing.

Two Mistakes Cost Me Real Time

Mistake 1 鈥?I ignored rate limits. dev.to returns Rate limit reached, try again in 300 seconds if you post too fast. The fix is to space publishes out by at least five minutes. My cron interval already handles this, but my early manual testing did not, and I burned time waiting on backoff timers.

Mistake 2 鈥?I duplicated a post. My first version tracked "what is published" by remembering URLs. When a URL changed slightly between runs, the checker thought the article was new and posted it again. Switching to a filename-based state file fixed this permanently.

What Still Needs a Human

Full transparency: automation handles the production and the publishing. It does not handle:

Account creation and verification 鈥?the first-time login, email confirmation, and bot-check basically need a human at the wheel.
Subject matter judgment 鈥?a topic list is a strategy decision. The pipeline is only as good as the queue you feed it.
Waiting for SEO to pay off 鈥?Google indexing and ranking takes weeks. This is a compounding asset, not a lottery ticket.

The Result

Right now the system runs unattended in the background. The content files grow, the cron publishes on schedule, and published-state.json grows with each successful post. I write the strategy; the agent executes the mechanics.

If you are already running OpenClaw, this is very achievable. Start small: one folder, one state file, one scheduled task. Let the machine do the boring, repeatable work while you own the part that actually matters 鈥?deciding what to say.

This is part of an ongoing series on AI-agent-driven content automation with OpenClaw.

Deploying OpenClaw with Docker: A Clean Setup

hakiimi — Mon, 10 Aug 2026 03:51:51 +0000

Running OpenClaw inside Docker gives you isolation, easy upgrades, and consistent environments across machines. Here is a clean, working setup with the key details that usually trip people up.

Why Docker

Docker keeps everything (runtime, config, data) bundled and reproducible. You can move a setup between machines, pin versions, and avoid “works on my machine” problems.

The basics

Create a directory for your config and data, then run the official image with the ports the gateway needs exposed. Keep your auth token in an environment variable, not in the command line, so it stays out of shell history and logs.

Named volumes for persistence

Persist the data directory with a named volume so agents, memory, and sessions survive container restarts and upgrades. Without this, you lose everything when the container is replaced.

Networking that matters

Bind the gateway to localhost by default, and put a reverse proxy in front if you need remote access. Exposing the gateway directly to the internet without auth protection is a common and dangerous mistake.

Upgrading safely

Before upgrading, back up the data volume. Pull the new image and recreate the container. Because state lives in the volume, the upgrade is low-risk and reversible.

A small compose file goes a long way

A docker-compose.yml captures the whole setup: image, ports, volumes, environment, and restart policy. One command brings it up, and the same file works on any Docker host.

Wrap up

Docker is one of the cleanest ways to run OpenClaw: reproducible, isolated, and easy to upgrade. Get the volumes and auth right, and the rest is straightforward.

Building Your First OpenClaw Skill: A Walkthrough

hakiimi — Mon, 10 Aug 2026 03:11:33 +0000

Skills are how you package repeatable work for an OpenClaw agent — a folder with instructions, scripts, and references the agent can load on demand. The first one is the hardest; after that it clicks. Here is the full walkthrough.

What a skill is

A skill is a directory containing a SKILL.md (instructions for when and how to use it), plus optional scripts/ and references/ folders. The agent reads SKILL.md when the skill is relevant and follows it, running scripts and consulting references as needed.

Pick one repeatable task

Choose a workflow you do more than once that takes at least a few minutes and can be automated or partly automated. A clear, single-purpose task beats a vague catch-all.

Write SKILL.md

SKILL.md has a small YAML frontmatter block (name and description) followed by the instructions. The description matters most: it tells the agent when to use the skill.

Then write the body: the workflow steps, expected inputs and outputs, and any quality bar the agent must meet.

Add a script

Put a helper script in scripts/ — for example a Python or shell file that does the mechanical part. Keep it focused. Scripts make the skill do real work instead of just describing steps.

Add references

Put templates, examples, or longer guides in references/ that the agent can read when it needs detail.

Test it

Give the skill to your own agent and run it end to end. Fix anything that breaks, and adjust the description if the agent is not triggering it correctly.

Publish or keep local

You can keep a skill local for yourself, or publish it to ClawHub for community use. Either way, a polished skill saves effort every time you reuse it.

SOUL.md: Give Your AI Agent a Personality That Actually Helps

hakiimi — Mon, 10 Aug 2026 02:32:10 +0000

Every OpenClaw agent has a persona file, traditionally SOUL.md. Most people skip it or write a one-liner. But SOUL.md is where you encode how the agent should behave, and it has an outsized effect on output quality. Here is how to use it well.

Why persona matters

An agent without a persona answers literally. With a good persona, it understands tone, priorities, when to push back, and what "good" means for your work. The same model produces very different output depending on the persona you give it.

Start with the job, not the vibe

Write SOUL.md around the role the agent plays, not generic personality adjectives. Instead of "be friendly and helpful", try "you are a senior SEO editor: you flag weak claims, keep prose tight, and refuse to pad word count."

Include what matters for your work

Tone: how it should sound in deliverables and messages.
Priorities: what to optimize for (accuracy, speed, clarity, consistency).
Boundaries: what it should refuse or flag, to keep you safe.
Context: who the audience is, what the work is for.

Keep it short and specific

A tight, concrete SOUL.md beats a long vague one. Aim for a few sentences per point, written as instructions to the agent, not marketing copy.

Iterate with examples

As you work, note where the agent's behavior missed: too wordy, too terse, too agreeable. Rewrite SOUL.md with concrete examples of the desired behavior, and the next run improves.

Wrap up

SOUL.md is a lever, not a formality. Write it around the job, keep it concrete, and keep refining it. The better the persona, the less hand-holding every other instruction needs.

Why Your AI Agents Need Memory (and How OpenClaw Handles It)

hakiimi — Mon, 10 Aug 2026 02:09:42 +0000

A chatbot without memory answers the same question twice. An agent without memory can never get better at a task. Memory is what turns a stateless tool into a system that compounds.

The problem with no memory

Without memory, every task starts from zero. The agent re-reads context, re-learns your preferences, and repeats mistakes. It is like hiring someone who forgets everything overnight.

Three kinds of memory

Session memory: what happened in this conversation. Useful but transient.
Long-term memory: facts and lessons that persist across sessions. This is the big win.
Working memory / state: the current state of a running task or project.

Most people only use session memory. The leverage is in the long-term kind.

How OpenClaw addresses it

OpenClaw stores memory in plain files (like MEMORY.md and dated daily notes) plus a semantic search index. Agents can recall prior decisions, preferences, and context by searching these notes instead of asking again.

Why plain files are a feature

Files are human-readable, editable, and portable. You can see exactly what the agent remembers, fix a wrong memory, and move it to a new machine. No opaque database lock-in.

Practical tips

Tell your agent to write decisions down, not just answer.
Review and fold daily notes into long-term memory periodically.
Prune stale facts so memory stays clean and relevant.

Wrap up

Memory is the difference between an agent and a toy. Start writing things down, let the agent search its own notes, and you get compounding returns on every interaction.

OpenClaw Gateway Setup: Tokens, Channels, and Security

hakiimi — Mon, 10 Aug 2026 02:04:38 +0000

A good OpenClaw setup is more than installing the binary. The gateway is the heart that connects your agents to chat channels, tools, and the web. Getting it configured right saves you trouble later.

The gateway in one sentence

The gateway is the always-on service that routes messages between your agents, the tools they use, and the channels where you talk to them (Telegram, Slack, Discord, and more).

Tokens and auth

The gateway uses a token for access control. Set a strong, unique token and never expose it. Keep the gateway bound to localhost or behind an authenticated reverse proxy.

Connecting a channel

The simplest first channel is Telegram: create a bot, give the gateway the bot token, and you can talk to your agent from your phone. Each channel has a small config block; fill it and the gateway does the rest.

Agents and their config

Each agent has a profile with its personality (SOUL.md), memory, and allowed tools. You can run multiple agents on one gateway, each isolated. Keep security settings strict.

Environment and secrets

Store API keys and credentials in config or environment, not prompts. Use the gateway's built-in secret handling so keys are never logged or sent to the model.

Scheduled and headless work

The gateway can run agents on schedules and expose them over a local API, which is how you build headless automations on a VPS. Secure that API the same way.

Wrap up

Proper gateway setup: strong token, localhost binding or HTTPS, careful secret storage, and channels connected one at a time.

Headless AI Agents: Real Workflows Beyond the Chatbot

hakiimi — Mon, 10 Aug 2026 01:59:17 +0000

"AI agent" usually means a chatbot. But the real leverage of an agent platform like OpenClaw is headless automation: software that runs tasks on its own schedule, without a chat window. Here is what that actually looks like.

Chatbot is the weakest use case

A chatbot waits for a question. A headless agent initiates work. The difference is the difference between a reactive tool and an autonomous system.

Real headless workflows

Scheduled scraping: pull competitor prices or news every hour and write results to a database.
Content pipelines: generate and publish SEO articles on a cron schedule.
Monitoring and alerts: watch for price changes and notify you on Slack or Telegram.
Data normalization: take messy rows from a form or API and output clean, structured records.
Inbox triage: sort mail, draft replies, and log follow-ups automatically.

How it is wired

Typically you run the agent as a service (systemd) on a VPS, connect it to a scheduler, and let it call APIs and write to storage by itself. No chat window required.

Why this matters for income

Headless agents are the engine behind passive automation: content that publishes itself, monitors that run constantly, and pipelines that never sleep. The value is consistency at scale.

Key idea

An agent is not a better chatbot. It is a way to encode a repeatable business process that runs on its own. Start with one boring repeatable task, automate it, then add the next.

Keyword Research for AI-Generated Content: A Practical Method

hakiimi — Mon, 10 Aug 2026 01:54:10 +0000

Most AI content fails because it starts with a vague topic, not a keyword with real demand. This is the keyword research method I use to decide what my agents write next.

Start with the searcher, not the topic

Ask: what would someone actually type? Real search phrases, not editorial headlines. Write down the question form, the problem form, and the how-to form of your topic.

Use the free tools first

Google Autocomplete: type your seed phrase and read the suggestions - these are real queries.
People also ask: mine those boxes for sub-questions.
Answer boxes / featured snippets show what Google thinks the intent is.

Judge demand vs. effort

For each keyword, ask two questions: Is it worth ranking for? Can I realistically rank? A long-tail keyword with clear intent beats a broad head term for a new site.

Cluster into one article

Group 3-5 related questions into one in-depth article. One strong page that answers a cluster outperforms five thin pages, and matches how Google rewards topical depth.

Hand the cluster to the agent

Once you have a keyword cluster, your agent has a real brief: title, target keywords, outline sections mapped to each question. That is the difference between write about X and answer these specific searchers.

The honest metric

Track position, not vanity. If a page does not move after a few weeks, reassess the keyword or improve the page. Keyword research is a loop, not a one-time step.

That is the method: find the real queries, judge effort, cluster, then brief the agent precisely.

AI Agent vs. Single Prompt: When Automation Actually Pays Off

hakiimi — Mon, 10 Aug 2026 01:44:56 +0000

Everyone is talking about AI agents, but most people still use a single prompt. The honest question: when does an agent actually pay for itself?

Here is my rule, learned from building an OpenClaw-driven content system.

The difference in one line

A prompt answers a question now.
An agent runs a process on a schedule, with memory, and handles the middle steps.

An agent is worth it when the task is repeated, multi-step, or needs consistency - not a one-off question.

When a single prompt is fine

A one-time draft you will heavily rewrite.
A quick answer to a factual question.
Anything where the output is a dead end, not input to more work.

Using an agent here is over-engineering. More tokens, no real benefit.

When an agent pays off

Content pipelines: research, draft, SEO, publish - a repeatable loop.
Monitoring: watch prices, competitors, or news on a schedule and alert you.
Inbox workflows: sort, draft replies, and log follow-ups.
Data normalization: messy input to clean, uniform output every time.

The common thread: the task repeats, and each run builds on consistent process, not on your attention.

The hidden cost people miss

An agent is only reliable if you encode quality standards. Without a good system prompt, SOUL, and per-task instructions, an agent will cheerfully produce garbage at scale - worse than a human doing one good job.

Wrap up: reach for a prompt when it is one-off; build an agent when the work repeats. ROI comes from consistency and scale, not automation for its own sake.

AI Agent vs. Single Prompt: When Automation Actually Pays Off

hakiimi — Mon, 10 Aug 2026 01:44:56 +0000

Everyone is talking about AI agents, but most people still use a single prompt. The honest question: when does an agent actually pay for itself?

Here is my rule, learned from building an OpenClaw-driven content system.

The difference in one line

A prompt answers a question now.
An agent runs a process on a schedule, with memory, and handles the middle steps.

An agent is worth it when the task is repeated, multi-step, or needs consistency - not a one-off question.

When a single prompt is fine

A one-time draft you will heavily rewrite.
A quick answer to a factual question.
Anything where the output is a dead end, not input to more work.

Using an agent here is over-engineering. More tokens, no real benefit.

When an agent pays off

Content pipelines: research, draft, SEO, publish - a repeatable loop.
Monitoring: watch prices, competitors, or news on a schedule and alert you.
Inbox workflows: sort, draft replies, and log follow-ups.
Data normalization: messy input to clean, uniform output every time.

The common thread: the task repeats, and each run builds on consistent process, not on your attention.

The hidden cost people miss

Wrap up: reach for a prompt when it is one-off; build an agent when the work repeats. ROI comes from consistency and scale, not automation for its own sake.

How to Set Up an OpenClaw Agent on a VPS (Step-by-Step)

hakiimi — Mon, 10 Aug 2026 01:40:38 +0000

Running an OpenClaw agent on a VPS unlocks 24/7 automation without keeping your laptop on. This is the setup I use for my content agents. Here is the exact path.

Why a VPS

A VPS gives your agents a permanent home: always-on, stable IP, no sleep mode, and room for multiple agents and scheduled jobs. Any basic Linux VPS (2GB RAM) is enough to start.

1. Spin up the server

Choose a Linux distro (Ubuntu 22.04 LTS is the easiest start).
Connect over SSH.
Update everything: sudo apt update && sudo apt upgrade -y.

2. Install Node.js (required for OpenClaw)

curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt-get install -y nodejs
node --version

3. Install OpenClaw

npm i -g openclaw
openclaw --version

Configure the gateway token and keep it bound to loopback or behind a reverse proxy.

4. Run as a service (survives reboots)

Create /etc/systemd/system/openclaw.service, enable and start it, and your gateway comes back automatically after any reboot.

5. Connect from anywhere

With the agent headless on the server, connect a chat channel (Telegram, Slack, Discord) and schedule jobs on the server clock.

Security checklist

Keep the gateway bound to 127.0.0.1 or behind HTTPS reverse proxy.
Use a strong auth token.
Never expose raw ports publicly.

Wrap up

That is the whole flow: server, Node, OpenClaw, systemd, remote access. Once it is running, your agent works around the clock - the entire point of a VPS.

How I Built a Passive Income Content System With an AI Agent (OpenClaw)

hakiimi — Mon, 10 Aug 2026 01:39:03 +0000

In 2026, running a content business no longer means staring at a blank page.

I built a fully automated system with OpenClaw, an open-source AI agent platform, that researches, writes, optimizes, and schedules SEO content for me. This is exactly how it works.

Why an agent instead of a single prompt

A single AI prompt gives you a draft. An agent gives you a production loop. The difference is process: research, draft, SEO check, publish, and iterate happen on a schedule, not as one-off requests.

The stack

OpenClaw as the orchestration layer (agents, skills, memory)
A content topic pipeline (keyword research to outline to draft)
An SEO pass (title, meta, headings, keyword density, schema)
A scheduling step so articles publish consistently

The key insight

The agent is only as good as the standards you encode. I wrote SOUL.md and per-task instructions that enforce quality: no filler, real substance, specific examples. That is what keeps readers (and search engines) coming back.

Next steps

This is the beginning, but the architecture matters: a repeatable, automated editing system that compounds. Next, I will break down the keyword research step and show how to pick topics that actually get traffic.