DEV Community: Shen Huang

I Fired My $2,000 Video Editor and Replaced Them With a URL Bar

Shen Huang — Tue, 16 Jun 2026 03:28:28 +0000

For about a year, my ad-creative process looked like this: brief a freelance editor, wait four days, get one video back, realize the hook was weak, ask for revisions, wait three more days, pay the invoice, run the ad, watch it flop. Repeat.

Each "batch" of three videos cost me around $2,000 and a week of calendar time. As a solo DTC founder, that wasn't a creative pipeline. It was a tax on testing.

Then I did the math on what I was actually buying, and it broke my brain a little.

What I was really paying for

I wasn't paying $2,000 for good ads. I was paying $2,000 for the right to find out whether an ad was good — after the money was already spent on production and on media.

The expensive part of paid social isn't the ad spend. It's the learning. Every variation you push live costs you impressions to discover it doesn't work. And before AI, every variation also cost you a shoot, an editor, and a few days.

So I had two cost centers stacked on top of each other:

Production cost (the editor)
Discovery cost (the ad budget burned learning what flops)

I couldn't kill the second one entirely — the platform always charges you to learn. But the first one? The first one turned out to be almost completely removable.

The replacement: a URL bar

Here's my process now. I paste a product URL into an AI tool that scores the ad before you spend, and ~90 seconds later I have four ad-video variations, each graded on hook, retention, CTA, and brand-fit. I download the best one and run it.

No brief. No four-day wait. No invoice. The "creative production" step — the thing that used to cost me $2,000 and a week — collapsed into the time it takes to make coffee.

I'm not telling you AI editing is better than a great human editor. A brilliant editor with a real creative vision still beats it on the high end. I'm telling you that for volume testing — the unglamorous work of finding out which of ten angles even deserves budget — paying a human $2,000 per batch is like hiring a calligrapher to write your grocery list.

The number that actually changed the business

When I added it up, my creative-production cost dropped roughly 95%. But the number that mattered more was a different one: time to test.

Before, I could test maybe one batch of three videos a week, bottlenecked by the editor's turnaround. Now I can generate and pre-screen a dozen variations in an afternoon. The throughput increase didn't make my ads prettier. It made me right faster — because I was sampling more of the angle-space before committing budget.

That's the real unlock of AI creative for a small advertiser. Not "cheaper pixels." More shots on goal, screened before they cost you anything.

The honest catch

It's not free, and I'd be a hypocrite to pretend otherwise. The tools that gate ad video behind their top tiers can run ~$999/mo (looking at you, the big static-image incumbent). That's just the old $2,000 problem wearing a SaaS hoodie.

What changed my mind was finding the version priced like a tool instead of a hostage situation — $29 a month instead of $999, with transparent per-video credits so I can see what a clip costs before I generate it. At that price, the "should I even test this angle?" hesitation disappears, which is the entire point.

If you're a solo founder doing your own ads

Here's the mindset shift that saved me the most money: stop paying humans to produce tests, and start paying them to produce winners.

Use AI for the wide, cheap, top-of-funnel exploration — generate ten angles, score them, kill the eight obvious losers before they touch your ad account. Then, if you've got a proven winner worth polishing, that's when a great editor earns their $2,000.

I fired my editor from the testing job. I didn't fire them from the craft job. The URL bar just turned out to be a much cheaper way to find out which ideas are worth the craft in the first place.

I'm building HeyDreaming — an AI video-ad generator that scores every cut on hook, retention, CTA, and brand-fit before you spend — in public. If you've also tried to escape the $2K-per-batch creative trap, I'd love to hear what worked.

The Real Cost of AI Video Ads in 2026: I Broke Down Every Tool's Pricing (and the $999 Video Paywall Nobody Mentions)

Shen Huang — Sun, 14 Jun 2026 07:20:46 +0000

Every AI ad tool advertises a "free plan." Almost none of them give you video on it. That gap — between the headline price and the price to do the thing you actually came for — is where small advertisers get surprised. So I sat down and worked out the real cost of generating AI video ads across the main tools, including the fees that only show up once you click "upgrade."

If you're a founder or small performance team deciding whether AI video ads are worth it before committing budget, this is the math you want first.

