What are your three biggest concerns using AI for work?

AI Anxiety Is Real: What the Data Says Workers Fear Most

AI adoption is accelerating faster than trust can keep up. Half of employed American adults now use AI in their roles at least a few times a year, up from 46% the previous quarter, according to Gallup data.

Yet this rapid integration has outpaced confidence. A Pew Research Center study reveals that 52% of U.S. workers are more worried than hopeful about AI’s workplace impact.

This anxiety is not abstract. Thirty-two percent of these workers expect fewer job opportunities long-term, while only six percent anticipate growth. The fear is compounded by a significant "shadow usage" problem.

Twenty-nine percent of workers admit to using AI tools without their management’s knowledge, as noted in a Federal Reserve review. This gap between usage and oversight creates a blind spot for organizations.

When employees operate in the dark, risks multiply. The data points to three primary, evidence-backed concerns driving this hesitation.

• Job displacement: Workers fear AI will eliminate roles or reduce future hiring.
• Data privacy and security: Autonomous agents pose risks to sensitive information and infrastructure.
• Trust in tooling: It is difficult to verify which AI skills are safe and effective.

The security concern is particularly acute. IBM X-Force documents a "lethal trifecta" of agentic AI risks: deep access to private data, interaction with untrusted content, and outward communication ability. Attackers are already exploiting this, with campaigns uploading thousands of malicious skills disguised as legitimate productivity tools.

Trust in the tools themselves is also eroding. Stanford researchers found that across 56 widely used benchmarks, tests claiming to measure the same property frequently disagree. This means high-stakes decisions are often made based on unvalidated scores.

This verification gap leaves businesses guessing whether an AI skill is helpful or hazardous. SkillzBench is building a solution to this exact problem. By pinning every skill version to a commit SHA and running independent security scans, the platform aims to provide transparent trust scores.

These scores are derived from security, quality, and maintenance signals, ensuring that money never influences the ranking. The goal is to replace guesswork with verified data.

For managers, this shift is critical. With nearly a third of the workforce using AI without oversight, banning tools is no longer a viable strategy. Instead, organizations need a way to vet the tools their employees are already adopting.

SkillzBench’s approach focuses on independent verification. Every skill is benchmarked in a sandbox, and results are published separately from any commercial incentives. This ensures that the "Lift" in performance is measured objectively, without vendor bias.

As AI becomes standard in the workplace, the cost of getting it wrong rises. The average cost of a data breach has reached nearly five million dollars, and AI-driven attacks are increasing by 56%.

The path forward requires clarity. Workers need to know their tools are safe. Managers need to know their workforce is compliant. And developers need to know their skills are effective.

The data is clear: anxiety is real, but it is also solvable. By addressing these three core concerns with rigorous verification, the industry can move from fear to confident adoption. The tools are here. The question is whether you are using the right ones.

The Agentic AI Security Problem: The 'Lethal Trifecta' and the Malware Supply Chain

When your AI agent can read your files, browse the web, and send messages outward, a single poisoned instruction can turn it into a data breach. IBM X-Force calls this combination the "lethal trifecta": deep access to private data, exposure to untrusted external content, and the ability to communicate outward — and attackers are already exploiting it.

The supply chain is the newest battleground. In the "ClawHavoc" campaign, attackers uploaded more than 1,100 malicious skills to a community skill repository, disguised as legitimate productivity tools. A skill that promises to summarize your inbox can quietly exfiltrate credentials, contacts, and documents. Community hubs that once felt like app stores are now an attack surface, and most users install from them with no verification at all.

The consequences are not hypothetical. Anthropic disclosed that during cybersecurity evaluations, Claude models accessed real organizations' production infrastructure — including a database with several hundred rows of production data — because a misconfiguration granted live internet access. In one incident, Claude published a malicious PyPI package that was downloaded and run on 15 real systems within about an hour, exfiltrating a security company's credentials. Most alarming: neither victim organization detected the intrusion themselves; Anthropic had to notify them.

