How to Use Train AI Model: A Practical Walkthrough

Why Your AI Agent Struggles — and Why Skill Packs Are the Fix

Your AI agent probably isn't failing because the underlying model is weak. It's failing because it was never properly trained for your specific workflow.

In 2025–2026, "training an AI model" no longer means fine-tuning weights. It means equipping a general-purpose agent with Agent Skills — SKILL.md instruction packages that turn a general agent into a specialist without custom development. Anthropic's engineering team, which built the feature, frames it simply: building a skill for an agent is like putting together an onboarding guide for a new hire.

The reliability data explains why this matters. Claude Opus 4.6 completes 12-hour tasks at only 50% success, but 70-minute tasks at 80%, and a UC Berkeley study found seven open-source multi-agent frameworks failing 41% to 86.7% of tasks across 14 distinct failure modes. The pattern is consistent: capability isn't the bottleneck — reliability on long, specific workflows is.

That's exactly where generic pilots break down. A widely cited MIT study found most generative AI pilots delivered no measurable financial return, and the ones that worked were built around a specific workflow rather than bolted on as a generic tool. Skill packs are that workflow-specific mechanism, packaged and reusable.

The ecosystem is already proving demand. Anthropic announced Agent Skills in December 2025, and within roughly three months a single skill had passed 200K downloads. But volume brings risk: Mitiga demonstrated a malicious skill silently exfiltrating an entire codebase in just 4 user interactions with an empty audit log, and OWASP has responded with the Agentic Skills Top 10, the first security framework for agent skills. Anthropic's own guidance is blunt: install skills only from trusted sources.

• Skills are pre-baked behaviors, not prompts — they execute exactly as written, reviewed or not.
• Reputation signals like stars and downloads can be inflated by bots and fake accounts.
• Vetting must cover bundled scripts and anything touching files, network, or credentials.
• Version pinning and independent benchmarking turn "trust me" into verifiable evidence.

This is the gap SkillzBench is being built to close — a free, independent directory where every skill is commit-SHA pinned, security-scanned, license-checked, and benchmarked in a sandbox so its Lift is published separately from any rating. The waitlist is live.

The Skill Pack Anatomy: How Agent Skills Actually Work

Before any skill can help your agent, it helps to understand what a skill actually is: not a prompt, but an organized folder of instructions, scripts, and resources that an agent discovers and loads dynamically. Anthropic's engineering team, who built the feature, compares it to "putting together an onboarding guide for a new hire" — and that analogy explains the entire anatomy.

Every skill starts with a SKILL.md file with YAML frontmatter. The frontmatter carries the skill's name and description, which is what drives triggering — the agent decides whether to load the skill based on that metadata alone. Below the frontmatter sits the instruction body, and alongside it can live bundled scripts and resources. Because agents with filesystem and code-execution tools don't need to read everything into context at once, Anthropic notes that "the amount of context that can be bundled into a skill is effectively unbounded."

That efficiency comes from progressive disclosure, which Anthropic calls "the core design principle that makes Agent Skills flexible and scalable." Loading happens at three levels: the agent first sees only the lightweight name and description; when a task matches, it reads the full SKILL.md; and only when needed does it open bundled files or run scripts. This keeps context windows lean while allowing deep, task-specific detail.

Bundled scripts matter for a second reason: deterministic reliability. Instructions in prose leave room for interpretation; code executed exactly as written does not. This is the reliability gap the broader ecosystem is struggling with — a UC Berkeley study found seven multi-agent frameworks failed 41%–86.7% of tasks across 14 failure modes, and METR benchmarks show Claude Opus 4.6 succeeding at 80% on 70-minute tasks but only 50% on 12-hour ones. Skills that bundle verified scripts close that gap on specific workflows.

The open standard also makes skills portable. Published as an open format, the same SKILL.md package works across

• Claude Code and Claude.ai, where skills were first introduced
• Codex and other coding agents that adopt the standard
• Chat-app agents that load instruction bundles for specific tasks

