This week, the most common Codex moment in dev teams looks the same: someone pastes a chunk of notes into a thread, then immediately wonders why they have to do it again next time.

The promise behind Codex plugins and skills is that you stop re-copying the same context and start reusing it—first by connecting to the right information sources, then by enforcing the right team process.

Codex plugins: Google Drive and email-style connections

OpenAI describes Codex plugins as the mechanism that lets Codex “connect to other tools and information sources.” In practice, that means a plugin can be used to reference files stored in Google Drive, scan an email inbox, or work with information that lives in other tools outside the chat.

OpenAI also frames plugins as “simple and immediately useful.” The key idea is that if the connected plugin already has the information you need, you can ask Codex to use that information without copying and pasting everything into the thread.

Access is straightforward. In the Codex interface, you open plugins by selecting Plugins in the top-left corner. From there, you can check recommended plugins or ones you already installed, browse the plugin library, or create a new plugin.

The tension teams feel is obvious: without a connection, every workflow starts with the same manual step—copy, paste, and reformat—no matter how many times you’ve done it before.

The analysis is that plugins exist to remove that friction by making “where the data comes from” a reusable capability rather than a repeated user action.

The conclusion is that plugins turn external context into something Codex can fetch on demand.

Codex skills: reducing repeated explanations of team playbooks

If plugins solve the “where’s the data?” problem, skills target the “how do we do this here?” problem.

The article’s example starts with a reality most teams recognize: even something as routine as writing a newsletter can look different across companies. The source notes that “10 companies can structure a newsletter in 10 different ways,” and that customer-facing messages often require a company-specific tone. It also points out that sales teams typically follow essential procedures such as extracting account data, checking usage, and preparing materials for a business review.

In that setting, a Codex skill acts like a playbook. The source explains that skills make Codex follow those procedures consistently, so users do not have to re-explain the same process every time.

It also adds a practical nuance about creation. The source says that creating skills usually requires more technical expertise than creating a new plugin. However, it separates the creation complexity from day-to-day usage: the UI path for using a skill is described as independent of plugins.

Instead of navigating through plugin setup, you call a skill directly from a thread. The source describes the interaction as pressing $ in the thread and selecting the skill you want to run.

A concrete example in the source is a skill called “Customer Update.” In that scenario, a team wants weekly updates prepared in the format they prefer. The source includes the call example verbatim:

$customer-update Create a weekly customer update using the notes and files in this folder.

The article also reiterates how you can find or create skills from the interface. It states that you can select Plugins in the top-left corner to view skills, browse the library, or create a new skill. At the same time, it explicitly says it will not cover the detailed skill creation process in this piece.

The tension here is that teams often spend time describing process rules in plain text, and those descriptions are easy to get wrong or forget.

The analysis is that skills formalize those rules so the user’s job becomes selecting the right playbook rather than rewriting it.

The conclusion is that skills make team workflows repeatable through a single $ call.

Plugins vs skills: separating data connections from process compliance

The most important shift in the article is not that Codex can do more, but that it divides responsibilities more cleanly.

Previously, the user often had to copy and paste information repeatedly just to get it into the chat. The source contrasts that with the new separation: plugins handle “bringing in information from other tools,” while skills handle “following the team’s way of working.”

The article lays out a clear rule set. If Codex needs to use information from another tool, you use a plugin. If Codex needs to follow a process, you use a skill. And if Codex must both pull in connected-tool information and follow the team process, you use both.

The example ties the two together. It describes using a Google Drive plugin to pull the latest files from a specific folder, then drafting a weekly project update in the team’s standard format.

The source provides the combined request example verbatim:

text

$google-doc-html-email-stager Use the Google Drive plugin to pull the latest files from this folder and draft this week’s project update in our team’s standard format.

The tension this resolves is that “one tool does everything” often fails in practice: if you only have a process template, you still need fresh data; if you only have data access, you still need consistent formatting and rules.

The analysis is that the plugin/skill split makes causation explicit: plugins change the inputs Codex can access, while skills change the steps Codex follows.

The conclusion is that Codex is designed to execute connection (plugin) and procedure (skill) separately, then combine them when needed.

Result: the steps developers explain every time become fixed in a skill call

The change developers feel immediately is that they no longer have to spell out team rules in text for every run. Instead, the workflow becomes a repeatable invocation.

At the same time, the article draws a boundary that matters for expectations. Plugins handle information connections, so using skills alone does not automatically solve “latest external data access.” If you want Codex to fetch up-to-date content from connected tools, you still need the plugin side of the setup.

The resolution is that Codex is built so that a single $ call can trigger both the connection and the procedure—separately defined, then executed together—so the next run starts where the last one left off.