How to choose between Codex plugins and custom skills when building your workflow

Apr 30, 2026

I spent hours browsing plugin marketplaces, reading “top 10 Codex plugins” articles, and comparing setups from other developers. But when I finally stepped back and looked at my workflow, I realized something: most of those plugins solved problems I didn’t have.

The Problem: Plugin FOMO

Here’s what happened. I installed 15 plugins because:

Everyone said they were “essential”
I was afraid of missing out on productivity gains
I thought more tools = better output

But my Codex instance became slower. Conflicts emerged. I spent more time managing plugins than actually coding. And half the features? I never used them.

+---------------------------+---------------------------+
| Plugin-Heavy Setup        | Base Codex + Custom Skills|
+---------------------------+---------------------------+
| 15+ plugins installed     | 3-5 custom skills         |
| Generic features          | Exact-fit solutions       |
| Dependency conflicts      | Zero dependencies          |
| Slow startup              | Fast, lean                 |
| Updates break things      | You control everything    |
| Learning curve per plugin | Build what you know       |
+---------------------------+---------------------------+

Environment

I’m using OpenAI Codex with the built-in skill-creator and skill-installer tools. My primary stack is Python/FastAPI for backend work and React/TypeScript for frontend.

What I Discovered

The Reddit community echoed what I was starting to suspect. One user put it bluntly:

“honestly for both claude and codex, no plugin is still the best plugin… feels like skill issue for the people who say otherwise… unless you’re just a vibe coder and not a software engineer”

Another added:

“I only use superpowers. the rest I create with codex to fit my needs. openai has skill-creator and skill-installer by default so that helps.”

The consensus was clear: Base codex with custom skills >>>>

The Solution: Build What You Need

OpenAI ships Codex with two built-in tools that most users ignore:

skill-creator - Generates skills from your descriptions
skill-installer - Manages your custom skills

These tools eliminate the need for most plugins. Here’s how I use them.

Example 1: Creating a Component Generator Skill

I work with React and TypeScript daily. Instead of installing a generic component generator plugin, I asked Codex to create a skill for my exact workflow:

"Create a skill for my React + TypeScript + Tailwind project that:
1. Generates component boilerplate with proper typing
2. Includes common hooks (useState, useEffect patterns)
3. Follows my team's naming conventions"

Codex generated this skill file:

---
name: react-component-creator
description: Generates React component boilerplate with TypeScript and Tailwind
triggers:
  - "create component"
  - "new react component"
  - "generate component"
---

## Instructions

When asked to create a React component:
1. Generate functional component with TypeScript props interface
2. Include proper imports (React, hooks as needed)
3. Add Tailwind classes for styling
4. Include JSDoc comments for documentation
5. Export component as default

## Template

```typescript
import React from 'react';

interface {ComponentName}Props {
  // Add props here
}

/**
 * {ComponentName} component description
 */
export default function {ComponentName}({ props }: {ComponentName}Props) {
  return (
    <div className="...">
      {/* Component content */}
    </div>
  );
}

### Example 2: API Endpoint Generator

For my FastAPI backend, I created another skill:

```markdown title="~/.codex/skills/api-endpoint-generator.md"
---
name: api-endpoint-generator
description: Generates FastAPI endpoint boilerplate with error handling
triggers:
  - "create api endpoint"
  - "new endpoint for"
---

## Instructions

When asked to create an API endpoint:
1. Generate endpoint function with proper type hints
2. Include request validation using Pydantic
3. Add standard error handling with HTTPException
4. Include OpenAPI documentation strings
5. Add logging for debugging

## Template

```python
@router.post("/{resource}", response_model={ResponseModel})
async def create_{resource}(
    request: {RequestModel},
    db: Session = Depends(get_db)
):
    """
    Create a new {resource}.
    """
    try:
        # Validate and process
        logger.info(f"Creating {resource}: {request}")
        result = await service.create(request, db)
        return result
    except ValueError as e:
        logger.error(f"Validation error: {e}")
        raise HTTPException(status_code=400, detail=str(e))

### Installing Custom Skills

Using the built-in `skill-installer` is straightforward:

```bash title="install-skill.sh"
# Using skill-installer (built-in)
codex skill install ./my-custom-skill.md

# Or manually place in:
~/.codex/skills/

I Think the Key Reason Is: Ownership

When you build custom skills, you own them:

No waiting for plugin authors - If a bug exists, you fix it
No breaking updates - You control when and how skills change
No feature bloat - Every line serves your exact needs
Version control - Skills are just markdown files, easy to track

As one Reddit user said: “We don’t like bloat here. Use what you need only.”

Common Mistakes I Made (So You Don’t Have To)

Mistake 1: Installing “All the Popular Plugins”

Just because a plugin has 10,000 downloads doesn’t mean it fits your workflow. I installed a Python formatter plugin that conflicted with my existing toolchain. Waste of time.

Mistake 2: Copying Others’ Setups Blindly

A senior engineer’s plugin stack works for their workflow, their projects, their preferences. Mine needed to be different.

Mistake 3: Fear of “Missing Out”

The anxiety of not having the “best” configuration led me to over-engineer. Starting minimal and adding only when I felt genuine friction worked much better.

Mistake 4: Not Learning Built-in Tools First

Before installing plugins, I should have explored what Codex provides out of the box. The skill-creator and skill-installer tools solved 90% of my needs.

Summary

In this post, I showed why Codex plugins are often unnecessary and how custom skills provide a better alternative. The key point is that base Codex with built-in tools like skill-creator and skill-installer lets you build exactly what you need without plugin bloat.

Start minimal. Build skills for your actual problems. Add complexity only when you feel friction in your workflow. Your future self will thank you.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

👨‍💻 OpenAI Codex Documentation

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!