DEV Community: Israel Saba

5 Portable Agent Skills for OpenCode and Claude Code

Israel Saba — Wed, 19 Aug 2026 21:19:48 +0000

Agent Skills turn repeated prompts into reusable, inspectable workflows.

This collection includes five small skills for work that comes up often when building with OpenCode or Claude Code: reviewing public copy, checking text limits, capturing public webpages as PDFs, sending task notifications, and structuring research for later use.

The full index is available at Published Agent Skills.

For OpenCode, Skills can live in ~/.config/opencode/skills/ or project-level locations supported by your setup. Claude Code can discover Skills from .claude/skills/. Put a Skill folder in the right location, restart the agent session if needed, and it becomes available when the task matches its description.

1. AI Writing Detector Skill

AI Writing Detector Skill reviews English and Brazilian Portuguese copy for patterns that make AI-written text feel generic.

It checks common issues such as repeated sentence rhythm, filler phrases, excessive formatting, and em-dash use. It also ships with a CLI and MCP server for text and file linting.

Useful prompts:

Review this README introduction with the anti-ai-tells Skill. Keep the technical facts, flag generic wording, and suggest direct replacements.

Run the writing linter on this release post, then rewrite only the passages that need attention.

This is useful before publishing documentation, launch posts, landing pages, and changelogs.

2. Text Counter Skill

Text Counter Skill gives exact counts for characters, words, sentences, paragraphs, lines, graphemes, bytes, and phrase occurrences.

It helps when "roughly under the limit" is not enough.

Useful prompts:

Write a 155-character meta description for this package and verify its exact character count.

Reduce this GitHub issue title to 80 characters without removing the error code.

Count the phrase "OpenCode" in this Markdown file.

The Skill makes counting rules explicit. That avoids surprises with spaces, Unicode characters, emoji, or repeated phrases.

3. HTML to PDF Skill

HTML to PDF Skill converts authorized public webpages into readable, browser-rendered PDFs.

The workflow uses Playwright and Chromium, waits for page assets, handles common cookie dialogs, removes ad blocks, and records the source URL and access time in each PDF footer.

Useful prompts:

Capture these public API documentation pages as PDFs for offline review.

Create a readable PDF copy of these public release notes and verify the page count.

This is practical for research, design reviews, long documentation pages, and internal reading packs.

4. ntfy Skill

ntfy Skill sends safe completion, failure, or blocked notifications for agent tasks that may take longer than 30 seconds.

It encourages a simple rule: estimate task duration before starting. If the work may take a while, notify the user once when it finishes or needs input.

The Skill keeps tokens out of repositories, shell history, URLs, and notification content. It supports ntfy.sh and approved self-hosted ntfy servers.

Useful prompts:

This export may take several minutes. Use the ntfy Skill to notify me once the final files are ready.

Before sending an ntfy message, confirm the token comes from the operating system credential store.

5. Open Knowledge Format Skill

Open Knowledge Format Skill creates source-linked Markdown research bundles for people and agents.

A bundle can include an index, a research report, an AI summary, source tables, evidence tables, and related output files. It separates facts from interpretation and points claims back to their sources.

Useful prompts:

Package this research into an OKF bundle with source links, evidence rows, caveats, and open questions.

Create an ai_summary.md that another agent can use to continue this investigation safely.

This helps when research needs to survive longer than one chat session.

A Small Workflow That Works

A developer can combine these Skills in a normal agent session:

Research a topic and save findings with the Open Knowledge Format Skill.
Draft documentation or a blog post.
Use Text Counter for title, description, and social-post limits.
Run AI Writing Detector before publication.
Capture public references as PDFs when visual records matter.
Use ntfy for long-running exports, tests, or browser tasks.

No large framework is required. Each Skill is a focused Markdown file with optional scripts where automation adds value.

Try the Collection

Stop wasting time on vibe coding

Israel Saba — Tue, 13 Jan 2026 00:24:34 +0000

Have you ever left Claude Code to chew on a hard task, only to learn it stopped 1s after you were out?

Giving Claude Code full access to your computer is not the wisest decision, so the next safest alternative is actually deciding on permission queries that need your attention.

So, assuming you took the safest route, as I did, there is a way to not lose queries from Claude code when you are away from your desk, and I explain it here.

Please note the Roadmap, where I will add a way to make decisions on the go too.^**

How to tackle the problem

We will use an open-source app called ntfy that sends custom notifications directly to your mobile. It can be installed on your iOS or Android mobile and you can use it for free.^***

Option 1 - Quick-win

Use ntfy claude, as opposed to self-hosted, without a de-bouncer

NTFY Setup

Sign-up at ntfy app

Sign-in and access your dashboard
Click Subscribe to topic

Click GENERATE NAME^* -> SUBSCRIBE and take note of the topic

Click on your avatar at the top -> Click your username
At Access tokens click Create access token, choose a name (e.g. claude-code), click CREATE TOKEN and take note of the created token (it is always available at the user settings).

Download NTFY app to your mobile and enable notifications
Sign-in to your ntfy account in the app (make sure you are subscribed to topic created on 4.)