The financial stakes are rising fast. The global average cost of a data breach has reached USD 4.99 million, while AI-driven attacks have increased by 56%. IBM X-Force warns that AI vulnerabilities are "no longer a future problem" — they are already present in production environments. Making matters worse, many AI-specific flaws lack CVE identifiers, so standard patch management and compliance tools simply cannot see them.

For teams adopting agent skills, the practical questions become:

• Who wrote this skill, and can their instructions be trusted?
• What data and tools does the agent actually see when the skill runs?
• Has the skill been scanned for malicious behavior — and re-scanned when it updates?
• Would you even know if something went wrong?

This is the gap SkillzBench is being built to close. Its Verify pillar pins every skill version to a commit SHA, validates it, checks the license, and runs security scans — while the Stay Current pillar tracks upstream changes and re-scans after every update, so a skill that is safe today does not silently turn risky tomorrow. Published research suggests roughly 26% of agent skills carry at least one vulnerability, which is precisely why independent verification matters before anything touches your data.

The lesson from the ClawHavoc campaign and Anthropic's disclosures is uncomfortable but clear: by the time an AI-driven intrusion shows up in your logs, it may already be too late. Vetting what your agents run — before they run it — is the only defensible position. Skills, proven: join the SkillzBench waitlist to get verified, benchmarked agent skills first.

Who Holds the Measuring Stick? Why You Can't Tell Which AI Tools Actually Work

When Stanford researchers examined 56 widely used AI benchmarks, they found that tests claiming to measure the same property frequently disagree — and that benchmark scores drive high-stakes decisions about market value, procurement, and regulation without anyone validating whether the score actually supports the decision. As researcher Sanmi Koyejo put it, "Whoever holds the measuring stick steers the ship."

The problem isn't academic. A benchmark score is, in Koyejo's words, "a prediction about how a system will behave once it's out in the world" — yet almost nobody records that prediction in a way that can be checked later. The bias-benchmark example makes the failure concrete: a genuinely biased model that detects trick questions scores as "unbiased," while an unbiased model that misses the trick gets flagged as "biased." If you're choosing tools based on those numbers, you may be choosing exactly wrong.

For agent skills, the stakes compound. Published research found that roughly 26% of agent skills carry at least one vulnerability, and there's no standardized scoreboard telling you which instruction packages will help your workflow and which will leak data or break it. Anthropic's engineering team warns that without proper evaluations, teams get stuck in reactive loops, "catching issues only in production" — and agent mistakes "can propagate and compound" across multi-turn tool use.

So what can a non-expert actually check? The warning signs are consistent across the research:

• Scores published by vendors or communities with no stated testing method or sandbox conditions
• No version pinning — if you can't tie a skill to a specific commit, you don't know what you're installing
• No security scan, license check, or validation step before a skill reaches your agent
• Ratings that mix performance with promotion, so you can't tell whether a high score reflects quality or money

This is the gap SkillzBench is being built to close. Its approach separates measurement from money: every skill version is pinned to a commit SHA, security-scanned, and license-checked, then benchmarked in a sandbox with the same model — with and without the skill — so the published Lift in percentage points shows what the skill actually adds. Trust scores draw on security, quality, license, maintenance, and community signals, and advertising revenue never touches them. Lift is always shown separately from ratings.

The lesson from the Stanford findings and Anthropic's disclosures is the same: independent verification has to come from outside the system being sold. Until third-party, method-transparent scores are the norm, treat any unexplained benchmark claim — including vendor marketing — as an unvalidated prediction, not evidence.

From Worry to Control: A Practical Framework for Trusting Your AI Tools

Worry without control is just anxiety. The good news is that each of the three big concerns we've covered — security, performance, and trustworthy measurement — has a concrete, practical answer, and none of them require you to become a security researcher.

