DEV Community: Robin Beraud-Sudreau

Stop doing price-per-m math by hand on property alert emails

Robin Beraud-Sudreau — Tue, 27 Oct 2026 10:02:21 +0000

If you follow property alerts, you know the routine: ten emails, each with a price and a surface, and you divide in your head to see whether anything is actually cheap for the area. It is boring, error-prone, and the one good listing is usually buried.

I wrote a small Hermes skill, listing-alert-triage, that does this step for you. It is one Python file using only the standard library. No API key, no network.

It reads plain text, HTML or .eml exports, finds an amount followed by €/EUR and a number followed by m²/m2, guesses the city (Lyon 69003, 33000 Bordeaux, à Lille), and computes the price per m². You provide your own reference price per m² for each city, and it ranks listings as GEM, watch or pass. Anything absurdly cheap gets a ? because that is more often a typo or a scam than a bargain. You can also exclude by min/max surface or max price, and output text, JSON or CSV.

python3 scripts/triage.py alerts/*.eml \
  --ref Nantes=3900 --ref Rennes=3400 --max-price 400000

[watch   ] Nantes  168 000 EUR  48 m2  3 500 EUR/m2  ref 3900.0  ratio 0.90x

Honest limits: extraction is heuristic, so check the first run against the original email. It does not value anything, and it only knows euros and square metres. I tested it on synthetic fixtures only.

The skill is MIT licensed in the hermes-skills library.

Skill (MIT): https://github.com/RobinBeraud/hermes-skills/tree/main/automation/listing-alert-triage
All skills: https://github.com/RobinBeraud/hermes-skills

This post was written with AI assistance and reviewed through automated checks.

Hermes Skills Just Got Easier: One-Command Installation for AI Agent Setup

Robin Beraud-Sudreau — Mon, 26 Oct 2026 22:05:31 +0000

Hermes Skills Just Got Easier: One-Command Installation for AI Agent Setup

The Problem: Setup Friction

Getting started with AI agent skills shouldn't require navigating complex installation procedures, multiple configuration files, or lengthy documentation deep-dives. Yet that's often the reality when adopting open-source AI tools.

The Hermes AI agent community just addressed this pain point. The latest update to the hermes-skills repository introduces a one-command install section in the README—simplifying how developers bootstrap their skill environment.

What Changed?

The updated documentation now provides a streamlined installation path right at the top of the README. Instead of hunting through multiple sections or jumping between docs, users get a clear, copy-paste-ready command to get Hermes skills up and running.

This small but significant change reflects a philosophy many open-source projects are adopting: reduce time-to-first-success.

How to Use It

Head over to the hermes-skills GitHub repository and look for the one-command install section in the README. The command is designed to:

Clone or download the skills package
Install all dependencies
Prepare your environment for Hermes integration

Run it once, and you're ready to start building or using Hermes skills without wrestling configuration.

Integrating with Your Hermes AI Agent

Once installed, integrating skills with your Hermes agent is straightforward:

Discover available skills - Browse the installed skills directory
Load them into Hermes - Your agent automatically discovers compatible skills
Start using them - Skills extend your agent's capabilities immediately

Whether you're building a productivity agent, a data processing pipeline, or an automation workflow, Hermes skills provide modular, composable functionality without reinventing the wheel.

Why This Matters

Installation friction is a silent killer of adoption. Every extra step, every unclear instruction, every dependency hunt creates opportunities for developers to abandon setup and try something else.

By prioritizing clear, one-command onboarding, Hermes-skills removes barriers and lets developers focus on what matters: building intelligent agents.

Next Steps

If you're interested in:

Building custom Hermes skills - Check the repository for skill templates
Contributing to the project - PRs and community contributions are welcome
Following updates - Star the repo to stay informed about improvements

Get Started Today

Ready to supercharge your Hermes AI agent? Head to github.com/RobinBeraud/hermes-skills and give it a star while you're there. Your feedback and contributions help make this tool better for everyone.

The barrier to entry just got lower. What will you build?

Keep Secrets Out of Git: Introducing env-secrets-scanner for Hermes AI

Robin Beraud-Sudreau — Mon, 26 Oct 2026 21:58:02 +0000

Keep Secrets Out of Git: Introducing env-secrets-scanner for Hermes AI

The Problem

Accidentally committing secrets is one of the most common security mistakes in software development. A forgotten .env file, an API key hardcoded in a script, or credentials embedded in a URL can silently slip into your git history—and once it's there, it's there forever. Even if you delete it later, anyone with access to the repository can still find it by browsing the commit history.

env-secrets-scanner solves this problem by scanning your project before you commit, catching leaked secrets before they reach your repository.

How It Works

env-secrets-scanner is a lightweight Python scanner (Python 3.8+, standard library only) that runs offline with zero external dependencies. It detects:

Real .env files and key files (*.pem, *.key, id_rsa)
Private key blocks, AWS keys, GitHub tokens, Slack tokens, and Stripe keys
Credentials embedded in URLs (scheme://user:password@host)
Suspicious variable assignments like password = "..."

The best part? All findings are masked in the output, so the report itself is safe to share in a chat or ticket without exposing sensitive data.

# Scan your entire project
python3 scripts/scan_secrets.py /path/to/project

# Check only staged files before committing
python3 scripts/scan_secrets.py /path/to/repo --staged

# Get machine-readable JSON output
python3 scripts/scan_secrets.py . --json

Exit codes make it perfect for git hooks: 0 (clean), 1 (findings), 2 (usage error).

Using It with Hermes AI

The env-secrets-scanner skill integrates seamlessly into your Hermes AI agent workflow. Before pushing code or asking your AI assistant to review sensitive code, run the scanner as a security checkpoint. You can invoke it as a pre-commit skill to automatically scan staged files, or use it interactively when inheriting a new project.

If you encounter a false positive (like a deliberately exposed example password), simply add secretscan:ignore in a comment on that line.

Getting Started

The skill is available in the hermes-skills open-source repository. It requires only Python 3.8+ with no external dependencies—perfect for CI/CD pipelines and local development workflows alike.

Whether you're securing a brand-new project or auditing an inherited codebase, env-secrets-scanner gives you peace of mind before every commit.

Ready to keep your secrets safe? Star the project at https://github.com/RobinBeraud/hermes-skills and add this skill to your workflow today.

Hermes Skills Just Got a Visual Upgrade—Here's Why That Matters

Robin Beraud-Sudreau — Mon, 26 Oct 2026 21:57:36 +0000

Making AI Skills Accessible at a Glance

Imagine discovering a powerful open-source AI tool, but the first thing you encounter is a wall of text. No screenshots. No demo. Just documentation. That's the friction the Hermes Skills project just eliminated with a fresh visual update to their README.

The latest commit to the hermes-skills repository adds a professional banner and an animated demo GIF—small changes with a big impact on onboarding and adoption.

Why Visual Documentation Matters

Developers are busy. We scan before we read. A well-designed banner immediately communicates what a project is about, while a demo GIF shows working code in action—no installation required. This is especially important for AI agent skills, where users need to understand both the concept and the result quickly.

For the Hermes AI agent ecosystem, this means:

Faster decision-making: Contributors can instantly see if a skill solves their problem
Better first impressions: Open-source projects live or die by their README experience
Clearer use cases: A demo GIF speaks louder than a thousand lines of documentation

What Are Hermes Skills?

Hermes Skills are modular, composable capabilities for the Hermes AI agent. Think of them as plugins that extend what Hermes can do—from data processing to API integrations, automation tasks, and custom workflows.

Each skill is designed to be:

✓ Independent and reusable
✓ Well-documented with examples
✓ Easy to integrate into larger agent workflows
✓ Community-driven and open-source

Getting Started with Hermes Skills

Using Hermes Skills is straightforward:

Browse available skills in the repository
Review the demo (now visually!) to confirm it fits your needs
Follow the setup instructions for your specific skill
Integrate with Hermes using the provided API or configuration
Extend or customize as needed for your use case

The visual updates make steps 1-2 significantly faster, which compounds across your entire development workflow.

Why This Matters for the AI Community

As AI agents become more sophisticated, the ability to compose skills—like building blocks—becomes critical. Projects that prioritize clear documentation and user experience will naturally attract more contributors and users.

The Hermes Skills project understands this. By investing in visual communication, they're not just improving aesthetics; they're reducing cognitive load for developers evaluating, learning, and building with their tools.

Ready to Explore?

If you're working with AI agents, building automations, or looking for reusable skills to power your workflows, Hermes Skills deserves a spot in your toolkit.

Head over to the project and see what's available:

GitHub: RobinBeraud/hermes-skills

Don't forget to ⭐ the repo if you find it useful—it helps other developers discover this excellent resource!

Are you building with Hermes or exploring AI agent frameworks? Share your experience in the comments below!

Catch Secrets Before They're Committed: Meet the Env-Secrets-Scanner Skill

Robin Beraud-Sudreau — Mon, 26 Oct 2026 21:52:05 +0000

Catch Secrets Before They're Committed: Meet the Env-Secrets-Scanner Skill

The Problem: Accidental Secret Leaks

One misplaced .env file, one forgotten API key in a config, and your credentials are in git history forever. Removing them later is painful—you'd need to rewrite commits, force-push, and notify your team. The env-secrets-scanner skill for Hermes AI catches these leaks before they happen, scanning your project for exposed secrets in seconds.

How It Works

The skill uses a lightweight Python scanner (no external dependencies, no API calls) to detect common secret patterns:

Real .env files and key files (.pem, .key, id_rsa)
Private key blocks and tokens (GitHub, Slack, Stripe, AWS, Google API, JWT)
Credentials in URLs like https://user:password@database.com
Assignments such as api_key = "sk_live_..." or TOKEN=secret

It intelligently skips safe files like .env.example and .env.sample, and ignores common build folders (.git, node_modules, venv).

# Scan your entire project
python3 scripts/scan_secrets.py /path/to/project

# Or just what's staged for commit
python3 scripts/scan_secrets.py /path/to/repo --staged

The Safety Angle: Masked Output

Here's the clever part—all findings are masked in the report. Instead of showing your actual API key, it displays something like sk_live_****. This means you can safely share scan results in a Slack message, GitHub issue, or support ticket without exposing credentials.

Using It with Hermes

Integrate env-secrets-scanner into your Hermes workflow to automate security checks:

Ask Hermes to scan a project before deployment
Use it as a pre-commit hook to block unsafe commits
Run it on inherited codebases to audit for leaks

Exit codes make it perfect for automation: 0 (clean), 1 (findings), 2 (error). Chain it into CI/CD or pre-commit workflows seamlessly.

Why It Matters

Security shouldn't require third-party services or API keys. This skill runs entirely offline with Python's standard library, making it fast, portable, and trustworthy. Whether you're working solo or across a team, catching secrets before they hit git history saves hours of damage control.

Ready to add security to your workflow? Check out the env-secrets-scanner skill and more at https://github.com/RobinBeraud/hermes-skills — and don't forget to star the repo!

Catch leaked secrets before `git push`, with one stdlib Python file

Robin Beraud-Sudreau — Mon, 26 Oct 2026 21:51:53 +0000

Everyone has a story about an API key that landed in a public repo. Usually it is not carelessness: a .env file was not in .gitignore yet, or a quick test left a password in a config file, and git add -A did the rest.

Dedicated scanners exist, but sometimes you just want a fast local check with no install, no account and no network. So I wrote the env-secrets-scanner skill for Hermes Agent. It ships a single Python script using only the standard library.

It walks a folder (or just your staged files), flags real .env files while ignoring .env.example, and matches common token formats: private key blocks, AWS key IDs, GitHub and Slack tokens, JWTs, passwords inside connection URLs, and suspicious password = "..." style assignments. Placeholders like your_key_here are skipped. Output is masked (k8J*****41), so the report is safe to share.

python3 scripts/scan_secrets.py . --staged
# .env:0  [env-file]  (file name)
# cfg.py:1  [generic-assignment]  k8J*****41
# 2 finding(s)

The exit code is 1 when something is found, so it drops straight into a pre-commit hook.

It is a pattern matcher: it can miss exotic formats, does not read git history, and does not check whether a key is still valid. Treat it as a safety net before the commit, and rotate anything that already leaked.

Skill (MIT): the hermes-skills library.

Skill (MIT): https://github.com/RobinBeraud/hermes-skills/tree/main/security/env-secrets-scanner
All skills: https://github.com/RobinBeraud/hermes-skills

This post was written with AI assistance and reviewed through automated checks.

Automated Skill Validation for Hermes AI: Ensuring Quality Open-Source AI Skills

Robin Beraud-Sudreau — Mon, 26 Oct 2026 21:48:12 +0000

Automated Skill Validation for Hermes AI: Ensuring Quality Open-Source AI Skills

The Problem: Maintaining Quality at Scale

Building an open-source repository of AI agent skills is exciting—but it comes with challenges. How do you ensure every contribution maintains consistent quality? How do you catch configuration errors or accidentally committed secrets before they reach production? Manual review doesn't scale, and automated validation is non-negotiable for a trusted AI ecosystem.

The Hermes Skills project just implemented a solution that validates every pull request automatically, checking skill structure and preventing security issues before they slip through.

How It Works

The new CI/CD workflow uses GitHub Actions to run validation checks on every PR. Two key components work together:

1. Automated Validation Workflow (.github/workflows/validate.yml)
The GitHub Actions workflow triggers on every pull request, orchestrating validation checks without manual intervention.

2. Skill Validator Tool (tools/validate_skills.py)
This Python utility performs two critical checks:

Structural Validation: Ensures skills follow the required format and schema
Secrets Detection: Scans for hardcoded API keys, tokens, and sensitive credentials

When a contributor opens a PR with a new skill, the validator runs instantly. If issues are found, the PR gets feedback immediately. No broken or insecure skills make it into the main branch.

# Skills must follow the schema:
{
  "name": "skill-name",
  "description": "What this skill does",
  "version": "1.0.0",
  "parameters": [...],
  "handler": "module.function"
}

Why This Matters for Hermes AI Users

When you use Hermes AI with community skills, you want confidence. This validation ensures:

Reliability: Malformed skills won't break your agent
Security: No accidental credential leaks in shared code
Consistency: All skills follow the same standards
Trust: Community contributions are pre-vetted

Hermes AI agent developers can now safely extend their agents with third-party skills, knowing each one has passed automated quality gates.

Contributing to Hermes Skills

If you're building skills for Hermes AI, this validation makes contribution smoother:

Push your skill in a PR
Get instant feedback from the validator
Fix any issues and push again
Once validation passes, maintainers review your code
Merge and ship!

No more "why did my PR get rejected?" moments—the validator tells you exactly what needs fixing.

Join the Movement

Hermes Skills is building the foundation for trustworthy, community-driven AI agent capabilities. Every validated skill makes Hermes AI more powerful and reliable.

Interested in contributing? Want to build skills that thousands of developers will use? Check out the repository and see what's possible.

Star the repo and join the community: https://github.com/RobinBeraud/hermes-skills

The future of AI agents is collaborative—let's build it together.

Two new Hermes Agent skills: a keyless research router and hand-drawn diagrams for social posts

Robin Beraud-Sudreau — Mon, 26 Oct 2026 20:58:11 +0000

The open-source skills library for Hermes Agent just grew to 28 skills. Two new ones this week:

Data Intelligence Router. One keyless adapter (dataapi.py) to query open data sources (OpenAlex, Crossref, arXiv, World Bank, ECB, Wikipedia, NVD, Open Library...) and get the same normalized JSON every time: provider, query, retrieval date, source URL, cache flag. The skill adds routing rules (which source for which question), cross-checking, and a hard rule: say what is a preprint, what is delayed data, and never claim "real time" on free feeds.

Note Visual. Minimalist hand-drawn style diagrams (compare, 2x2 matrix, funnel, steps) generated with Pillow, so every word is exact, unlike image models. Perfect as the picture of a one-line post on Substack Notes or LinkedIn. They are illustrations of concepts, never invented data.

Also in this update: a fixed waitlister skill and an updated README.

Repo: https://github.com/RobinBeraud/hermes-skills (MIT). Contributions welcome via pull request.

Automate Your X/Twitter Workflow with Hermes Tweet: A New AI Agent Skill

Robin Beraud-Sudreau — Sun, 05 Jul 2026 15:33:56 +0000

Automate Your X/Twitter Workflow with Hermes Tweet: A New AI Agent Skill

The Problem: Manual Social Media Monitoring Wastes Time

Managing X/Twitter presence at scale is exhausting. Whether you're monitoring brand mentions, researching competitor activity, or managing community engagement, doing it manually drains productivity. What if your AI agent could handle Twitter research, monitoring, and approved actions automatically?

That's exactly what Hermes Tweet solves—a new marketing skill for the Hermes AI agent that brings X/Twitter automation directly into your AI workflows.

Introducing Hermes Tweet

Hermes Tweet (version 0.1.6) is an open-source skill developed by Xquik that extends Hermes Agent with powerful Twitter/X capabilities. It lets your AI agent:

Search and explore tweets with native Twitter search
Read tweet replies and details for deeper context
Look up user profiles and analytics
Monitor tweet activity in real-time
Export followers for analysis
Gate X actions through Xquik's secure API

How It Works

Hermes Tweet uses three core tools under the hood:

tweet_explore    → Search tweets and discover content
tweet_read       → Fetch tweet details and reply threads
tweet_action     → Execute approved X/Twitter actions

The skill requires network access and environment variables for authentication:

XQUIK_API_KEY                    # Your Xquik API credentials
HERMES_TWEET_ENABLE_ACTIONS      # Enable/disable actions
HERMES_ENABLE_PROJECT_PLUGINS    # Allow trusted plugins

Getting Started with Hermes Agent

Installing Hermes Tweet takes just two commands:

hermes plugins install Xquik-dev/hermes-tweet --enable
hermes tools list

Then set your XQUIK_API_KEY in your Hermes runtime environment—never paste it directly in chat.

Once installed, you can start using natural language prompts with your Hermes Agent:

"Search for tweets mentioning our product launch"
"Get replies to this tweet URL"
"Find followers of @username"
"Monitor mentions of our brand"

The skill handles authentication, API routing, and action gating automatically.

Why This Matters for AI Automation

Hermes Tweet bridges the gap between general-purpose AI agents and specialized social media workflows. Instead of switching between tools, your Hermes Agent now has native Twitter capabilities—perfect for:

Content teams researching trends
Community managers monitoring conversations
Marketing analysts tracking campaign performance
Growth teams discovering influencers

The skill is MIT-licensed and actively maintained by the Xquik team.

Ready to Automate?

Hermes Tweet is now part of the official Hermes skills collection. Check out the full implementation and contribute:

⭐ Star the Hermes Skills repo to stay updated on new AI agent capabilities.

Get started today and let your AI agent handle the Twitter grunt work.

Cleaning Up Personal References: How Hermes Skills Maintains Security Best Practices

Robin Beraud-Sudreau — Thu, 02 Jul 2026 12:50:35 +0000

Cleaning Up Personal References: How Hermes Skills Maintains Security Best Practices

Security in open-source projects isn't just about cryptography and authentication—it's also about preventing accidental exposure of personal data. The Hermes Skills repository just completed a comprehensive security audit, removing lingering personal references that could compromise user privacy.

The Problem: Hidden Personal Data in Documentation

When teams iterate quickly on documentation and examples, personal details can slip through: email addresses in config files, usernames in screenshots, internal URLs, or hardcoded identifiers. While these might seem harmless, they create security vectors and violate privacy principles. The recent cleanup across voxtral-tts, neuronwriter, and other skills demonstrates a mature approach to open-source maintenance.

What Changed

The commit focused on three skill modules:

media/voxtral-tts: Mistral's voice cloning API documentation now uses sanitized voice ID examples
seo/neuronwriter: NeuronWriter integration now removes any site-specific URLs or internal references
README.md: Updated to reflect these changes across the board

These aren't breaking changes—they're hygiene improvements that make the codebase safer for everyone.

Best Practices for Your Own Projects

If you maintain open-source tools, here's what you can learn:

Audit documentation regularly: Search for domain names, email patterns, and UUIDs that might be personal
Use placeholder syntax: Replace real values with clearly marked placeholders like $YOUR_API_KEY or your-domain.com
Review before publishing: Have a checklist: Are there hardcoded URLs? Environment variables? User IDs?
Make it reproducible: Ensure examples work for anyone without requiring personal configuration

How This Improves Hermes Skills

Hermes AI agent users benefit from cleaner, more portable skill definitions. When you integrate the voxtral-tts skill for voice cloning or neuronwriter for SEO optimization, you're working with documentation that prioritizes your privacy while maintaining complete functionality.

The skills still do everything they did before—generate speech with Mistral's API, analyze SEO with NeuronWriter—but now they do it without exposing anyone's personal infrastructure.

Next Steps

If you use Hermes Skills or contribute to the project, you'll notice smoother integration with fewer configuration gotchas. Documentation is now truly generic and reusable.

Want to see the full scope of available skills? Check out the repository and star it if you find it useful:

⭐ github.com/RobinBeraud/hermes-skills

Security through simplicity. That's the Hermes way.

Hermes AI Skills Just Got More Secure: Personal Data Removed from Published Skills

Robin Beraud-Sudreau — Thu, 02 Jul 2026 12:48:24 +0000

The Problem

When building open-source AI agent skills, it's easy to accidentally expose sensitive information in documentation—API keys, personal model IDs, user emails, or custom configuration details. Once published to a repository, this data becomes a security liability for anyone using your skills.

The Hermes AI agent community just took a major step toward fixing this with a significant security push across seven popular skills.

What Changed

A recent commit to the hermes-skills repository removed all personal and sensitive data from published skill documentation. Skills affected include:

marketing/waitlister — removed example waitlist keys and personal URLs
media/photogpt — stripped personal model IDs
media/voxtral-tts — cleaned up voice clone references
media/youtube-content — removed example channel data
productivity/mural — eliminated workspace identifiers
seo/neuronwriter — removed project-specific credentials
wordpress/wpbakery — scrubbed site-specific URLs

Why This Matters

Each skill's documentation now uses placeholder variables (like $YOUR_API_KEY, YOUR_WAITLIST_KEY) instead of real values. This pattern:

✅ Prevents accidental credential leaks

✅ Makes it clearer where users need to insert their own data

✅ Reduces social engineering attack surface

✅ Follows security best practices for open-source projects

How It Works with Hermes

When you use a skill with the Hermes AI agent, it reads credentials from your local environment (typically ~/.hermes/.env). The documentation now explicitly guides you to store sensitive data there:

# In ~/.hermes/.env
WAITLISTER_API_KEY=your_actual_key_here
PHOTOGPT_API_KEY=your_actual_key_here
MURAL_ACCESS_TOKEN=your_actual_token_here

Then skills reference these variables without exposing them in git history or public documentation.

What You Should Do

If you're using any of these skills:

Pull the latest changes — git pull to get the security update
Review your .env file — ensure all credentials are stored locally, not in code
Check your git history — if you've forked the repo, verify no secrets were committed
Update your skill configs — replace any hardcoded values with environment variable references

Contributing Secure Skills

If you're building new skills for Hermes, this commit sets the standard:

Use environment variables for all credentials
Document how to find/generate API keys, but never include examples of real keys
Use placeholder names that make it obvious what needs replacing
Store sensitive docs in private wikis, not public repositories

This is a great reminder that security in open-source isn't just about code—documentation matters too.

Get Involved

The Hermes AI agent is built by the community. If you've spotted other sensitive data in skills or want to contribute a new skill securely, check out the repository and help strengthen the ecosystem.

⭐ Star hermes-skills on GitHub to stay updated on security improvements and new skill releases.

4 New Skills for Hermes AI: Email Marketing, DNS Management, YouTube Moderation & SEO Automation

Robin Beraud-Sudreau — Wed, 01 Jul 2026 16:11:37 +0000

4 New Skills for Hermes AI: Email Marketing, DNS Management, YouTube Moderation & SEO Automation

The Hermes AI agent just leveled up. Four fresh open-source skills are now available to automate email campaigns, manage your DNS infrastructure, moderate YouTube comments, and continuously optimize WordPress sites for search engines.

The Problem

Managing multiple platforms drains time and focus. You're juggling SendFox for newsletters, Gandi for domains, YouTube's comment section, and SEO tools scattered across different tabs. Hermes unifies these workflows into conversational, reusable skills.

What's New?

1. SendFox — Email Marketing Automation

Manage your entire email operation through API calls:

add_contact("contact@example.com", "newsletter", tags=["VIP"], first_name="Alice")
campaign_stats = get_campaign_stats(campaign_id)

Create lists, segment contacts, launch campaigns, and track opens/clicks—all without leaving your AI agent.

2. Gandi — Domain & DNS Management

Stop logging into Gandi's dashboard. Ask Hermes instead:

domains = gandi("GET", "domain/domains")
records = gandi("GET", "livedns/domains/example.com/records")

List domains, check expiration dates, modify DNS records, configure email redirections, and verify your infrastructure—all programmatically.

3. YouTube Comment Management — Moderation & SEO Linking

Stay on top of YouTube comments with:

yt_cm_pending.py — Find unanswered comments across your channel
yt_cm_act.py — Reply or reject comments in bulk
Built-in SEO interlinking to WordPress sites

The skill handles the critical youtube.force-ssl scope requirement so you can actually authenticate and moderate at scale.

4. SEO Optimizer — Continuous Content Improvement

A two-loop system that:

Optimizes existing pages — Fetches your Google Search Console data, identifies high-potential pages, scores them with NeuronWriter, improves content with Claude, and auto-publishes via WordPress.
Creates new articles — Detects genuinely searched topics and generates fresh content on demand.

Run daily: 3 pages → NeuronWriter analysis → Content improvement → Live

How to Use with Hermes

Each skill is drop-in ready. Just set your API keys in .env:

SENDFOX_API_KEY=your_key
GANDI_API_TOKEN=your_token
NEURONWRITER_API_KEY=your_key
GSC_TOKEN=path/to/token.json

Then talk to Hermes naturally:

"Add alice@example.com to my VIP list in SendFox"
"What's the expiration date of my domains?"
"Show me unanswered YouTube comments from the last week"
"Run my daily SEO optimization cycle"

Hermes handles authentication, pagination, error handling, and rate limits transparently.

Why This Matters

These aren't fancy wrappers—they're battle-tested integrations built to solve real workflow friction. The YouTube skill, for example, documents critical gotchas like scope requirements and token-swapping behavior. The SEO skill integrates four different systems (GSC, NeuronWriter, Claude, WordPress) into a cohesive daily routine.

Get Started

All four skills are open-source and ready to use. Check out the repo, explore the skill definitions, and start automating:

Star the hermes-skills repo →

If you build something cool with these skills, share it in the comments. The community is growing, and every integration makes Hermes smarter.