DEV Community: Leo tim

Weekly PR Digest: Celebrate Your Contributors (Without Writing a Bot)

Leo tim — Wed, 04 Nov 2026 22:27:47 +0000

## The Problem: Your Contributors Deserve Recognition

Running an open source project means PRs are flying in. Maintainers and contributors churn through reviews, merges, rebases—and by Friday, nobody remembers the small wins from Monday or Tuesday. A weekly digest that highlights what shipped and thanks the humans who made it happen sounds nice, but hand-writing it every week burns out fast.

What if your coding agent could build that for you in two minutes?

The Workflow

You give your agent a single instruction:

Connect to GitHub and every Monday morning, fetch all PRs merged in my repo since last week. For each one, write a two-line summary of what it does and who merged it. Combine them into a friendly digest and email it to my team.

Your agent wires it up in WebArm24. Here's what the pipeline looks like:

Runs on a weekly cron schedule (Monday 8 AM UTC, or whenever you like)
Makes an HTTP call to the GitHub API to fetch merged PRs with a date filter
Loops through each PR and calls Claude (via MCP) to generate a one-paragraph summary
Uses a simple if/else to skip bot PRs or auto-generated commits
Bundles all summaries into a formatted email body
Sends the email via your mail provider

You open the WebArm24 canvas, see the pipeline cards laid out in a clean flow, run a test to see a sample digest, then tweak the email template by asking the agent: Make it friendlier and add a line thanking all contributors at the end. The agent adjusts the step, you preview again, and when it looks right, you flip the schedule on.

Every Monday morning your inbox has a ready-to-read digest you can post in Slack or forward to your team.

Why This Matters

Contributor retention is quietly the hardest part of open source. A small, regular acknowledgment—especially one that doesn't feel mass-produced—keeps people motivated. Automating it means you actually do it, week after week, instead of letting it slide for months and then writing a guilt-driven thanks post.

And because the pipeline lives in your WebArm24 workspace, you can tweak it anytime. Want to add a contributor count? Ask the agent to add it. Want to call out the review count, not just merges? Change the filter. The version history means you never lose a working version.

Remix Ideas

Daily stand-up prep: Fetch PRs merged yesterday, open issues added, and GitHub discussions started. Format as a quick morning briefing for your team.

Contributor leaderboard: Once a month, rank contributors by merged PR count and email a fun Hall of Fame summary. The agent can add a playful tone without you lifting a finger.

Stale PR alert: Use the GitHub API to find PRs waiting for review longer than 7 days. Run this on a Tuesday morning and ping reviewers who marked themselves as available.

How to Build It

Head to WebArm24, sign up for free credits, and connect your coding agent:

claude mcp add --transport http webarm24 https://webarm24.online/mcp --api-key YOUR_KEY

Paste the workflow idea into your agent, and it will create the whole pipeline for you. You'll get a canvas with every step visible, the ability to test it right away, and fine-grained control over the schedule. No backend hosting, no cron daemon, no Zapier tabs open all day.

The best part? It takes about five minutes from idea to running pipeline. Go build it and let your contributors know they're seen.

AI Agents + Browser Automation: Extract Web Data Without Writing Scrapers

Leo tim — Wed, 04 Nov 2026 22:08:21 +0000

The Problem: Manual Data Extraction Eats Hours

You need to pull pricing data from three competitor sites. Extract user feedback from a web forum. Monitor job listings. Combine data from multiple sources into a spreadsheet. These tasks feel simple—click here, copy that, paste there—but they're mind-numbing and error-prone.

Traditionally, you'd write a web scraper. You'd parse HTML, handle pagination, deal with JavaScript rendering, debug when the site layout changes. It works, but it's slow to build and brittle to maintain.

There's a better way: let an AI agent control your browser and extract the data by following plain-English instructions. You describe what you want; the agent figures out how to get it.

How AI Agents + Browser Automation Work Together

Browser automation tools (like Playwright, Selenium, or Puppeteer) let programs click buttons, scroll pages, and read text just like a human would. AI agents—powered by large language models—can interpret natural language instructions and decide which actions to take.

When you combine them:

You tell the agent what to do in plain English
The agent sees the current page (via screenshot or DOM structure)
The agent decides what to click, type, or read next
The browser executes those actions
The agent repeats until the task is done
Data is extracted and formatted for you

The result? You get a working data extraction pipeline without writing a single scraper line.

A Real Example: Extracting Competitor Pricing

Let's say you want to track three competitor prices weekly. Here's the plain-English instruction you'd give an AI agent:

Visit each of these URLs: example.com/products, competitor-a.com/shop, competitor-b.com/pricing. On each page, find all products that match the category "Project Management Tools". For each product, extract the name, price, and any discount badge. Return the results as a CSV where each row is: product_name, price, discount, source_url.

