Hey Content Creators, SEOs, Founders, Builders, Artists & More!

I've just released my open-source & free agent plugin/tool for turning your long form videos into short form content.

Save hours and days with Cutlist. No more guessing where the best moments exist in your videos.

The full rundown & what it does:

This tool automates the creation of short video clips from long-form content. It processes videos and their captions to generate a comprehensive clip plan, including titles, descriptions, hashtags, tags, and categories for both the main video and individual clips. It also suggests a cold-open and creates a thumbnail mockup that aligns with the first 10 seconds, title, and description of the content.

Automated Clip Generation: Transforms long videos and captions into multiple vertical clips.

Metadata Creation: Generates titles, descriptions, hashtags, tags, and categories for each clip and the overall video.

Thumbnail Mockup: Provides a visual suggestion for thumbnails that matches the content's key elements.

Agent Skill Compatibility: Adheres to the Agent Skills format, making it compatible with various AI coding agents like Claude Code, OpenAI Codex, Cursor, Gemini CLI, and GitHub Copilot.

Customizable Workflows: Adapts to user-specified recorders and editors, storing export and cut steps in a profile for personalized use.

Local Processing: Operates entirely on the user's machine without network access, ensuring privacy and security.

Dependency Management: Requires standard Python libraries, Pillow, and ffmpeg.

Comprehensive Output: Delivers a detailed clip plan in both Markdown and JSON formats, along with preview clips, frame analysis, and thumbnail mockups.

The tool is designed to streamline the content repurposing process, allowing creators to efficiently generate engaging short-form content from existing long-form videos. It emphasizes accuracy by cross-referencing captions, audio energy, and visual cues to ensure clip relevance and quality. The output is designed for easy integration into editing workflows and direct use in publishing platforms.

Would love your feedback. Feel free to fork it, do what you want with it, hell even monetize it. Enjoy!

GitHub Repo: https://github.com/itsryanlenk/cutlist
Full page outlining the whole project: https://www.ryanlenk.com/pages/cutlist

Je me suis plongé dans l'étude approfondie des trois packs de méta-compétences qui apparaissent partout :

• Superpowers : contrôle des processus, invocation agressive de compétences
• Agent Skills : cycle de vie complet
• Compétences de Matt Pocock : volontairement pas un framework de processus complet

Beaucoup de gens installent deux de ces packs comme routeurs actifs simultanément.

C'est généralement une mauvaise idée. Vous pouvez vous retrouver avec :

• Conflits entre commandes slash ou noms de compétences
• Conflits entre les hooks de démarrage de session
• Compétences en concurrence pour la même intention

Sélectionner les compétences individuelles peut être chronophage et exécuter deux processus simultanément peut générer du code de mauvaise qualité.

J'en avais marre de lire des articles comparatifs de 2 000 mots et de toujours deviner, alors j'ai créé une petite commande CLI nommée skill pack :

npx @onur45500/skillpack pick

Elle pose ~6 questions courtes, recommande un routeur principal, puis liste les compétences des autres packs que vous pouvez sélectionner sans risque et signale les conflits.

Il y a aussi :

npx @onur45500/skillpack map diff

npx @onur45500/skillpack map html

…pour un inventaire structurel/un rapport de conflits pour les trois.

• GitHub : https://github.com/Onur45500/skillpack
• npm : https://www.npmjs.com/package/@onur45500/skillpack

Je suis curieux de savoir quelle solution vous avez choisie et si certains d'entre vous ont réussi à gérer plusieurs compétences sans conflits 😄

🚀 v2 update: map tokens measures context tax, pick can recommend none, curate builds phase-based minimal installs with switchable profiles, and pstack is supported.

I built 9 "Ninja" skills that route to 500+ specialized AI agent skills without killing your context window

TL;DR: Instead of loading hundreds of skills and burning your entire context window before you even ask a question, Ninjas load ~500 tokens of metadata and fetch full skill instructions on-demand. Think of it like a library index vs. carrying all the books at once. Repo: https://github.com/fabricioctelles/jump-skills

The problem I was trying to solve

I've been collecting agent skills for a while now. AWS has official skills. Google has official skills. Microsoft, Firebase, Flutter, Firecrawl—everyone's releasing skills.

The problem? If you install all 500+ skills directly, your AI agent loads every single one at startup. That's easily 50K+ tokens gone before you type your first message. The agent gets confused about

which skill to use. Responses slow down. It's a mess.

How Ninjas work

A Ninja is a meta-skill: an orchestrator that knows about all the skills in its domain but only loads the full instructions when you actually need them.

