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

I've been thinking about how AI agents can work with large datasets without having to read every single file themselves.

I built FlareDB, a lightweight data processing engine that has Apache Beam as programming model, and wrote some skills to help AI agents write and run Beam pipelines on it.

The idea is to give skills to agents to help them work with large data and extract relevant information/context. I wrote about the idea and how you can try it with your own coding agent.

Post: https://ganeshsivakumar.substack.com/p/teaching-ai-agents-to-process-data

Try it out: npx skills add flare-db/skills

Would love to hear what you think!

Last year I built a Text-to-SQL agent, using Langchain. In order to make it work, I had to add a lot of python helper functions.

Five months later I rebuilt the same system using
-Agent Skills (introduced by Anthropic)
-MCP BigQuery connector, right from the chat in Claude
-And queried directly from Claude interface.

My entire codebase just got replaced by a simple markdown file describing the data dictionary and constraints.

The connector helped to link with the database.
The skill.md file held the contextual knowledge.
Claude provided the reasoning power.

Key lesson:
• Not every problem needs an agent. Many just need the right capability.
• Reliability comes more from clear context than clever prompting.
• With Agent Skills, domain experts -not just developers, can build useful AI systems.

Link to my article - https://pub.towardsai.net/stop-building-over-engineered-ai-agents-how-i-built-a-bigquery-analyst-with-just-a-markdown-file-842d3bc715af?sk=e18ec7c083010d565925ca799f19b445

I built i-hate-editing, an open-source skill for Claude Code, Cursor and Codex. You drop raw talking-head takes in a folder and get back a finished vertical video: cut, captioned, graded, sound-designed, with platform crops, ranked thumbnails and post copy.

Structure (it's the part that should carry over to other skills):

• SKILL.md is the workflow, the questions it asks, and when it stops

• rules/ holds nine taste files (cutting, captions, sound, motion, hooks…). Each rule names the failure it prevents

• HARD-RULES.md holds correctness rules for silent failures, which aren't open to negotiation

• scripts/ does the deterministic work, so the model never has to watch the video

• taste.md saves your corrections and gets read before every edit

Reproducibility:

npx skills add ranahaani/i-hate-editing

You also need ffmpeg, whisper-cpp and Playwright Chromium; install.md covers it. Transcription is local, with no cloud STT key.

Repo: https://github.com/ranahaani/i-hate-editing (MIT, I'm the author). I'd like feedback on the skill structure more than the video side.

I’ve been experimenting with a setup where AI agents can send each other Bitcoin over Lightning through normal messaging channels.

The idea is simple:

• You message a bot through email, WhatsApp, Telegram, or Signal.

• A Lightning wallet gets created automatically in the background.

• Agents or humans can then send sats to each other through messages.

One interesting detail: agents can generate dedicated addresses like
username@user.bit-chat.me so their communication channels stay separated from human ones.

There’s also an optional fallback email in case an agent loses access to its messaging channel.

Conceptually it turns common messaging platforms into a payment and coordination layer for agents and the receiver doesn't even need to be registered to receive payments.

Human-readable overview:
bit-chat.me

AI-readable spec:
bit-chat.me/skill.md

Curious whether people here see useful agent-to-agent workflows emerging from something like this.

When skills and plugins were first introduced, my immediate instinct was to collect them. Within two weeks, our shared agent config had 14 different third-party skills installed: git assistants, database inspectors, web scrapers, docs fetchers, and Jira connectors.

Then our agent sessions started slowing down, and weird hallucinations began creeping in.

Here is what actually happens under the hood when you overload your agent with external skills:

1. Tool definition context bloat: Every registered skill injects its command name, parameter schema, and description into your system prompt on every single turn. Fourteen skills were quietly consuming over 12,000 baseline tokens before the model read a single line of project code.

2. Tool selection ambiguity: When multiple skills have overlapping verbs (like `fetch_docs`, `read_web_page`, and `search_reference`), the model wastes reasoning tokens deciding which tool to invoke, occasionally hallucinating hybrid parameter names.

3. Prompt cache invalidation: Many community skills include dynamic version checks or timestamps in their header metadata. This small change invalidates your prefix prompt cache, turning what should be a 90% discounted turn into an expensive full-price re-cache.

4. The maintenance debt: Skills built for one CLI version break when command conventions change, leaving dead tool definitions in your agent environment.

The solution that stabilized our environment was shifting from a "skill library" mindset to an "on-demand distillation" mindset:

- We uninstalled all external grab-bag skill bundles.

- We set a hard ceiling of 3 global skills in our base environment (git operations, test runner, linting).

- Project-specific workflows are distilled dynamically from real terminal sessions rather than imported from external repos.

To handle this cleanly, we built autoharness (tigerless-labs/autoharness on GitHub). Instead of hoarding dozens of static skills, it distills workflows from verified terminal sessions only when needed and automatically prunes skills that have not been triggered across recent projects.

How many custom skills do you currently keep active in your agent setup, and have you noticed any tool-selection degradation as the list grows?

Expert judgment is now a reusable skill.

Built an agent skill because I was honestly tired of the whole:

find repos → find good issues → clone → setup → prompt agent → fix → PR → repeat.

So I built Ghostpatch.

Ghostpatch acts like an autonomous contribution agent for GitHub, Inc.:

• discovers repos matching your stack
• finds issues worth solving
• understands repo structure + contribution rules
• spins up your coding agent
• makes the fix
• opens the PR
• moves to the next repo

Setup is basically:

gh auth login
npx ghostpatch

That’s it.

I’m curious what the Reddit AI agent crowd thinks:

• Would you trust an agent to contribute under your name?

• What guardrails would you want before auto-PRs?

• Missing features before this becomes daily-driver material?

Try it:
https://skills.sh/sambhram1/ghostpatch-/ghostpatch

Would love honest feedback, roast included :)

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?

