What are some genuinely good uses for AI?

The Hype Problem: Impressive Output vs. Actual Work

The AI demo looked flawless. Then you tried it on real work, and the polished output fell apart.

This is the central frustration most people hit when they move from AI hype to AI reality. Text that "sounds right" tells you almost nothing about whether the work actually finished, according to NVIDIA's evaluation team. The genuinely good uses of AI are defined by verified task completion, not impressive output. Think refunds processed, GitHub issues resolved, tickets closed, banking conversations completed end to end.

The shift in evaluation mirrors this. Agent assessment has moved from scoring individual function calls to measuring full task completion via executable environments. The gold standard is checking environment state, such as a merged PR or a closed ticket, rather than asking a judge model whether the final message reads well.

Yet the ecosystem where most of this work happens is young and largely untested. Within roughly three months of Anthropic's December 2025 Agent Skills announcement, a single skill called "Find-Skills" had over 200,000 downloads, per Mitiga's supply chain analysis. One SkillsBench count found more than 47,000 unique skills spread across 6,300+ repositories. And a large-scale study of 31,132 skills found that 26.1% contain at least one vulnerability.

The uncomfortable truth is that the skills flooding this fast-growing ecosystem are mostly AI-generated and almost never tested. As Philipp Schmid documented, "Everyone is writing skills. Almost nobody is testing them."

Real value exists. The skills format lets teams package institutional knowledge into portable, version-controlled artifacts that any compatible agent can load, which is genuinely useful for onboarding, preserving expert workflows, and scaling automation across finance, healthcare, and operations. But the surrounding marketplace is flooded with packages that look credible on the surface while carrying hidden risk.

What separates a genuinely good AI use from a risky one comes down to one question: was the task verified complete, and was the capability vetted before it ran?

Three Uses Where AI Genuinely Delivers

The gap between AI hype and verified value narrows when you look at outcomes, not outputs. Genuine utility emerges when systems preserve expertise, complete live tasks, and package capabilities for reuse. These three areas hold up under scrutiny because they rely on measurable results rather than plausible-sounding text.

Executable knowledge transforms institutional expertise into portable assets. In sectors like finance, healthcare, and manufacturing, organizations use AI skills to streamline onboarding and automate expert-driven workflows. This approach preserves critical logic that might otherwise be lost when specialists retire or move roles. By packaging this knowledge into version-controlled packages, teams ensure that complex procedures remain accessible and consistent across their operations, regardless of staff turnover.

Real task completion moves beyond simulation into live environments. Agents now operate across SaaS platforms, cloud infrastructure, and customer service channels to finish specific jobs. The evaluation standard has shifted from judging whether a response sounds right to verifying if the work actually finished. For instance, success is defined by a merged pull request, a closed support ticket, or a processed refund in a production database. This focus on environment state ensures that AI investments deliver tangible operational results, not just conversational fluency.

The third pillar is the build-once, reusable capability package. Skills extend agent capabilities without requiring expensive model retraining or fine-tuning. This allows developers to create a specific function once and deploy it across multiple agent products and platforms. The efficiency gain is significant, as it decouples capability development from underlying model architecture. However, this flexibility demands rigorous quality control, as the ecosystem grows rapidly with thousands of new packages appearing in repositories.

To navigate this landscape safely, focus on verified performance metrics:

• Verify that skills complete full task chains in executable environments, not just single-step prompts.
• Check for transparent benchmarking data that measures performance lift independently of community ratings.
• Ensure version pinning and security scans are in place to prevent supply chain risks.
• Prioritize skills that capture stable, high-value institutional knowledge over volatile, trendy features.

The agent skills ecosystem is expanding fast, with over 47,000 unique skills identified across major repositories. Yet, a recent study found that 26.1% of analyzed skills contain at least one vulnerability, highlighting the need for careful vetting. As models improve, some skills may become obsolete, so regular re-evaluation is essential to retire capabilities the base model has already absorbed.