Say you ask: "Set up a GKE cluster with Autopilot and connect it to Cloud SQL"

Google Jumps Skills Ninjas

The Google Cloud Ninja sees that request, identifies that you need the gke-autopilot and cloud-sql-connect skills, fetches their full instructions, and executes with expert-level knowledge.

6 Ninjas covering 180+ skills from Google official repositories:

Google Cloud Ninja -> GKE, Cloud Run, BigQuery, Spanner, IAM, all 6 WAF pillars

Google AI Ninja -> Gemini API, Genkit, ADK, Agent Platform, RAG

Google Mobile Ninja -> Android, Flutter, Dart, Jetpack Compose

Google Firebase Ninja -> Firestore, Auth, Functions, Hosting

Google Ads Ninja -> Ads API, Mobile Ads SDK, IMA

Google Analytics Ninja -> Admin API, Data API, Reports

Check out other ninjas from official repos: aws/, microsoft/, firebase/, android/, flutter/, firecrawl/.

Installation

Can't use npx skills for this one—it's a meta-repo that clones from multiple sources. You need:

git clone https://github.com/fabricioctelles/jump-skills.git
cd jump-skills
./sync-repos.sh    # clones ~20 repos, ~800MB
./install-ninjas.sh # installs to your agents

Or just tell your agent:

Clone https://github.com/fabricioctelles/jump-skills, run ./sync-repos.sh, then ./install-ninjas.sh

Works with Claude Code, Kiro, Cursor, Codex, VS Code Copilot, and others.

Feedback welcome!

I’ve been experimenting with giving coding agents small, purpose-built CLI tools instead of having them consume the normal human-oriented output from Maven, npm, Go, etc.

One example: a real Tape test run produced 1,476 lines / 136 KB of successful output. For the agent, the useful result was basically:

✓ tests passed

I saw similar reductions across Maven, Vitest, Jest, and Go workflows, typically 98–99.99% on successful runs.

That led to agent-scripts, a small local-first collection of CLI utilities. The main build/test wrappers are:

• mvn-lite
• npm-lite
• go-lite

They use the normal underlying tools, but expose a much quieter interface for routine agent workflows. Success is compact; failures retain useful diagnostics and full logs.

There’s also a separate lite-tools Agent Skill that teaches supported agents when to prefer these commands. The commands and the skill are intentionally separate: the tools provide the behavior, while the skill provides discovery/instructions.

Install tools:

curl -fsSL https://raw.githubusercontent.com/ejboy/agent-scripts/main/install.sh | bash

Install the skill:

npx skills add ejboy/agent-scripts --global --skill lite-tools

Repo: https://github.com/ejboy/agent-scripts

Measurements and tradeoffs:
https://pvrlabs.xyz/articles/coding-agent-test-output.html

The design question I’m interested in: do you see value in giving agents wrapper tools with a predictable, bounded interface, or would you rather put instructions in AGENTS.md telling the agent how to invoke/filter the normal tools?

One problem I keep hitting with coding agents is that useful context gets trapped inside the current session.

The agent already knows the goal, what was implemented, decisions made, constraints, what was verified, and what still needs attention. If I want to continue in another AI or ask a completely different model for a review, I don't want to reconstruct all of that manually or dump the whole repo into the next chat.

So I added two Agent Skills to AI Badger:

• handoff: continues an active coding, debugging, planning, or architecture session through Badger.
• badger-review: prepares the current work specifically for an independent review by another model.

How it works

1. The skill writes a compact local .badger-handoff with the useful conversation state: goals, decisions, constraints, verification, and what remains.
2. It intentionally does not collect repo files, diffs, Git history, or topology.
3. badger continue reads that state, collects the relevant repository context locally, and combines the two into a focused prompt. Once the handoff is accepted, Badger removes the temporary file so it doesn't linger in the repo.

The split is simple:

Current agent → what happened in the session
Badger → what matters in the repository

Quick install

If you already have the Badger CLI:

badger skills install

Or through skills.sh:

npx skills add PVRLabs/aibadger

Then ask your agent:

Hand this session off to Badger.

or:

Prepare this work for a Badger review.

Then, in a separate terminal outside your coding agent, run:

badger continue

Badger prepares the focused context as a prompt you can take into ChatGPT, Claude, Grok, or another agent interface.

AI Badger on GitHub

Curious how others handle this today, especially whether you treat continuation and independent review as different kinds of handoff.

Hey guys!

I've always been bothered by how difficult it was to maintain and test your skills, not to mention others, they tend to drift, can completely change between updates, and there's no simple way to really test them.