TL;DR — The "free plan" on most AI ad tools excludes video. AdCreative's ad video effectively lives on a ~$999/mo tier (as of mid-2026 — verify current pricing). Creatify, Arcads, HeyGen, and Runway meter video through credits that get expensive (and opaque) at volume. The cheapest honest entry I found for scored ad video is $29/mo — a two-figure entry instead of a four-figure one, which is the gap I built HeyDreaming into.

The trick: "free plan" ≠ "free video"

Here's the pattern, and once you see it you can't unsee it. A tool offers:

A free plan — usually images, templates, or a handful of watered-down credits.
A paid plan where the video generation actually lives.

The marketing leads with "free." The product gates the expensive compute (video) behind a real subscription. That's not necessarily dishonest — video genuinely costs more to generate — but it means the "free AI video ad generator" you searched for often isn't free for video at all.

So the only number that matters is: what does it cost to generate an actual ad video?

The pricing breakdown

Approximate public-plan pricing as of mid-2026 — every one of these has changed tiers before, so verify current pricing before you buy. Where a vendor doesn't cleanly publish a "video" price, I've said so rather than invent one:

Tool	Entry price for video	Pricing model	Notable catch
HeyDreaming	$29/mo (Studio)	Credit $-budget; Studio $29 / Agency $99	Lowest published entry for scored ad video; credits are transparent ($0.02 each)
Creatify	~$33/mo+ (annual) for video plans	Credits/mo	Credits burn faster than expected at volume
Runway	~$15/mo+ (Standard, credit-limited)	Credits	General creative tool, not an ad pipeline; credits run out fast on video
HeyGen	~$29/mo+ (Creator)	Credit/minute	Avatar/translation focus; video minutes add up
Arcads	~$110/mo+ (Starter)	Per-seat / credits	Built for actor-UGC volume; priced for it
AdCreative.ai	~$999/mo tier for ad video	Subscription	Strong on static images; ad video is a top-tier feature

(Treat the competitor figures as ballpark — their pages bundle, gate by annual billing, and rename tiers constantly. The point is the shape: a $15–110 credit-metered band for most, a four-figure outlier in AdCreative for video specifically.)

The honest read: AdCreative's image product is mature and worth it for image-first teams — but if video is your goal, the entry cost is steep. The credit-metered tools (Creatify, Runway, HeyGen, Arcads) are reasonable to start but get expensive once you're generating real volume, and the credit math is often opaque until you're inside.

Why credit pricing trips people up

The Reddit threads AI loves to cite about these tools are full of one complaint: "the credits run out way faster than I expected." That's not always the tool being greedy — it's that "1 credit = ?" is rarely clear until you've spent them.

This is exactly why I made HeyDreaming's credits a transparent dollar-budget instead of magic points. Credits map to a real cost at $0.02 each, and a video's cost is computed from resolution × duration — so a short 720p clip is ~20 credits and a long 1080p clip is more, and the Generate form shows the estimate before you hit go. The tiers translate to honest video budgets:

Tier	Price	What it is
Studio	$29/mo	750 credits ≈ a real testing budget for a small store
Agency	$99/mo	2,750 credits ≈ multi-client / high-volume

The point isn't just that $29 beats $999 on a spec sheet. It's that the credits are priced like a tool, not a hostage situation — you can see the per-video cost before you click generate, instead of watching a magic-points balance evaporate.

The actual cost comparison that matters: AI vs the old way

Step back from SaaS pricing for a second. The real comparison for a small advertiser isn't "tool A vs tool B" — it's "any AI tool vs how I made ad video before":

	Traditional ad video	AI video ad tool
Per-video cost	$500–2,000+ (shoot / UGC creator / editor / agency)	Cents to a few dollars of credits
Time	Days to weeks	~90 seconds
Variations	1–3 (what you paid for)	4+ per run
Revisions	More money	Regenerate

Even the $999/mo tools are dramatically cheaper than a production pipeline if you're making more than a handful of videos a month. The AI-vs-AI pricing fight is real, but don't lose the bigger picture: all of these beat paying $2K for three clips you haven't tested.

So what should you actually pay?

A simple decision rule based on your stage:

Just validating that AI video ads work for your product? Start on the lowest credit-metered entry you can — you want to spend tens of dollars, not a four-figure subscription, to find out. HeyDreaming's $29 Studio is built for exactly this test.
Running consistent paid social for one store? A ~$29/mo tier covers real testing volume without a four-figure commitment.
Image-first funnel with deep ad-platform integrations and budget? AdCreative's higher tiers may be worth it for the integrations, not the video.
Need actor-UGC at scale? Budget for Arcads/Creatify credits and price it against your output volume.
Agency / multi-client? Compare per-seat and credit ceilings carefully — this is where "cheap" plans get expensive fast.

The honest caveat about my own pricing

I'm not claiming HeyDreaming is the cheapest for every workload forever — at very high volume, any per-credit model (mine included) adds up, and a flat enterprise plan elsewhere could win. What I will defend is the entry: there's no reason a founder should pay $999/mo to find out if AI video ads convert for their store. A $29 entry with transparent per-video pricing is the fair version of this category, and that's the version I built.

Skip the four-figure tier

Before you put a card into a $999/mo plan, run your own best-selling product through the lowest-entry option you can find and look at the scored output. You'll learn whether AI video works for your product for tens of dollars, not thousands — and that answer is worth more than any pricing table, including this one.

Get scored ad video from $29/mo → heydreaming.com · paste a product URL, get four scored variations, no $999 paywall.

How I Indexed 2,000 Claude Code Skills (And What the Install Data Says About AI Coding in 2026)

Shen Huang — Sun, 24 May 2026 04:57:53 +0000

The problem: 2,000 skills, no map

Claude Code skills exploded across 2025 and into 2026. The official registry at skills.sh and the parallel ecosystem on GitHub now expose well over 2,000 public skills — covering everything from frontend-design patterns to azure-deploy to nano-banana-pro image generation. The format won. Every serious AI coding agent — Claude Code, Cursor, OpenSeek, Codex — now ships some flavor of "loadable context package".

But there is no ranked, install-weighted, searchable index. The registry lists skills alphabetically, paginates them across dozens of pages, and doesn't surface install volume in a way you can sort. You discover a useful skill one of three ways: someone tweets it, you scroll forever, or you already know the author/repo combo. None of those scale past a few hundred skills.

So I built one. orangebot.ai/skills is a ranked, filterable index of 1,998 public Claude Code skills sorted by weekly install volume, tagged by domain, with individual detail pages for the top 50 highest-installed entries. It is the page I wanted six months ago and didn't have.

This post is the build log. Three parts: the stack (boring on purpose), the SEO crisis I walked into and the fix that shipped today, and what the install data actually says about where AI coding tools are headed in 2026.

Source registry: skills.sh. The catalog: orangebot.ai/skills.

The stack (zero infrastructure surprises)

I picked the most boring stack I could justify, on purpose. The catalog is not where I want to spend operational attention — the data pipeline and the SEO are.

Next.js 16 App Router. Server Components by default so Google sees real HTML, not a JS shell. Routing is filesystem-based, the metadata API is built in.
Firebase App Hosting. git push deploys. No manual ops, no Docker, no Kubernetes. Free tier so far.
Cron on a Linux box at home. A Python scraper runs daily on lich-ubuntu, normalizes install counts and author attribution, and writes a single ~2.5MB skills_index.json to the repo's public/data/ directory. When the file changes, the next deploy picks it up.
No database at request time. The Next.js page reads the JSON at revalidate time (every 6 hours). Firebase serves the rendered HTML. No Postgres, no Redis, no Firestore call on the hot path.

That's the whole architecture. One JSON file, one Next.js page, one daily cron. The catalog routes in the repo:

src/app/skills/page.js              # SSR catalog (server component)
src/app/skills/SkillsClient.js      # interactive island (search/filter/sort)
src/app/skills/[category]/page.js   # domain filter pages
src/app/s/[id]/page.js              # individual skill detail page (top 50)
public/data/skills_index.json       # 1,998 entries, ~2.5MB

Honest disclosure on the data freshness: skills_index.json is regenerated weekly-ish during active development as I iterate on the parser. The production cron — separate Python service on lich-ubuntu — is what stabilizes it to daily; that part is still rolling out. So treat the snapshot as recent, not "fresh this morning".

The decision I keep being asked about is "why not a database". Two reasons. First, the catalog is read-mostly and changes once a day — that is the canonical shape of a static JSON file, not a row store. Second, every database I'd add is a thing that can break at 2am while I'm asleep. A JSON file in public/ cannot break. It can be wrong, but it cannot be down.