Claude Code Setup

Edit ~/.claude/settings.json (create if needed) to have it as below

{
  "hooks": {
    "PermissionRequest": [
      {
        "matcher": "*",
        "hooks": [
          {
            "type": "command",
            "command": "curl -H 'Authorization: Bearer <your-token-from-step-6-above>' -v -L -d 'Claude Code is requesting your input to move on' ntfy.sh/<topic-ntfy-step-4>"
          }
        ]
      }
    ],
"Stop": [
      {
        "matcher": "*",
        "hooks": [
          {
            "type": "command",
            "command": "curl -H 'Authorization: Bearer <your-token-from-step-6-above>' -v -L -d 'Claude Code has finished working' ntfy.sh/<your-topic-name-from-step-4>"
          }
        ]
      }
    ]
  }
}

Start a new claude session and enjoy!

Option 2: de-bouncing add-on

To avoid multiple notifications at the same time we can add a de-bouncer.

Create the de-bouncer script at the path ~/.claude/scripts/ntfy-debouncer.sh below

#!/usr/bin/env bash
set -euo pipefail

NTFY_SERVER_URL="ntfy.sh"
NTFY_TOPIC="<your-topic-name-from-step-4>"
LOGFILE="/tmp/ntfy-hook.log"
TOKEN="<your-token-from-step-6-above>"

exec >>"$LOGFILE" 2>&1

LOCKFILE="/tmp/claude-notify-last"
COOLDOWN=30


if [[ -f "$LOCKFILE" ]]; then
  LAST="$(cat "$LOCKFILE")"
  NOW="$(date +%s)"
  if (( NOW - LAST < COOLDOWN )); then
    exit 0
  fi
fi
date +%s >"$LOCKFILE"

MSG="${1:-}"
[[ -n "$MSG" ]] || exit 2

curl -v \
  -H "Authorization: Bearer ${TOKEN}" \
  -L \
  -d "$MSG" \
  "https://${NTFY_SERVER_URL}/${NTFY_TOPIC}"

Chmod the script

chmod +x .claude/scripts/ntfy-debouncer.sh

Update ~/.claude/settings.json to use it

{
  "hooks": {
    "PermissionRequest": [
      {
        "matcher": "*",
        "hooks": [
          {
            "type": "command",
            "command": "$HOME/.claude/scripts/ntfy-debouncer.sh 'Claude Code is requesting your input to move on'"
          }
        ]
      }
    ],
"Stop": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "$HOME/.claude/scripts/ntfy-debouncer.sh 'Claude Code has finished working'"
          }
        ]
      }
    ]
  }
}

Option 3: token security

Create a keychain entry on your terminal

security add-generic-password -a "$USER" -s "ntfy.sh" -w "<your-token-from-step-6-above>" -U

at ~/.claude/scripts/ntfy-debouncer.sh paste

#!/usr/bin/env bash
set -euo pipefail

NTFY_SERVER_URL="ntfy.sh"
NTFY_TOPIC="<your-topic-name-from-step-4>"
LOGFILE="/tmp/ntfy-hook.log"

exec >>"$LOGFILE" 2>&1

LOCKFILE="/tmp/claude-notify-last"
COOLDOWN=30


if [[ -f "$LOCKFILE" ]]; then
  LAST="$(cat "$LOCKFILE")"
  NOW="$(date +%s)"
  if (( NOW - LAST < COOLDOWN )); then
    exit 0
  fi
fi
date +%s >"$LOCKFILE"

MSG="${1:-}"
[[ -n "$MSG" ]] || exit 2

# Storing the token
# security add-generic-password -a "$USER" -s "ntfy.sh" -w "tk_XXX" -U

TOKEN="$(security find-generic-password -a "$USER" -s "$NTFY_SERVER_URL" -w 2>/dev/null || true)"
if [[ -z "${TOKEN}" ]]; then
  echo "ERROR: token not found in Keychain (service: ntfy.israelsaba.com.br, account: $USER)" >&2
  exit 3
fi

curl -v \
  -H "Authorization: Bearer ${TOKEN}" \
  -L \
  -d "$MSG" \
  "https://${NTFY_SERVER_URL}/${NTFY_TOPIC}"

Roadmap

Other things I'd like to explore/write about regarding this. Let me know what you would like first. Do let me know your thoughts and any extra tips.

[X] ~~Explore a more secure option using MacOS secrets to store the NTFY token~~
[ ] Write about my self-hosted instance of ntfy and how I connect it here
[ ] Explore using the "Notification" hook on Claude Code

^{reference docs: Claude Code hooks, NTFY}

^{*It is important to generate a random topic name as this is a public platform. If you name it claude-code for instance, anyone who has done the same will be able to push notifications to your ntfy. That can be solved by running a self-hosted instance.}

^{**Do check this NetworkChuck's video on the matter. It solves the same problem with n8n and Slack, and it even includes a way to answer the prompt on the go.}

^{***Tutorial made using MacOS as base. Although shell script shebang is designed for maximum compatibility.}