The agent would:

Navigate to each URL
Take a screenshot to see the layout
Identify product listings (even if the HTML structure differs between sites)
Click through pagination or load-more buttons if needed
Extract text and prices
Format and return the CSV

No regex. No DOM selectors. No fragile CSS parsing. The agent understands context.

Why This Beats Traditional Scraping

Resilience: When a site redesigns its layout, your scraper breaks. An AI agent adapts—it doesn't rely on specific HTML structures. It understands "find the price on this product card" regardless of whether it's in a <span> or a <div>.

Speed to value: Building and testing a scraper takes hours or days. Describing your task to an AI agent takes minutes. You don't need to learn XPath or debug CSS selectors.

Flexibility: Extracting data was task A. Now you need to extract and filter by price range, and group by brand. Modify your English instruction; the agent adapts. A scraper would need rewriting.

Handling dynamic content: Many modern sites load data via JavaScript. Scrapers struggle; they see placeholder HTML. Browser automation sees the final rendered page, so dynamic content is automatically captured.

Tools and Platforms to Try

Browser automation libraries:

Playwright (Python, Node.js, C#) — reliable, fast, great for AI integration
Selenium — older, but widely compatible
Puppeteer (Node.js) — excellent for headless Chrome control

AI agent frameworks:

Claude (Anthropic) — can be integrated with Playwright via custom tools
OpenAI's function calling — similar approach; define actions, let GPT-4 choose which to call
Anthropic's Computer Use API — high-level tool; the model can take screenshots and click

No-code platforms:

If you don't want to write code at all, platforms like WebArm24 let you describe a workflow in plain English—"extract this data from these sites, check for changes weekly"—and the platform's AI builds and runs it. You schedule it, get results in your inbox, done. It's an n8n or Zapier alternative, but powered by AI agents that understand your instructions and can control a browser to extract data.

A Practical Workflow

Here's how a real team might implement this:

Define the task clearly. What data? From where? Any filters or transformations? Write it down in a Slack message or document—that's your instruction.
Set up a browser automation script that connects to an AI agent (Claude or GPT-4). Provide the instruction and the starting URLs.
Let it run. The agent sees each page, extracts data, moves to the next.
Format output. Tell the agent to return a CSV, JSON, or Google Sheets update.
Schedule it. Use a cron job or a platform like WebArm24 to run the extraction weekly, daily, or on-demand.
Add a human loop if needed. If the extracted data looks odd, the agent should flag it or pause for review.

Common Gotchas

AI can hallucinate. If a product isn't on the page, the agent might make up a price. Mitigate by asking the agent to cite the text it's reading ("extract the price from the text you see, not from your knowledge base") and by spot-checking results.

Rate limiting and detection. Sites may block rapid requests or bot traffic. Use delays between clicks, rotate user agents, and respect robots.txt. An ethical approach: if you need frequent updates, talk to the site owner about an API.

Complex UX. Some sites require CAPTCHA, login, or unusual interactions. Browser automation shines here because it's human-like, but an AI agent might need help. You can annotate: "If you see a login form, stop and alert the user."

Cost. Calling an AI API for every click adds up. For high-volume tasks, batch your requests. Run the extraction overnight when it's cheapest, or use cheaper models for simple tasks.

When to Use This Approach

Use AI + browser automation for:

One-time or low-frequency extractions (weekly reports, quarterly research)
Multiple sites with different layouts (AI adapts; scrapers don't)
Tasks involving UX judgment ("click only the items on sale", "find the 'Contact Us' link")
Rapid prototyping (you need data fast, maintainability is secondary)

Stick with a scraper for:

High-volume, real-time extraction (millions of rows per day; cost matters)
Simple, stable targets (one site, consistent HTML, you control the endpoint)
Offline-first workflows (you need zero latency)

Getting Started Today

If you're new to this, start small:

Pick one website you want to extract data from.
Install Playwright: pip install playwright (Python) or npm install playwright (Node.js).
Write a five-line script that navigates to the site and takes a screenshot.
Describe what you want extracted in plain English.
Use an AI API (Claude, GPT-4) with a prompt that includes the screenshot, your instruction, and a list of possible actions (click, type, scroll, extract text).
Let it run. Iterate on your instruction based on what it does.

Within an hour, you'll have extracted your first dataset without writing scraper code.

Or, if you prefer a fully managed experience, platforms like WebArm24 handle the browser, the AI agent, and the scheduling for you. Describe your task, set it on a schedule, and results land in your inbox.

The Future: Agents as Data Pipelines

As AI gets smarter and faster, browser automation becomes the new ETL. Instead of building pipelines in code, you'll describe them in English. "Update my pricing dashboard by extracting from these five competitors, transform prices to USD, flag anything that moved >10%, and email me a summary."

The agent does it all. No code, no maintenance, no fragility.

Start experimenting today. Your next data extraction task doesn't need a scraper.

I gave my coding agent an n8n/Zapier-style automation platform over MCP

Leo tim — Wed, 04 Nov 2026 21:52:55 +0000

Most MCP servers get used one tool call at a time, inside a chat. When the chat closes, the work stops.

I wanted something else: tell my coding agent "every weekday at 9am, do X and email me" and have it build a real workflow that keeps running on its own. So I built WebArm24. It's a hosted automation platform in the same space as n8n, Zapier and Make, except it's designed to be driven by an agent over MCP instead of dragged together on a canvas.

What it looks like

The prompt in Claude Code was:

Every weekday at 9am, fetch USD rates for EUR, GBP and JPY, have AI summarize them and email me.

The agent drafted the pipeline, created it, ran it once to check, and the email arrived 15.5 seconds later. After that it runs on its cron schedule with no chat open.

Connect it in one line

claude mcp add --transport http webarm24 https://webarm24.online/mcp \
  --header "Authorization: Bearer wak_..."

Create the wak_... key with the MCP button at webarm24.online. New accounts get free credits. It's a plain streamable-HTTP endpoint, so Cursor, Windsurf, VS Code and other MCP clients work too.

Discovery (initialize, tools/list) doesn't need a key, so you can inspect all the tools before signing up.

What the agent can do

The server exposes about 60 tools, grouped like this:

Pipelines: pipeline_create, pipeline_update, pipeline_run, pipeline_run_wait, pipeline_test_step, pipeline_debug_chat, plus groups, version history and restore of deleted pipelines.
AI builder: pipeline_builder_chat drafts a pipeline from a plain-English description.
Triggers: cron, a one-shot run_at time, an inbound webhook URL, or a manual run.
Storage: persistent per-user JSON/text stores and files that pipelines can read and write.
Direct tools: email, JSON analysis, and a browser for sites that have no API.

A pipeline is a list of steps, and each step can use the earlier ones' output through templates like {{prev_output}}, {{step_2_output}} or {{step_1.json.items}}. The step types are:

Step	What it does
`agent`	An LLM step, which can also drive a browser
`http_request`	Calls any REST API
`mcp`	Calls a tool on any third-party MCP server
`js`	JavaScript in V8
`python`	Python in a bubblewrap sandbox (ffmpeg and Pillow available)
`email`	Sends an email
`if_else`	Branches
`data_storage`	Persistent stores and files

MCP servers as building blocks

The mcp step is my favorite part. Your pipeline can call other people's MCP servers on a schedule, in parallel, and feed one server's output into another's input.

Every Monday, this pipeline:

Calls TidyData MCP public_holidays three times in parallel (US, UK, DE)
Merges the results into 33 rows sorted by date in a JS step
Publishes them as a shared table through rows.page MCP push
Emails the team the link

The whole run takes 5.3 seconds, and the step config is just:

{
  "type": "mcp",
  "mcp_url": "https://rows.page/mcp",
  "mcp_tool": "push",
  "mcp_arguments": "{\"rows\": {{prev_output}}, \"title\": \"2027 public holidays\"}"
}

For servers that need auth, headers can come from pipeline variables: "Authorization": "Bearer {{TOKEN}}".

What I learned building it

Agents are better at editing workflows than at drawing them. Making failures readable was the hard part. Per-step outputs, a "test one step" tool and a debug chat let the agent find and fix its own mistakes instead of guessing.

Undo stops being optional once agents edit things unattended. Every change, whether it comes from the UI, the AI builder or an agent over MCP, is saved as a revision tagged with its source. Deleted pipelines can be restored too.

Use LLMs at build time and keep run time deterministic. The mcp step has an agent mode where an LLM chains a server's tools itself. For scheduled jobs, though, fixed call_tool steps were far more predictable.

MCP servers: please return structuredContent. A friendly sentence plus JSON in one text block reads well in chat but is painful to use downstream. Clear inputSchema descriptions with examples (like "year (e.g. 2027)") also save agents a lot of wrong guesses.

Pricing

WebArm24 uses pay-as-you-go credits with no subscription. Creating and editing pipelines is free. Runs, AI builder calls and direct browser or email tool calls cost credits, and new accounts start with free ones.

Try it

Website: webarm24.online
MCP endpoint: https://webarm24.online/mcp
Install docs and demos: github.com/leovegas/webarm24-mcp
Also on the official MCP registry as online.webarm24/webarm24

I'd love feedback, especially if you run n8n or Zapier in production: what would stop you from letting an agent maintain your workflows?