The pillar guide that links into the catalog lives at orangebot.ai/blog/claude-code-skills-guide. It's the long-form companion — what skills are, how to install them, when to pick a skill vs an MCP server.

The SEO crisis I didn't see coming

Six months after the catalog went live, I finally opened Google Search Console. The numbers were ugly.

21 of 186 known URLs indexed. 11.3%.
151 URLs sitting in "Discovered – currently not indexed". last_crawled timestamps were the 1969-12-31 Unix epoch — Google had registered the URLs from my sitemap and then never bothered to fetch them.
The /skills page alone was getting 5,651 impressions per week but a 0.12% CTR. People were seeing the page in search results, then bouncing past it.

That is the failure mode for a content site. I had built the catalog, written the pillar guide, submitted the sitemap, and Google's verdict was a polite "no thanks". The 5,651 impressions were good news in disguise — the demand was real; the page just couldn't convert it because the SERP snippet was the generic brand tagline (no generateMetadata) and the rendered HTML was an empty client shell.

I spent a day diagnosing it instead of pushing more content. Three root causes:

Root cause 1 — the catalog page was a client component. The top of src/app/skills/page.js had 'use client'. The server-rendered HTML was an empty <div>. Googlebot does run JS, eventually, but it queues JS-heavy pages on a much slower second pass, and for low-authority sites it often skips the second pass entirely. So Google saw a blank page, picked up the brand-tagline title from the root layout, and ranked accordingly.

Root cause 2 — sitemap pollution. Next.js App Router auto-generates routes from metadata files like opengraph-image.js, twitter-image.js, icon.js. My next-sitemap.config.js was pulling all of them into sitemap.xml, plus eight stale scaffold routes I never finished (/cjobs, /mnews, /jobmatch, /jobs, /datajobs, /photographer, /prop, /startups). Google saw 173 sitemap entries, found ~18 weren't HTML and another 8 returned thin/empty pages, and started treating the whole sitemap as low-trust.

Root cause 3 — the homepage didn't link to /skills, /tools, or /digest in visible HTML. The nav was inside a <details> element that collapsed by default. Googlebot reads <details> content fine, but the absence of a prominent above-the-fold internal link to /skills meant the catalog was getting near-zero internal PageRank from the homepage.

Three causes, four commits.

The fix: 4 commits, ~180 file-changes (shipped 2026-05-23)

Four commits today, between 11:15 and 18:59 PDT: e9b4ba0 (SSR-ify /skills /tools /news, clean sitemap, add hub nav), d09e0e4 (CTR titles, EEAT author page, 5 tools SSR, news sitemap), 4442629 (P1+P2 push — 5 more tools SSR, deep compare pages, blog framework + 8 posts), 505ec1d (P3 push — 23 tools SSR, 50 skill detail pages, hub depth, OG image, newsletter). Cumulative session touched ~180 file-changes across the four commits per the P3 commit message.

Commit 1 — convert /skills and the other hub routes from client components to a server-shell + client-island pattern. This is the generally useful pattern I'd recommend to anyone running into the same problem. The shape is:

// src/app/skills/page.js  — Server Component (NO 'use client')
import fs from 'node:fs/promises';
import path from 'node:path';
import SkillsClient from './SkillsClient';

export const revalidate = 21600; // 6 hours

export const metadata = {
  title: '2,000+ Best Claude Code Skills (2026): Top Skills by Installs & Stars',
  description: 'A working library of Claude Code skills from across GitHub...',
  alternates: { canonical: '/skills' },
};

export default async function SkillsPage() {
  const raw = await fs.readFile(
    path.join(process.cwd(), 'public', 'data', 'skills_index.json'),
    'utf-8'
  );
  const allSkills = JSON.parse(raw);
  const topSkills = [...allSkills]
    .sort((a, b) => (b.installs || 0) - (a.installs || 0))
    .slice(0, 60);

  const itemListJsonLd = {
    '@context': 'https://schema.org',
    '@type': 'ItemList',
    numberOfItems: topSkills.length,
    itemListElement: topSkills.map((s, i) => ({
      '@type': 'ListItem',
      position: i + 1,
      name: s.name,
      url: s.repository,
    })),
  };

  return (
    <>
      <script
        type="application/ld+json"
        dangerouslySetInnerHTML={{ __html: JSON.stringify(itemListJsonLd) }}
      />
      <details>
        <summary>Text view · {allSkills.length} skills</summary>
        <h1>Claude Code Skills Index</h1>
        <ol>
          {topSkills.map((s) => (
            <li key={`${s.source}-${s.skillId}`}>
              <a href={s.repository}><strong>{s.name}</strong></a>
              {' '}by @{s.source} — {s.weeklyInstalls} installs/wk
            </li>
          ))}
        </ol>
      </details>
      <SkillsClient />
    </>
  );
}

