# Equipping Agents for the Real World: A Deeper Look at Agent Skills
**作者**: Nainsi Dwivedi
**日期**: 2026-05-02T09:35:47.000Z
**来源**: [https://x.com/NainsiDwiv50980/status/2050509548272930881](https://x.com/NainsiDwiv50980/status/2050509548272930881)
---
As large language models continue to improve, I’ve noticed something interesting. The conversation is no longer about what models can do. It’s about what they can reliably execute in the real world.
On paper, today’s AI systems look incredibly capable. They can reason, write, analyze, and even interact with tools. But when you actually try to use them in real workflows, a gap becomes obvious.
Not a gap in intelligence.
A gap in execution.
That gap comes down to three things: structure, context, and procedure.
While exploring this problem, I came across a concept from Anthropic called Agent Skills. And the more I looked into it, the more it felt less like a feature—and more like a missing layer in how we build AI systems.
This isn’t a small improvement. It fundamentally changes how I think about building with AI.
From General Intelligence to Operational Capability
Most modern agents are already powerful. Give them access to tools, code execution, and files, and they can do things that used to require full software systems.
But when I started trying to use them for real tasks, a pattern emerged.
They don’t fail because they’re dumb.
They fail because they lack structure.
Real-world work requires:
Clear procedures, not just understanding
Defined workflows, not improvisation
Repeatability, not one-off success
Context that evolves beyond a single prompt
And this is where most AI workflows break.
You end up re-prompting, over-explaining, or manually guiding the system every time.
That’s not scalable.
This is exactly the gap Agent Skills are trying to solve.
What Are Agent Skills? (From a Builder’s Perspective)
The simplest way I think about Agent Skills is this:
A skill is a packaged capability.
Not just instructions.
Not just prompts.
But a combination of:
Guidance (what to do)
Context (when and why)
Execution (how it actually happens)
Technically, it’s just a structured folder with a SKILL.md file, supporting documents, and sometimes executable code.
But conceptually, it’s much more powerful.
It’s a way to take something you’ve figured out—some workflow, some process, some expertise—and turn it into something an agent can reuse.
Instead of rebuilding behavior every time, you install it.
That shift alone changes everything.
The Anatomy of a Skill (How I See It)
At the center of every skill is a SKILL.md file.
What’s interesting is how it’s structured.
At the top, you define metadata like name and description. This isn’t just for organization—it’s how the agent decides whether to use the skill at all.
That made me realize something subtle but important:
The problem isn’t just giving AI instructions.
It’s helping AI decide when those instructions matter.
Then comes the actual guidance—the “how to do this task” part.
And if things get complex, you don’t overload a single file. You break it into layers:
Core instructions
Supporting documents
Edge-case handling
Which leads to the most important idea behind all of this.
Progressive Disclosure Changed How I Think About Context
Before this, I used to think the solution to better AI outputs was “more context.”
More prompts.
More examples.
More instructions.
But that quickly hits limits.
What Agent Skills introduce is a different approach:
Don’t load everything.
Load only what’s needed.
The agent starts with awareness (metadata), then pulls in deeper context only when relevant.
This is exactly how we work as humans. We don’t memorize entire manuals—we navigate them.
And suddenly, the context window stops being a limitation. It becomes a navigation problem.
That shift is huge.
Skills in Action: Where This Actually Matters
Take something simple like working with PDFs.
Most AI systems can understand a document. But ask them to reliably extract structured fields or fill forms, and things get inconsistent.
Why?
Because those tasks require precise, repeatable steps.
With a skill, you can define:
How to extract fields
What format to expect
Which steps to follow
What code to run
Now the agent isn’t guessing. It’s executing.
And that’s the difference between a demo and a system.
Why Code Inside Skills Is a Big Deal
One thing that really stood out to me is how skills can include executable code.
This solves a major limitation.
Language models are great at reasoning.
But they’re not always the best tool for doing.
Sorting, parsing, structured extraction—these are deterministic problems.
So instead of forcing the model to simulate them, you let code handle it.
The agent decides when to use code.
The code ensures how it gets done.
That combination—reasoning + execution—is what makes systems reliable.
How I’d Approach Building Skills
If I were building with this seriously, I wouldn’t start by designing skills upfront.
I’d start by watching where things break.
Where does the agent struggle?
Where do I repeat myself?
Where does output become inconsistent?
Those are signals.
From there:
Capture the working process
Turn it into structured instructions
Separate reusable parts
Add code where precision matters
Over time, you don’t just improve outputs.
You build a library of capabilities.
The Risk Side Most People Ignore
There’s also a serious side to this.
Skills don’t just add capability—they add power.
And power without control becomes risk.
A poorly designed skill could:
Leak data
Call unsafe APIs
Execute unintended actions
So the mindset has to shift from “prompt engineering” to something closer to system design and security.
You’re no longer just talking to AI.
You’re extending it.
What This Means Going Forward
The more I think about it, the clearer the shift becomes.
We’re moving from:
Using AI → to building with AI
Prompting → to structuring systems
Intelligence → to execution
And Agent Skills sit right in the middle of that transition.
They turn knowledge into something usable.
Reusable.
Composable.
Final Thought
If there’s one thing this changes for me, it’s this:
The question is no longer
“What can this model do?”
It’s
“What can this system reliably execute?”
And the answer increasingly depends on the skills you build into it.
Because in the end, intelligence alone isn’t enough.
Execution is what makes it real.
## 相关链接
- [Nainsi Dwivedi](https://x.com/NainsiDwiv50980)
- [@NainsiDwiv50980](https://x.com/NainsiDwiv50980)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [5:35 PM · May 2, 2026](https://x.com/NainsiDwiv50980/status/2050509548272930881)
- [3,425 Views](https://x.com/NainsiDwiv50980/status/2050509548272930881/analytics)
---
*导出时间: 2026/5/2 22:32:03*
---
## 中文翻译
# 装备智能体以应对现实世界：深入解析 Agent Skills
**作者**: Nainsi Dwivedi
**日期**: 2026-05-02T09:35:47.000Z
**来源**: [https://x.com/NainsiDwiv50980/status/2050509548272930881](https://x.com/NainsiDwiv50980/status/2050509548272930881)
---
随着大型语言模型持续改进，我注意到了一件有趣的事情。讨论的焦点不再在于模型能做什么，而在于它们能在现实世界中可靠地执行什么。
理论上，当今的 AI 系统看起来能力惊人。它们可以推理、写作、分析，甚至使用工具。但当你尝试在实际工作流中使用它们时，一道鸿沟变得显而易见。
这不是智力上的鸿沟。
这是执行上的鸿沟。
这道鸿沟归结为三件事：结构、上下文和流程。
在探索这个问题的过程中，我遇到了 Anthropic 提出的一个概念，叫做 Agent Skills（智能体技能）。我研究得越深，就越觉得这不仅仅是一个功能——它更像是构建 AI 系统时缺失的一层。
这并不是微小的改进。它从根本上改变了我对构建 AI 应用的思考方式。
从通用智能到操作能力
大多数现代智能体已经非常强大。给它们工具、代码执行能力和文件访问权限，它们就能做到以前需要完整软件系统才能完成的事情。
但当我开始尝试将它们用于实际任务时，一种模式浮现了出来。
它们失败不是因为它们笨。
它们失败是因为缺乏结构。
现实世界的工作需要：
清晰的流程，而不仅仅是理解
定义好的工作流，而不是即兴发挥
可重复性，而不是一次性的成功
能够超越单个提示词演进的上下文
而这正是大多数 AI 工作流崩溃的地方。
你最终不得不反复调整提示词、过度解释，或者每次都手动引导系统。
这是不可扩展的。
这正是 Agent Skills 试图解决的鸿沟。
什么是 Agent Skills？（从构建者的视角）
我认为理解 Agent Skills 最简单的方式是：
技能是一种打包好的能力。
不仅仅是指令。
不仅仅是提示词。
而是以下几者的结合：
指导（做什么）
上下文（何时以及为何）
执行（实际如何发生）
从技术上讲，它只是一个包含 SKILL.md 文件、支持文档，有时还包括可执行代码的结构化文件夹。
但从概念上讲，它要强大得多。
这是一种将你已经弄清楚的东西——某种工作流、某个流程、某种专业知识——转化为智能体可以重用的东西的方式。
你不再每次都重新构建行为，而是直接安装它。
仅此这一项转变就改变了一切。
技能的剖析（我的理解）
每个技能的核心都是一个 SKILL.md 文件。
有趣的是它的结构方式。
在顶部，你需要定义名称和描述等元数据。这不仅仅是为了组织——它是智能体决定是否使用该技能的方式。
这让我意识到一个微妙但重要的问题：
问题不仅仅在于给 AI 下达指令。
而在于帮助 AI 决定何时这些指令是重要的。
然后是实际的指导——即“如何做这项任务”的部分。
如果事情变得复杂，你不必把所有内容塞进一个文件。你可以将其分层：
核心指令
支持文档
边缘情况处理
这就引出了这背后最重要的理念。
渐进式披露改变了我对上下文的思考
在此之前，我常认为获得更好的 AI 输出的解决方案是“更多的上下文”。
更多的提示词。
更多的例子。
更多的指令。
但这很快就会遇到瓶颈。
Agent Skills 引入了一种不同的方法：
不要加载所有内容。
只加载需要的内容。
智能体从感知（元数据）开始，然后仅在相关时引入更深入的上下文。
这正是我们人类的工作方式。我们不会背诵整本手册——我们是在查阅它们。
突然间，上下文窗口不再是限制。它变成了一个导航问题。
这种转变是巨大的。
实战中的技能：这真正重要之处
以处理 PDF 这样简单的任务为例。
大多数 AI 系统都能理解文档。但如果你要求它们可靠地提取结构化字段或填写表格，结果就会变得不一致。
为什么？
因为这些任务需要精确、可重复的步骤。
通过技能，你可以定义：
如何提取字段
预期什么样的格式
遵循哪些步骤
运行什么代码
现在，智能体不再是猜测。它是在执行。
这就是演示和系统之间的区别。
为什么技能中的代码至关重要
让我印象深刻的一点是技能可以包含可执行代码。
这解决了一个主要的局限性。
语言模型擅长推理。
但它们并不总是执行任务的最佳工具。
排序、解析、结构化提取——这些都是确定性的问题。
因此，不要强迫模型去模拟它们，而是让代码来处理。
智能体决定何时使用代码。
代码确保如何完成。
这种组合——推理 + 执行——正是让系统变得可靠的原因。
我会如何构建技能
如果我认真构建这个系统，我不会一开始就设计技能。
我会先观察问题出在哪里。
智能体在哪里遇到困难？
我在哪里重复了自己？
输出在哪里变得不一致？
这些都是信号。
然后：
捕获有效的工作流程
将其转化为结构化指令
分离可重用的部分
在需要精确的地方添加代码
随着时间的推移，你不仅仅是提高了输出质量。
你建立了一个能力库。
大多数人忽视的风险
这也有严肃的一面。
技能不仅仅是增加了能力——它们还增加了力量。
而没有控制的力量就会变成风险。
一个设计糟糕的技能可能会：
泄露数据
调用不安全的 API
执行意外的操作
因此，思维模式必须从“提示词工程”转向更接近系统设计和安全的层面。
你不再仅仅是在与 AI 对话。
你是在扩展 AI。
这对未来意味着什么
我思考得越多，这种转变就越清晰。
我们正在从：
使用 AI 转向 用 AI 构建
提示词转向 构建系统
智能转向 执行
而 Agent Skills 正处于这一转变的中心。
它们将知识转化为可用的东西。
可重用的。
可组合的。
最后的思考
如果说这一概念对我有什么改变，那就是：
问题不再是
“这个模型能做什么？”
而是
“这个系统能可靠地执行什么？”
而答案越来越取决于你构建进其中的技能。
因为最终，仅靠智能是不够的。
执行才能使其成为现实。
## 相关链接
- [Nainsi Dwivedi](https://x.com/NainsiDwiv50980)
- [@NainsiDwiv50980](https://x.com/NainsiDwiv50980)
- [升级到 Premium](https://x.com/i/premium_sign_up)
- [2026年5月2日 下午5:35](https://x.com/NainsiDwiv50980/status/2050509548272930881)
- [3,425 次观看](https://x.com/NainsiDwiv50980/status/2050509548272930881/analytics)
---
*导出时间: 2026/5/2 22:32:03*