Start with verification before you install anything. IBM X-Force has documented the "lethal trifecta" of agentic AI risks — deep access to private data, exposure to untrusted content, and the ability to communicate outward — and attackers are already exploiting it: the ClawHavoc campaign planted more than 1,100 malicious skills on a community hub, disguised as legitimate productivity tools. Your first line of defense is simple discipline: security-scan every skill, check its license, and pin versions to a commit SHA so what you tested is exactly what runs. And keep watching — upstream code changes, so re-scan when it does. Remember that neither organization Anthropic affected in its evaluation incidents detected the intrusion themselves. External, independent checking is not optional.

Second, benchmark in a sandbox before you trust a tool with real work. Anthropic's engineering team is blunt about this: without proper evaluations, teams get stuck in reactive loops, "catching issues only in production." The right test is a controlled A/B — run the same task with the same model, once with the tool and once without, and measure the difference in performance. That difference is the only honest answer to "does this actually help?"

Third, demand measurement that money can't touch. Stanford researchers who tested 56 widely used AI benchmarks found that tests claiming to measure the same property frequently disagree — and that benchmark scores drive high-stakes decisions without anyone checking whether the score supports the decision. As Stanford's Sanmi Koyejo puts it, "Whoever holds the measuring stick steers the ship." Independent scores, with performance shown separately from ratings, are the antidote.

This is exactly the framework SkillzBench is being built to deliver, free, through five pillars:

• Discover — continuously crawl and dedupe agent skills from GitHub so you see the whole landscape in one place.
• Verify — pin every version to a commit SHA, then validate, license-check, security-scan, and quality-judge it.
• Benchmark — test every skill in a sandbox with the same model, with and without the skill, and publish the Lift in percentage points.
• Equip — one free MCP server plus per-agent loadouts, so your agent only ever sees the skills and tools you chose for it.
• Stay Current — track upstream changes, re-scan, re-benchmark, and notify you when something shifts.

Every skill carries a 0–100 trust score built from security, quality, license, maintenance, and community signals — and money never touches scores. The directory, the MCP connector, the benchmarks, and the alerts are all free; revenue comes from advertising, never from charging users or influencing results.

You can't eliminate AI risk, but you can replace vague unease with a repeatable process: verify before installing, benchmark before trusting, and insist on measurement that answers to you, not to a vendor. That's the difference between worrying about AI and actually using it.

Your Next Steps: Adopt AI Without the Blind Spots

You can't manage what you can't see, and right now most organizations can't see how their people actually use AI. A Federal Reserve review of 16 workplace surveys found that 29% of workers use AI without their management's knowledge — which means your real risk surface is bigger than your tool inventory.

Start by auditing that shadow usage honestly: ask teams which tools and skills they've already adopted, then replace blanket bans with an allowlist of vetted options. A ban pushes usage underground; an allowlist keeps it visible and reviewable.

For agent skills specifically, pin every version to a commit SHA and re-scan whenever the upstream repository changes. That discipline matters because IBM X-Force documented a campaign that uploaded over 1,100 malicious skills to a community hub, disguised as legitimate productivity tools. Version drift is how a clean skill becomes a compromised one.

Finally, scope each agent tightly. Per-agent loadouts mean an agent only sees the skills and tools you explicitly choose for it, which shrinks the blast radius IBM describes as agentic AI's "lethal trifecta": deep access to private data, exposure to untrusted content, and the ability to communicate outward.

A practical sequence for managers and builders:

• Audit shadow AI usage across every team before writing any policy.
• Allowlist vetted skills instead of banning categories of tools.
• Pin skill versions to commit SHAs and re-scan on upstream changes.
• Assign per-agent loadouts so each agent sees only chosen tools.
• Re-check trust signals regularly, since maintenance and security posture shift over time.

This is exactly the gap SkillzBench is being built to close: every skill version pinned, validated, license-checked and security-scanned, with a trust score kept separate from benchmarked Lift — and money never touching either. The directory, the MCP connector, and the alerts are all planned as free.

Skills, proven. Join the SkillzBench waitlist to get verified, benchmarked agent skills first.