SkillzBench is building a free directory and MCP tool to help you discover, verify, and benchmark these skills. By tracking upstream changes and publishing independent Lift metrics, the platform aims to make it easier to identify which capabilities genuinely deliver value. You can join the waitlist to explore the catalog as it launches, ensuring you equip your agents with tools that are tested, secure, and effective.

The Catch: 26% of Skills Carry a Vulnerability

Every glowing use case in this article comes with a caveat worth stating plainly: the agent skills ecosystem is young, largely unvetted, and carries measurable risk. A large-scale analysis of 31,132 agent skills found that 26.1% contain at least one vulnerability — spanning prompt injection, data exfiltration, privilege escalation, and supply chain weaknesses.

That is not a theoretical concern. Skills execute with what researchers describe as "implicit trust and minimal vetting," meaning a malicious or careless package can run inside your agent's workflow before anyone reviews it. The same study found that 5.2% of skills show high-severity patterns strongly suggesting malicious intent.

The riskiest skills are the ones doing the most: those bundling executable scripts are 2.12x more likely to contain vulnerabilities than instruction-only skills. If a skill ships code, treat it like any other open source dependency — because, as security researchers note, the code that runs is determined at runtime, not at review time.

Popularity signals do not help here. Attackers inflate trust on public catalogs with bot upvotes, fake downloads, and fake comments, which means a skill's star count or download total tells you almost nothing about whether it is safe. As Mitiga's research puts it bluntly: don't trust skills based on stars or upvotes.

Before adopting any skill, run it through a short vetting pass:

• Check whether it bundles executable scripts, and read every one line by line
• Pin the exact version to a commit SHA so a future update cannot silently swap in different code
• Verify the license allows the use you intend
• Test the skill in a sandbox with the same model, with and without the skill loaded
• Ignore stars, upvotes, and download counts as quality evidence

This is exactly the gap SkillzBench is being built to close. Its directory will version-pin, security-scan, license-check, and benchmark every skill before listing it, and keep measured performance lift separate from community ratings so money and popularity never touch scores.

Vetting is what separates genuinely good AI use from risk. The use cases above are real and worth pursuing — but only with the same scrutiny you would apply to any code that runs inside your systems.

How to Adopt AI Skills Without the Risk

The safest path to AI value isn't a better model — it's better vetting of what you attach to it. Security researchers put it plainly: treat agent skills like any other open source package and apply the same scrutiny (SafeDep).

That starts with hygiene. Pin every skill to a specific version, check its license, and run a security scan before it ever touches your agent. This matters because a large-scale analysis of 31,132 skills found that 26.1% contain at least one vulnerability, and skills bundling executable scripts are 2.12x more likely to be vulnerable than instruction-only ones.

Next, test before you adopt. Run your core tasks twice — once with the skill loaded, once without — and measure the difference in percentage points. That measured improvement is your Lift, and it's the only honest signal of whether a skill helps. A practitioner case study showed why: rewriting one skill's description alone fixed 5 of 7 failures, lifting a pass rate from 66.7% to 100% (Schmid).

When you evaluate, grade outcomes, not paths. If the ticket closes or the PR merges, an unexpected route to the right answer is a feature, not a bug. Gate on environment state — a database row, a closed ticket — not on whether the output "sounds right."

Finally, retire skills the model has outgrown. Run your evals with the skill unloaded; if tasks still pass, the model has absorbed its value and the skill is just added attack surface.

Doing all of this manually across dozens of skills is heavy work — which is why SkillzBench is building a free, independent directory that discovers, verifies, benchmarks, and equips skills in one place:

• Every skill pinned to a commit SHA, license-checked, and security-scanned
• Benchmarks run in a sandbox with the same model, with and without the skill, publishing the Lift separately from any rating
• Trust scores built from security, quality, license, and maintenance signals — never from popularity or money
• A free MCP connector plus per-agent loadouts, so each agent only sees the skills you chose
• Upstream change tracking with re-scans, re-benchmarks, and alerts as skills evolve

Don't trust stars or upvotes — researchers have documented attackers inflating reputation with bot upvotes and fake downloads (Mitiga). Independent measurement is the antidote.

Join the free waitlist and browse the skill catalog to see which skills genuinely lift your agents — and which ones just add risk.