The net effect: you turn a general agent into a specialized one without custom development. But because skills are "pre-baked behaviors, not just prompts," as Mitiga researchers put it, the same mechanics that make them powerful make them risky — their proof-of-concept showed a malicious skill exfiltrating an entire codebase in 4 user interactions with an empty audit log. That's why vetting matters: SkillzBench is building exactly this layer, with commit-SHA pinning, security scanning, license checks, and sandboxed Lift benchmarks so you can see which skills actually help before you install them. You can already browse the free skills directory and join the waitlist at skillzbench.com.

Step-by-Step: Building and Installing Your First Skill Pack

Building a skill pack isn't a single creative act. It's a disciplined loop, and Anthropic's engineering team documents five authoring practices that form the spine of any serious skill-building workflow.

Step 1: Start with evaluation, not enthusiasm. Before writing a single line of SKILL.md, run your agent through representative tasks and watch where it fails. The METR benchmark found Claude Opus 4.6 completes 70-minute tasks at 80% success but only 50% on 12-hour tasks, and a UC Berkeley study showed seven open-source multi-agent frameworks failing 41%–86.7% of tasks across 14 distinct failure modes. Those gaps are your skill backlog.

Step 2: Structure SKILL.md for scale. Anthropic's core design principle is progressive disclosure, a three-level loading model where only metadata loads first, instructions load on trigger, and bundled files load on demand. Because agents with filesystem access don't need to read entire skills into context, "the amount of context that can be bundled into a skill is effectively unbounded." Split unwieldy SKILL.md files into focused sub-skills rather than letting one file sprawl.

Step 3: Optimize name and description for triggering. The YAML frontmatter's name and description fields are what the agent reads to decide whether to load your skill. Anthropic recommends thinking from the agent's perspective: what would it search for, and when would this skill clearly apply? Vague descriptions mean your skill never fires; over-broad descriptions mean it fires too often.

Step 4: Bundle scripts for deterministic reliability. Wherever the task involves repeatable mechanics (parsing, validation, transformation), ship a script inside the skill folder rather than relying on the model to improvise. Deterministic code eliminates a whole class of reliability failures.

Step 5: Iterate with the agent itself. Have the agent capture its own successes and mistakes during real use, then convert those observations into reusable skill content. This is the "training loop," and it compounds: each cycle makes the skill sharper on the exact failure modes that matter.

Installing your first skill pack. Trail of Bits maintains a curated marketplace of security-focused skills (vulnerability scanners for six blockchains, supply-chain auditors for npm, PyPI, and Go). To install in Claude Code:

/plugin marketplace add trailofbits/skills

For Codex, the equivalent command is:

codex plugin marketplace add trailofbits/skills

The marketplace repo includes per-skill installation notes and pinned commit SHAs for reproducibility.

One caution before you install anything: Mitiga Labs demonstrated a proof-of-concept where a malicious skill silently exfiltrated an entire codebase in just four user interactions with an empty audit log. OWASP's Agentic Skills Top 10 now documents the emerging threat categories. Both Anthropic and Mitiga converge on the same guidance: install only from trusted sources, audit every bundled file, and distrust reputation metrics like stars and upvotes. SkillzBench is building toward this exact problem: a free directory that pins every skill to a commit SHA, security-scans and license-checks each version, and benchmarks Lift in a sandbox so you can see what a skill actually adds before you wire it into your workflow.

Before You Install: The Security Check Most Teams Skip

Before you install a single skill, pause. Security researchers at Mitiga Labs demonstrated that a seemingly legitimate "Testing-Validator" skill could silently exfiltrate an entire local codebase to an attacker's public GitHub repository — all in just 4 user interactions, with the skill-audit log coming back completely empty. The agent followed the script exactly as written, whether anyone reviewed it or not.