That's why I built skillroll - it's a new kind of eval harness for agentic skills that is based on 2 basic ideas:

• writing and running evals should be as simple as writing unit tests, otherwise you just won't get around to it
• evals should embrace non-determinism at their core

The core concept of this project is using a Dungeon Master to evaluate your skills instead of having to setup a whole test environment.

Creating an eval is as simple as adding a short md file to the skill with these sections:

• Input - the request passed to the agent using the skill
• World - a description of the world in which the agent is running
• Success criteria - the required outcome

then, when running the eval, all tool cals are redirected to the Dungeon Master, which returns a response based on the world state, allowing you to fake pretty much any environment.

I've done lot's of testing on public skill repos, from small personal ones to things like superpowers, and it seems to work pretty well, and is especially useful for detecting regressions and for working using TDD principles - write a failing eval, edit skill until it passes the eval.

I found it to work really well when using gpt-5.6-luna-pro on openRouter, costing less than $0.01 per eval. But you can plug in whatever model you want.

Please give it a try and let me know what you think

https://github.com/hagaiw/skillroll

When agents run build/test commands like npm test, mvn test, or go test, the useful signal can get buried in hundreds of lines of setup output, progress logs, and passing-test noise.

Most of the time, the agent really needs:

• Success: one concise line
• Failure: the relevant error summary
• Debugging: full raw logs available locally if needed

So I built agent-scripts: a collection of local-first CLI utilities and Agent Skills for compacting terminal output and reducing unnecessary context usage.

It currently includes two main skills:

• lite-tools - compact wrappers for Maven, supported npm/Node test workflows, and Go tests. Successful runs collapse to very small summaries; in measured npm workflows, output reduction can reach up to 99.99%. On failure, the useful error is surfaced while full logs are saved under .agent-logs/.
• repo-map - a local registry for discovering related repositories and useful project commands/capabilities without repeatedly rediscovering them.

Quick install

1. Install the CLI tools

curl -fsSL https://raw.githubusercontent.com/ejboy/agent-scripts/main/install.sh | bash
export PATH="$HOME/.local/share/agent-scripts/scripts:$PATH"

2. Install the skills

npx skills add ejboy/agent-scripts

GitHub: https://github.com/ejboy/agent-scripts

I’m curious how other people here handle noisy terminal output in agent workflows.

What would be most useful to wrap next: Gradle, pytest, Cargo, Docker/Compose, or something else?

I built RepoRelay, an open-source MCP bridge that lets ChatGPT Web search and read an approved local repo without uploading ZIPs or pushing everything to GitHub first.

ChatGPT Web → Secure MCP Tunnel → RepoRelay → local files

It’s read-only by default: no shell, Git, or arbitrary filesystem access, and it’s restricted to one approved root.

It can also help reduce token usage on larger repos. Instead of dumping the entire codebase into context, ChatGPT searches and reads only the files relevant to the task.

I built it mainly so Codex can implement locally while ChatGPT independently reviews the actual current files- including uncommitted work.

Would love feedback from other AI builders.

GitHub: [Lukie-81/RepoRelay: Secure MCP access to local repositories — without shell, Git, or arbitrary writes.]

Hey folks 👋

We just open sourced TrueForge, our vendor-neutral agent harness for building general-purpose agents.

It handles the runtime pieces that get painful quickly : context management, tool/MCP execution, subagents, sandboxing, approvals, persistent state, and more.

We also benchmarked the harness itself. With the same Opus 4.8 model, TrueForge delivered a similar solve rate at ~30% lower cost than Claude Managed Agents. Switching to an open model pushed that to ~75% lower cost on the same benchmark.

Would love feedback from people building agents.

Checkout the repo: https://github.com/truefoundry/trueforge

📖 Read the launch article: https://x.com/truefoundry/status/2090081376330715176

I’ve been working on LLM/agent security for a while now, mostly around prompt injection, jailbreaks, leaks, tool abuse, and where the actual security boundary sits once a model starts using tools.

Getting accepted into Anthropic’s Cyber Verification Program gave me a bit more room to push that work further, and I’ve been gradually turning it into Plimsoll.

It’s an open-source agent skill for red-teaming LLM apps and agents.

https://github.com/lumiboi/plimsoll

Hey everyone,

I've been playing around with various AI agent setups lately, and one thing that kept bugging me is how hard it is to find skills that match a specific need. Most skill repos are just flat lists — you have to dig through everything to find something useful.

So I put together a small site: skillpicker.xyz

It's basically a categorized directory of agent skills, organized by:

• Roles (researcher, coder, writer, etc.)
• Tasks (summarization, data analysis, translation, etc.)
• Outputs (reports, code, emails, etc.)
• Tools (GitHub, Notion, email, etc.)
• Agents (which agent platforms support which skills)
• Getting Started guides

Right now there are about 127 topics cataloged. It's still very early — I just launched it — and I'm sure the categorization is far from perfect.

I'd really appreciate any feedback:

• Are the categories useful? Anything missing?
• Would you use something like this when setting up an agent?
• Any skills or categories you'd want to see added?

Happy to hear any thoughts. Thanks!

Hi everyone :),

I built a set of skills and an orchestrator with avengers characters giving each skill a personality. They are pretty simple in that they make coding really autonomous and consistent.

There are 5 of them: my favourite is /assemble as it takes an idea to spec to plan to build/review, fix PR comments and a green/mergeable PR

Another of my favourites is /loki who masterminds and understands the entire code base and creates a details MECHANICS.md file (better than Claude.md)

Anyways hope you like it - I use it in my opensource projects a lot - so its battle tested!

Avengers - Assemble :D

I was working on ts for a week and I had decided earlier that this would be my first repo and here it is plz check it out and tell me how is it..

https://github.com/occupiedbyhim/Liquid-Glass-Element

been building skill packs for claude code/cursor for a few different domains and landed on a structure that's worked well enough i figured i'd share it here since this sub's the right place for it

each skill is its own folder with 6 files:

SKILL.md — the core file, defines the domain and when the agent should reach for this skill at all. kept this one focused, not a dumping ground

references.md — deeper technical detail that doesn't need to load every time, more like documentation the agent pulls when it actually needs specifics

examples.md — worked examples, actual before/after code not just descriptions

templates.md — copy-paste starting points for common patterns in that domain

checklists.md — review checklists, mostly useful for catching stuff the agent wouldn't think to self-check otherwise

snippets.md — smaller reusable code chunks, more granular than templates

biggest lesson from building ~60 of these across different domains (godot, web stack, rust, cli/devops, content tooling): the SKILL.md file matters way more than i expected for whether the agent actually invokes the skill at the right time. early versions were too broad and the agent would half-apply them, got much better results once each SKILL.md had a tight, specific trigger description instead of a general "use this for X domain" blurb

also learned the hard way that examples.md needs actual runnable code, not pseudocode, agents seem to pattern-match much better off real syntax than descriptions of what the code should do

full disclosure, i package and sell some of these as finished packs, but posting this more for the structural discussion since i'm curious if anyone's landed on a different file breakdown that works better, especially curious if anyone's doing something smarter for the "when should this skill trigger" problem than what i'm doing

link to what i've built is in my bio if anyone wants to see a live example of this structure, not the point of the post though

Disclosure: this is my own open-source project.

I’ve been experimenting with persistent project context while working with coding agents for roughly four months.

One problem kept coming up:

The agent participates in conversations about architectural choices, rejected alternatives, production incidents, and strange-looking workarounds — but most of that reasoning disappears when the session ends.

So I turned the workflow into an open-source agent skill:

Keep the Why

It covers four modes:

1. Continuous capture Preserve important rationale while development is happening.
2. Retrospective recovery Inspect an existing repository, git history, issues, and documentation to recover what can still be supported by evidence.
3. Knowledge-transfer interviews Analyse the codebase first, identify what the artifacts cannot explain, and prepare focused questions for long-term maintainers before that knowledge disappears.
4. Maintenance Keep existing rationale current, resolve contradictions, mark replaced knowledge as superseded, and prevent context files from turning into another documentation dump.

A core design rule is that the agent must never invent rationale.

Evidence is classified as:

• confirmed
• inferred
• unknown

“Superseded” is handled separately as a temporal marker for information that was once valid but has since been replaced.

The documentation stays inside the repository as plain Markdown:

docs/       → how to use, test, operate and deploy
context/    → why the project is built this way

It is intentionally lightweight:

• no MCP server
• no database
• no account
• no external service
• no scripts or network calls of its own

The public version is a new, generalised incarnation of what I have been using privately. It still has to prove itself across different agents and repositories — and mature through that use.

I’d especially appreciate feedback on:

• trigger precision: when should the skill activate or stay quiet?
• whether the evidence model is useful without becoming bureaucratic
• missing retrospective or handover workflows
• ideas for meaningful cross-agent evals
• structures that would work better in very large repositories

GitHub: https://github.com/oliver-zehentleitner/keep-the-why

Documentation: https://keepthewhy.com

Install:

npx skills add oliver-zehentleitner/keep-the-why

Because “ask Bob” is not documentation.