The trick: the server emits the real top-60 list inside a <details> block (collapsed for users, fully readable for crawlers) plus a JSON-LD ItemList schema, and only then mounts the interactive <SkillsClient />. Google indexes the static list. Users get the interactive shell. Both reads are served from the same render.

Commit 2 — clean the sitemap. Excluded /*/opengraph-image, /*/twitter-image, /*/icon, /feed.xml, /feed.json, /feed/*, /api/*, and the eight stale scaffold routes from next-sitemap.config.js. Sitemap went 173 → 154 (cleanup), then later commits added /blog/* posts and 50 /s/[id] detail pages, bringing it to 219 URLs today. All current entries return HTML with <title> and <meta description>.

Commit 3 — visible homepage nav. Added a <nav aria-label="Site sections"> block at the top of the homepage with plain anchor tags to /skills, /tools, /digest, /news, /blog, /sources, /topics, /year/2026, /compare. No <details>, no JS, no collapse. Boring. Crawlable.

Commit 4 — depth on /tools, /blog, /s/[id], OG images, newsletter. SSR'd 33 of 36 tool pages (each with HowTo / FAQPage / SoftwareApplication / BreadcrumbList JSON-LD), shipped 13 blog posts as the editorial layer, built 50 individual /s/[id] skill detail pages, added a dynamic next/og card per blog post, and embedded Substack signup on every post page.

Expected D7 trajectory (forecast, not measured — post deploys today): indexed URLs 30-40 by 2026-05-30, 60-80 by 2026-06-06. The new /skills title — "2,000+ Best Claude Code Skills (2026): Top Skills by Installs & Stars" — replaces the generic brand tagline that was driving the 0.12% CTR. I'll update this post with measured GSC numbers once the D7 pull lands.

What the install data says about AI coding in 2026

The catalog gives a daily-updated view into which skills people actually install. Here is the top 10 by weekly installs, pulled directly from skills_index.json:

Rank	Skill	Author	Installs
1	find-skills	vercel-labs/skills	753,732
2	vercel-react-best-practices	vercel-labs/agent-skills	256,738
3	frontend-design	anthropics/skills	212,072
4	web-design-guidelines	vercel-labs/agent-skills	206,584
5	remotion-best-practices	remotion-dev/skills	182,063
6	azure-ai	microsoft/github-copilot-for-azure	146,196
7	azure-deploy	microsoft/github-copilot-for-azure	145,787
8	azure-storage	microsoft/github-copilot-for-azure	145,752
9	azure-cost-optimization	microsoft/github-copilot-for-azure	145,752
10	azure-diagnostics	microsoft/github-copilot-for-azure	145,697

Four things jump out.

find-skills is #1 with 753K weekly installs. A meta-skill — a skill whose only job is to discover other skills — outranks every domain-specific skill in the index by roughly 3x. The discovery layer is the actual moat. That's the thesis behind this entire catalog. The #1 skill is published by vercel-labs/skills, not Anthropic, which is itself a tell about who is racing to own the discovery primitive. Detail page: orangebot.ai/s/find-skills.

Microsoft owns the platform-skill volume. The microsoft/github-copilot-for-azure family ships 22 skills totaling 2.86M installs — the largest publisher in the index by total installs. The next-largest publisher is the parallel microsoft/azure-skills family at 2.29M across more skills. Combined: ~5.15M installs, all curated, all opinionated, all shipped as part of GitHub Copilot for Azure's default surface. If you're a cloud provider in 2026 and you don't have a curated skill family, you are losing this distribution channel.

Vercel is quietly the #2 publisher by reach. vercel-labs/skills (the find-skills repo) plus vercel-labs/agent-skills total 1.42M installs across very few skills — meaning per-skill leverage is higher than Microsoft's. Vercel is shipping skills that get installed almost universally rather than the broad-Azure-surface bet.

Inferen-sh and the open-source long tail are real. inferen-sh/skills totals 1.94M installs across 79 skills, mostly multimodal (image/video gen, OCR, Qwen). Six months ago "coding skills" meant test runners and migration helpers. Today image/video generation skills are colonizing the surface — because the same developer building a Next.js app is also generating OG images, hero shots, and product demos. The agent is the unified tool.

Top publishers by total installs in the current index:

Rank	Publisher	Skills	Total Installs
1	microsoft/github-copilot-for-azure	22	2,858,606
2	microsoft/azure-skills	(multiple)	2,291,209
3	inferen-sh/skills	79	1,941,845
4	github/awesome-copilot	209	1,598,674
5	coreyhaines31/marketingskills	(multiple)	873,458
6	anthropics/skills	18	757,840
7	vercel-labs/skills	1	753,732
8	supercent-io/skills-template	77	745,913

Total index: 1,998 skills, 401 unique publishers, ~19.2M cumulative weekly installs. Top 8 publishers hold roughly 60% of total volume — the power law is sharper than I expected, but the long tail of ~390 smaller publishers still matters.

The thesis I'd commit to: by Q4 2026 the meaningful divide will be "agents that ship and run skills" (Claude Code, Cursor, OpenSeek) vs "agents that just call LLMs" (everyone else). Skills become the unit of teaching an agent your stack. If your agent can't load a community skill in one command, it's a closed garden, and closed gardens lose to ecosystems.

A note on install-count interpretability: the numbers above include CI installs, scripted bulk installs, and probably some bot traffic. Treat them as a relative-popularity proxy, not a clean user count. The signal is noisy at the absolute level but the relative ranking holds up across multiple pulls.

For reference, the actual install command shape from skills_index.json:

# Install find-skills (the #1 skill, by Vercel Labs)
npx skills add https://github.com/vercel-labs/skills --skill find-skills

# Install frontend-design (by Anthropic)
npx skills add https://github.com/anthropics/skills --skill frontend-design

# Install azure-deploy (Microsoft)
npx skills add https://github.com/microsoft/github-copilot-for-azure --skill azure-deploy

One command. No package.json, no virtualenv, no Docker. That low-friction install path is what makes install counts a usable popularity signal in the first place.

What's next

The 50 highest-installed skills now have individual SEO pages at /s/[id] — searchable on Google for the skill ID directly, with SoftwareApplication + BreadcrumbList structured data and inline install instructions. That doubles the catalog's surface area for long-tail queries like "claude code find-skills install" or "azure-deploy skill setup".

The daily digest email is up next — a curated 5-skill brief delivered each morning, weighted toward newly-published skills with unusually high first-week install velocity. The signal I'm hunting: which skills are about to break out before they hit the top 50.

Open invitation: if you publish a Claude Code skill — public Git repo with a valid SKILL.md, listed on skills.sh or installable via npx skills add — the next scrape will pick it up. No submission form, no review queue, no gatekeeping. If your skill is good, the install counts will surface it on their own; if it isn't, no one will install it and that's also fine.

The live catalog is at orangebot.ai/skills. The long-form pillar — what skills are, how they compare to MCP servers, how to write one — is at orangebot.ai/blog/claude-code-skills-guide.

Go publish a skill. I'll see it on the next scrape.

I got tired of all the desktop agent tools being macOS only, so I built one for Linux.

Shen Huang — Sun, 01 Feb 2026 06:26:59 +0000

Like many of you, I’ve been messing around with OpenClaw (formerly clawdbot) and the whole "vibe coding" concept. It's cool, but finding a decent tool that actually drives the UI on Linux was a pain. Everything seems to be Mac-first right now.

Since I do all my local inference on Linux, I built a dedicated tool for it.

It's called Peepbo : https://github.com/LichAmnesia/peepbo

Basically, it's a lightweight Node/TS wrapper that connects your local VLM (LLaVA, Qwen-VL, etc) to your desktop Linux environment.

How it works:

Vision: Wraps scrot, gnome-screenshot, or gdbus so the model can see the screen.
Control: Uses xdotool to handle mouse/keyboard inputs.
Wayland: Yes, it works on GNOME Wayland, but you'll need to run in unsafe mode (details in the readme).

It's open source. Give it a shot if you're trying to build agents on Linux and let me know if it breaks anything.