### The Silent Evolution: OpenAI’s Quiet Adoption of ‘Skills’ in ChatGPT and Beyond

If you’ve used ChatGPT recently and asked it to do something more than just write text, you might have noticed something different. You ask for the current weather, and it fetches it. You ask it to summarize a recent news article, and it browses the web. You upload a CSV file and ask for a visualization, and it generates a graph. This isn’t just a smarter language model; it’s a model with *skills*.

While OpenAI hasn’t made a grand announcement about a “Skill Store” akin to Amazon’s Alexa, it has been quietly and steadily embedding action-oriented capabilities into its core products. This evolution from a pure text generator to an active agent is one of the most significant shifts in the AI landscape, and it’s happening right under our noses in both the user-friendly ChatGPT interface and the developer-focused command line.

#### What Are “Skills” in the AI Context?

In simple terms, a “skill” is the ability for a Large Language Model (LLM) to do more than just process and generate language. It’s the capacity to interact with external tools, run code, or access live data to accomplish a specific task. Think of it as the difference between an AI that *knows* what a flight from New York to London is and an AI that can actually *search for and book* that flight for you.

This is a fundamental change, moving the AI from being an “oracle” to being an “agent.”

#### The Evidence: Where to Find These Emerging Skills

The adoption of skills is most visible in three key areas:

**1. GPTs and Actions (The Evolution of Plugins)**

The most public-facing example was the rollout of ChatGPT Plugins. By enabling plugins for services like WolframAlpha, Expedia, and Zapier, OpenAI gave ChatGPT its first real set of external skills. The model could now solve complex mathematical equations, plan a trip, or interact with thousands of other apps.

This system is now evolving into the more personalized **GPTs**, where users can create custom versions of ChatGPT. A crucial part of this is defining “Actions,” which are essentially custom skills that connect the GPT to an external API. You can create a GPT that has the “skill” to check your company’s internal knowledge base or post updates to a project management tool. This is a direct, albeit developer-centric, way of building and assigning skills.

**2. Function Calling: The Developer’s Gateway to Skills**

Perhaps the most powerful and fundamental implementation of this concept is “function calling” in the OpenAI API. This feature allows developers to describe their application’s functions to the model.

Here’s how it works:
* A developer defines a function in their code, for example, `send_email(to, subject, body)`.
* When a user makes a request like, “Email my team about the project update,” the model doesn’t try to write the email itself. Instead, it recognizes the user’s intent and generates a structured JSON object: `{ “name”: “send_email”, “arguments”: { “to”: “team@example.com”, “subject”: “Project Update”, … } }`.
* The developer’s application then takes this JSON object and executes its own `send_email` function with the provided arguments.

This is the bedrock of AI skills. The model acts as an intelligent natural language router, translating human requests into executable commands for external tools.

**3. The Codex CLI: Skills for the Command Line**

For developers living in the terminal, the OpenAI CLI (often leveraging the Codex or newer GPT-4 models) has become a powerful companion. While not a formal “skill” system, the pattern of use is identical. Developers and power users are creating scripts and shell aliases that act as specialized skills.

For instance, a developer might create a command-line “skill” called `refactor`:
`$ refactor my_function.py –make-more-efficient`

Behind the scenes, this script pipes the code from `my_function.py` along with the prompt “make this more efficient” to the OpenAI API. The response is then used to update the file. Other common CLI-based skills that have emerged in the community include:

* **`docstring`**: Automatically generate documentation for a function.
* **`git-commit`**: Generate a descriptive Git commit message based on the staged changes.
* **`explain-command`**: Take a complex shell command (like `awk` or `sed`) and explain it in plain English.

These aren’t pre-packaged skills from OpenAI, but rather an emergent behavior. OpenAI has provided the powerful tool (the model), and the developer community is forging it into a set of discrete, reusable skills for their daily workflows.

#### Why This Quiet Rollout Matters

By gradually integrating these skills instead of launching a centralized, branded “Skill Store,” OpenAI is fostering a more organic ecosystem. It allows the model’s capabilities to expand naturally, driven by both user needs (in ChatGPT) and developer innovation (via the API and CLI).

This silent evolution is profoundly changing our relationship with AI. We are moving past the era of simply “chatting” with a bot. We are now beginning to direct, command, and collaborate with a capable agent that can interact with the digital world on our behalf. The skills are already here; you just need to know what to ask for.