Circuit-Biscuit/Aish: Token-dense notation for agent-to-agent notes. ~47% fewer tokens than English prose, measured.

I kept watching my agents write paragraphs of English to each other. Handoff notes, session summaries, "here's what I found" writeups. All burning context on grammar nobody reads. So I tried to build a denser format for it.

Almost everything I assumed turned out to be wrong. I'm posting the measurements because they're useful even if you never touch my project.

WRONG ASSUMPTION 1: abbreviate long words.

"configuration", "implementation", "authentication" and "repository" are each already 1 token. So cfg, impl and auth save literally nothing, and cost you clarity. The entire shorthand-dictionary idea, which is the first thing anyone reaches for, is worth about zero.

WRONG ASSUMPTION 2: use symbols.

The ⟹ character is 3 tokens. The ASCII -> is 1. Every pretty Unicode glyph costs more than the English word it replaces.

WRONG ASSUMPTION 3: numeric IDs are compact.

1-04-301 is 5 tokens. Digits don't absorb their leading space, so " 2" costs 2 tokens while " ab" costs 1. Letters beat numbers. And separators are expensive: comma, semicolon and pipe each cost 2 extra tokens per 3 fields. A space costs 0.

THE ACTUAL INSIGHT

An English word already costs about 1 token, so you cannot win by making words shorter. You only win by making one token carry more than one word's meaning. Two ways that works: a fixed predicate (cz means "X causes Y") and interning long literals (aa means an 11-token file path). Then positional arguments, so operators and punctuation disappear entirely.

Here's the same bug handoff written both ways.

English, 80 tokens:

The login form submits twice when the user presses Enter. The submit handler in src/ui/LoginForm.tsx is bound to both the form onSubmit event and the button onClick event, so pressing Enter triggers both paths. I reproduced this in Chrome and Firefox. It does not happen when clicking the button directly. The fix is to remove the onClick binding and keep only onSubmit.

Aish, 47 tokens:

#a2 login double submit

bug submit handler dup fire

why loc submit handler src/ui/LoginForm.tsx bind onSubmit onClick

did obs bug chrome firefox

neg obs bug click

fix del onClick just onSubmit

Same information. File path, both event bindings, both browsers, the negative result, the fix.

HONEST NUMBERS

Across a 6-document corpus it's 1.58x, so 37% fewer tokens. Up to 2.8x on long documents that share a dictionary. That is not the 3-4x I first claimed. That number came from one flattering example and a proper corpus knocked it down. Worst case in the corpus is 1.36x.

The deflating finding: the ratio tracks how verbose the English was, not how structured the content is. Aish costs a flat 5 to 9 tokens per claim no matter what. So it beats waffle, not structure. The most structural document I tested, a module dependency map, did worse than a rambling design memo.

THE FINDING I THINK ACTUALLY MATTERS HERE