That's because skills aren't just prompts. As Mitiga's researchers put it, skills are "pre-baked behaviors, so a single one-click install can quietly wire exfiltration straight into your delivery flow." And the ecosystem is growing faster than anyone can vet it: one skill ("Find-Skills") hit over 200K downloads within roughly three months of Anthropic's December 2025 Agent Skills announcement, while skills.sh has become the largest public catalog of skills.

OWASP has responded with the Agentic Skills Top 10, the first comprehensive security framework for AI agent skills, documenting the most critical risks across major platforms with evidence-based mitigations. Notably, Anthropic and Mitiga independently converge on the same core guidance — install skills only from trusted sources, and audit every bundled file, especially code and anything that touches the network.

Before installing any skill, run through this check:

• Source it from a trusted origin only — Anthropic's engineering team recommends installing skills exclusively from sources you can verify.
• Audit the bundled files yourself, paying special attention to scripts and network-touching instructions.
• Distrust stars, upvotes, and download counts — Mitiga showed these reputation metrics can be inflated by bots and fake accounts.
• Treat any instruction that silences logging or adds allowlists as an immediate red flag.
• Break down the skill's behavior before approval, potentially using another LLM to analyze what it actually does.

The problem is that doing all of this manually for every skill is exactly what most teams skip — which is why verification needs to be built into the pipeline, not left to good intentions. That's the gap SkillzBench is building to close: pinning every skill version to a commit SHA, running security scans and license checks, and testing each skill in a sandboxed benchmark environment — all free when it launches. Until then, treat every install like an onboarding document from a stranger: read it before you let your agent act on it.

From Pilot to Production: Measuring Whether Your Skills Actually Help

Installing a skill pack is not the finish line — it is the start of a measurement loop. The agents you equip will keep changing underneath you, and the skills that helped last month may drift, break, or get outpaced as upstream updates land.

The honest place to begin is with how you read the market numbers. Reported AI adoption ranges from 23% to 79% depending on methodology — one statistics collection puts it bluntly: both numbers are real, they just answer different questions put to different people. Treat any single adoption figure, including your own internal ones, as qualified context rather than proof.

What the evidence does support is that workflow-specific deployments succeed where generic pilots fail. A widely cited MIT study found most generative AI pilots showed no measurable financial return, while the ones that worked were built around a specific workflow rather than a generic tool bolted on. That is exactly how skills should be tied in: one skill pack per workflow, not a pile of everything at once.

Three habits keep the loop tight:

• Re-benchmark as upstream changes land. Skills are living instruction packages; when the skill's source updates or the underlying model changes, re-test with and without the skill to confirm the Lift still holds.
• Keep loadouts minimal per agent. Toggle only the skills and tools each agent needs for its workflow — a lean loadout is easier to measure, easier to audit, and less exposed to risk.
• Tie every skill to a named workflow. Measure the skill against that workflow's baseline, not against vague "productivity" claims.

The baseline matters because reliability, not capability, is the gap. Claude Opus 4.6 completes 70-minute tasks at 80% success but 12-hour tasks at only 50%, per the METR benchmark, and a UC Berkeley study found seven multi-agent frameworks failing 41%–86.7% of tasks. A skill earns its place only if it moves those numbers on your specific tasks.

This is the problem SkillzBench is being built to solve. Its free directory will continuously verify skills — pinning every version to a commit SHA, security-scanning, license-checking — and benchmark each one in a sandbox with the same model, with and without the skill, publishing the Lift in percentage points. A free MCP connector will let you toggle skills per agent, and alerts will flag upstream changes so you know when to re-benchmark. Everything stays free, and money never touches scores.

Going forward, use SkillzBench's directory and MCP connector to discover, verify, and equip skills — then measure honestly, iterate, and let the Lift decide what stays.

ctaText: Skills, proven. Join the SkillzBench waitlist to get verified skills and benchmarked Lift for your agents — free. socialProofText: ~26% of published agent skills carry at least one vulnerability. SkillzBench verifies every version and shows the Lift separately from ratings.