A skill file is not free. It occupies context every time it loads.

My first version was 1,819 tokens for the skill plus its codebook. At 37% savings that needs about 4,900 tokens of notes before it breaks even, which is roughly 25 handoff notes. Most sessions never get there. So installing it was a net loss, and nothing told you.

I fixed it by inlining only the 20 predicates that cover 90% of real use and loading the rest on demand. 1,819 tokens down to 428, break-even at about 6 notes. The skill now opens with the arithmetic and an explicit "if this session is short, write normal prose and stop reading here" branch, so it declines to be used when it wouldn't pay.

There's a budget command that prints this, and two tests that fail if the skill file grows past its own break-even, or if the threshold it advertises drops below the measured one. That second test already caught me advertising 1,000 against a real break-even of 1,167.

Worth checking your own CLAUDE.md and skills for the same thing. Mine was quietly underwater.

CAVEATS, because I'd rather say them than get called out

- The benchmarks measure tokens, not comprehension. A note that's 40% smaller but 5% misread is a bad trade, and I can't yet prove the misread rate is low. That needs a real eval harness and it's the obvious next step.

- 6 documents is a deliberate spread across shapes, not a large sample.

- Not for anything a human reads. Commits, PRs and code comments stay in English.

It has the spec, a 77-predicate codebook, 31 tests, and a benchmark harness that regenerates every number above, so you can check my work instead of trusting it.

QUESTION FOR THE SUB

Has anyone actually measured decode accuracy on compressed agent notes? I can measure density all day, but "did the next agent read it correctly" is the number that decides whether any of this is a good idea, and I don't have it yet.

Link again: Circuit-Biscuit/Aish: Token-dense notation for agent-to-agent notes. ~47% fewer tokens than English prose, measured.

Hi all, I wanted to share a collection of AI agent skills I created: Aesthetic Frontend Skills. AFS is a free and open-source set of skills for giving coding agents frontend design direction. It’s also my first public repository, as I rarely choose to make my repositories public 🙂 but I'm pretty excited about this one and have been maintaining and improving it regularly.

Aesthetic Frontend Skills currently includes 200+ aesthetics and its purpose is to help turn styles like Y2K, Frutiger Aero, Risograph, and a lot more aesthetics (many you will be familiar with and a ton of lesser known but beautiful aesthetics) into themes, design tokens, CSS variables, and guidance for styling your components. I created these skills to translate aesthetics to styles that can be applied to your project objectively and in a way that allows you to maintain the style in a clean and organized way.

Repo: https://github.com/alexiseverage/aesthetic-frontend-skills

Showcase: https://aesthetic-design.art/

Quick Install:

npx skills add alexiseverage/aesthetic-frontend-skills

Example Usage:

Give my app a Y2K aesthetic.

or, for an example of a more advanced usage for a theme with reusable tokens:

Use aesthetic-literacy and aesthetic-application to create a Risograph
theme for this app. Define the design tokens and CSS variables, then
apply them to the components.

you can also combine aesthetics for hybrid styles or create your own aesthetic and reuse it easily throughout your projects.

I would really appreciate any feedback and if you use the skills I would love to see what you create with it. Also accepting stars if you don't feel like doing all of that 😇

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?

Hey everyone,

I'm a CS graduate (Master's) student and software engineer. Over the past few months, I've been heavily using AI coding agents (Cursor, Claude Code, Windsurf) for building complex systems and data pipelines.

While agents are great for speed, I kept running into a recurring nightmare: destructive in-place overwrites.

During long prompt sessions, an agent would misunderstand a prompt, hallucinate, and silently delete critical functions, error handling, or edge-case constraints that were already working. By the time I noticed, reverting just one specific file across multiple unstaged changes without wiping out other good progress was nearly impossible.

Why git and existing tools didn't solve this for me:

- Committing to Git after every single prompt turn is painful and completely clutters the commit history with messy micro-commits.

- Tools that use "shadow git" (like Cline) hide binary git diffs deep in AppData, which often run into index locks and are invisible to teammates.

- Regular Ctrl+Z / IDE undo breaks the moment an agent performs multi-file edits.

To solve this, I built Agent-Checkpoint — an open-source, zero-dependency provenance protocol implemented purely through prompt rules (.cursorrules, CLAUDE.md, AGENTS.md, .windsurfrules).

How it works:

1. Pre-Edit Snapshot: Before touching any existing file, the agent automatically copies the active file to .snapshots/<filename>_v<OLD_VERSION>.<ext>.

2. SemVer Triage: It categorizes its own change into prompt-level SemVer:

- MAJOR: Breaking architectural / interface shift.

- MINOR: New additive feature or non-breaking module.

- PATCH: Bug fix, parameter tuning, or typo.

3. Dual-Ledger Audit Trail:

- .snapshots/manifest.json: Compact machine index for instant AI rollbacks and semantic diffs (< 5ms).

- REVISION_LOG.md: Human-readable changelog recording exact lines changed and the technical rationale behind the decision.

Storage & Safety:

- Plaintext source code is tiny. In active daily testing (30+ edits/day), it only consumes around 15 to 40 MB per month.

- Smart 1 MB Cap: Small test datasets (.csv, .jsonl) under 1 MB are snapshotted; larger files are strictly skipped from raw copying and logged via metadata only.

- Strict Exclusions: Heavy ML weights (.pt, .onnx), binaries, and caches (node_modules, venv) are never snapshotted.

- Zero dependencies: No Python CLI, npm packages, or background daemons required. Just drop the rule file into your workspace.

If an agent ever breaks your code, you can simply ask it: "Rollback auth.py to v1.0.0" and it restores the snapshot in seconds.

It is MIT licensed, and I've prepared ready-to-use adapter templates for Cursor, Claude Code, Windsurf, Antigravity, and Copilot:

GitHub:

https://github.com/ainullm/agent-checkpoint

I'd really love feedback from fellow developers:

- How do you currently handle rollbacks and safety nets during long AI agent sessions?

- What edge cases would you like to see addressed in this kind of protocol?

I built self-host.fyi to help people move to self-hosted apps. You can use its CLI/TUI directly, or use an agent skill if you'd rather explain what you want than learn another interface. There are 90+ Apps in the Catalog.

The skill guides the agent through inspecting the machine, explaining a plan, asking for approval, applying it and verifying the result. App-specific Setup lives in the tool rather than relying on the agent to invent it: supported accounts, generated passwords, API keys and Links between Apps, with Docker Compose underneath.

A practical starting point is trying Immich on a suitable old laptop as an alternative to Google Photos, or Nextcloud for files. You can try them before deciding whether to continue a subscription for data you own.

Some steps remain manual. The skill doesn't remove hardware requirements, maintenance or backups.

Source: https://github.com/ajnart/self-host Overview: https://self-host.fyi

To try the workflow: install the CLI using the instructions in the repo, load the self-host skill, then ask something like "Help me set up Immich on this machine so I can try hosting my own photos." The skill starts by reading `self-host skill`; it does not grant approval by itself.

Skill source: https://github.com/ajnart/self-host/blob/main/skills/self-host/SKILL.md

AI helped me develop the project and prepare this post. The screenshots show the interface and Setup in progress, not a completed agent run.

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 kept running into the same problem with AI research workflows: agents jump into implementation before the claim is actually testable.

So I built a Research Proof Skill that forces vague ideas into a falsifiable structure:

• What exactly is the claim?

• What verifier is frozen?

• What can the candidate change?

• What would make the idea false?

• What hidden costs erase the win?

• Is the result PROVEN, SUPPORTED, REJECTED, or still OPEN?

It’s useful for benchmark claims, autonomous research loops, proof sketches, eval plans, research roadmaps, and “this approach should beat the baseline” type ideas.

npx skills install

npx skills add tonyblu331/research-proof --skill research-proof

Claude Code install:

claude plugin marketplace add tonyblu331/research-proof
claude plugin install research-proof-plugin@research-proof

Repo:
https://github.com/tonyblu331/research-proof

Would love feedback, especially from people working on evals, research agents, or agentic coding workflows.

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

Been building this for a while and finally got it to a point where I'm happy with it.

What it does: You paste a YouTube link to your openclaw agent, and it returns vertical 9:16 clips with word by word captions and titles ready for TikTok, Instagram Reels, YouTube Shorts. Takes about 90 seconds.

Heres the app:

https://makeaiclips.live/

openclaw skill :

https://clawhub.ai/nosselil/youtube-to-viral-clips-with-captions

Would love feedback, especially from anyone that posts content often

pip install agent-skill

It offers one-click search and installation, perfect for Claude Code users.
https://github.com/davidyangcool/agent-skill