How to Share Reusable Workflows Across Teams with Codex Plugins

Mar 27, 2026

Problem

Our team had 12 developers. Each person had their own way of deploying code, running tests, and setting up environments. When a new person joined, they spent their first two days configuring tools and asking “how do you run the tests again?”

I documented everything. I wrote wikis. I created onboarding checklists. But documentation gets stale. People skipped steps. The “works on my machine” problem never went away.

Then I discovered Codex Plugins could solve this. One plugin could package our entire workflow and share it with the whole team.

Codex Plugins let me package development processes into installable units. Once installed, every team member gets identical skills, MCP configurations, and integrations.

Before plugins, team workflow sharing meant:

Documenting setup steps in wikis (gets outdated)
Sharing dotfiles via Git (incomplete, hard to maintain)
Walking new hires through setup (time-consuming, inconsistent)

With plugins, it becomes:

Create plugin with team standards
Publish to team registry
Team runs one install command
Updates propagate automatically

Creating a Team Workflow Plugin

I created a plugin that captures our entire development workflow. Here’s what went into it.

Plugin Structure

team-workflow-plugin/
  plugin.json
  skills/
    deploy.md
    test.md
    review.md
  mcp/
    servers.json
  integrations/
    github.json
    jira.json

Plugin Metadata

{
  "name": "@mycompany/dev-workflow",
  "version": "1.4.0",
  "description": "Team development workflow standards",
  "author": "platform-team",
  "skills": ["skills/*.md"],
  "mcp": "mcp/servers.json",
  "integrations": "integrations/*.json"
}

Team Standards as Skills

I captured our deployment process in a skill:

---
name: deploy
description: Deploy to staging or production with team standards
triggers:
  - "deploy to staging"
  - "deploy to production"
  - "ship it"
---

Run the deployment process:

1. Run linting and type checks
2. Execute test suite with coverage
3. Build production bundle
4. Run database migrations (if any)
5. Deploy to target environment
6. Run smoke tests
7. Notify team channel

Environment is determined by trigger phrase.
Production deployments require approval from 2 team leads.

Our code review checklist became a skill:

---
name: review
description: Code review with team standards
triggers:
  - "review this PR"
  - "team review"
---

Review against team standards:

1. TypeScript strict mode - no `any` types
2. Test coverage minimum 80%
3. All exports have JSDoc comments
4. No console.log in production code
5. Environment variables documented
6. Error handling uses our Result type
7. Database queries use parameterized statements

Format as GitHub PR review comments.

MCP Configuration for Team Tools

{
  "mcpServers": {
    "company-docs": {
      "command": "mcp-context7",
      "args": ["--library", "/company/internal-docs"]
    },
    "staging-db": {
      "command": "mcp-postgres",
      "args": ["--connection-string", "${STAGING_DATABASE_URL}"]
    }
  }
}

Team Integrations

{
  "name": "github",
  "type": "oauth",
  "scopes": ["repo", "read:org", "workflow"],
  "baseUrl": "https://github.com/mycompany"
}

Publishing to Team Registry

I set up a private plugin registry for our company.

Setting Up the Registry

# Create a private registry (we used npm internally)
npm init --scope=@mycompany

# Configure Codex to use private registry
codex config set registry https://npm.mycompany.com

Publishing the Plugin

# Build and package
codex plugin package

# Publish to private registry
codex plugin publish --registry https://npm.mycompany.com

# Tag versions for stability
codex plugin tag @mycompany/dev-workflow 1.4.0 stable

Team Onboarding Experience

New team members now onboard in minutes, not days.

One-Command Setup

# Install team workflow plugin
codex plugin install @mycompany/dev-workflow

Output shows what’s installed:

Installing @mycompany/dev-workflow v1.4.0...

Installed:
  Skills: deploy, test, review
  MCP servers: company-docs, staging-db
  Integrations: github, jira

Configuration:
  - GitHub OAuth configured
  - Jira integration ready
  - Team documentation accessible

Run 'codex skill list' to see available skills.

What New Developers Get

After installation, they have:

Our deployment workflow as a callable skill
Code review standards built in
MCP access to internal documentation
Pre-configured GitHub and Jira integrations

No wiki reading. No setup walkthrough. Just one command.

Managing Updates Across the Team

When I update the plugin, everyone gets the changes.

Publishing Updates

# Make changes to plugin
vim skills/deploy.md

# Bump version
npm version minor  # 1.4.0 -> 1.5.0

# Publish update
codex plugin publish --registry https://npm.mycompany.com

Team Receives Updates

Team members see available updates:

codex plugin outdated

# Output
# @mycompany/dev-workflow
#   Current: 1.4.0
#   Latest:  1.5.0
#   Changes: Added database migration checks to deploy skill

They update with:

codex plugin update @mycompany/dev-workflow

Version Pinning for Stability

Critical projects pin specific versions:

{
  "plugins": {
    "@mycompany/dev-workflow": "1.4.0"
  }
}

This prevents unexpected changes from breaking stable workflows.

Real Onboarding Metrics

I tracked onboarding time before and after the plugin:

Metric	Before Plugin	After Plugin
Environment setup	4 hours	15 minutes
First successful deploy	Day 3	Day 1
Questions about process	20+ per hire	3-4 per hire
Wiki documentation accuracy	60%	100% (plugin is source of truth)

Common Issues

Issue 1: Permission Denied on Private Registry

Team members got this error:

Error: Permission denied accessing @mycompany/dev-workflow

I fixed it by having them authenticate:

npm login --registry https://npm.mycompany.com
codex plugin install @mycompany/dev-workflow

Issue 2: Environment Variables Not Set

The plugin expects certain environment variables:

Error: STAGING_DATABASE_URL not defined

I added a setup check to the plugin:

---
name: setup
description: Verify environment configuration
triggers:
  - "check setup"
  - "verify environment"
---

Check that required environment variables are set:
- STAGING_DATABASE_URL
- PRODUCTION_DATABASE_URL
- JIRA_API_TOKEN
- GITHUB_TOKEN

Guide user through setting any missing variables.

New hires run this first:

codex skill run setup

Issue 3: Conflicting Plugin Versions

Two projects needed different plugin versions:

{
  "plugins": {
    "@mycompany/dev-workflow": "1.3.0"
  }
}

{
  "plugins": {
    "@mycompany/dev-workflow": "1.5.0"
  }
}

Codex handles this by loading the project-specific version when working in that directory.

Best Practices for Team Plugins

DO

Document trigger phrases

Create a quick reference for the team:

## Available Skills

- "deploy to staging" - Deploy to staging environment
- "deploy to production" - Deploy to production (requires approval)
- "review this PR" - Run team code review
- "check setup" - Verify environment configuration

Version everything

Use semantic versioning. Breaking changes get major versions:

# Non-breaking additions
npm version minor

# Breaking changes
npm version major

Include a setup skill

Make onboarding self-service:

---
name: onboard
description: Complete developer onboarding
triggers:
  - "onboard me"
  - "setup my environment"
---

Walk through:
1. Environment variable setup
2. Tool installation verification
3. First deployment walkthrough
4. Code review process explanation

DON’T

Don’t hardcode secrets

// WRONG
{
  "env": {
    "API_KEY": "sk-actual-key-here"
  }
}

// CORRECT
{
  "env": {
    "API_KEY": "${TEAM_API_KEY}"
  }
}

Don’t skip documentation

Each skill needs clear documentation:

---
name: deploy
description: Deploy to staging or production
documentation: |
  This skill handles:
  - Linting and type checking
  - Test execution with coverage reporting
  - Database migrations
  - Deployment to target environment
  - Post-deploy smoke tests

  For production deploys, requires 2 approvals.
triggers:
  - "deploy to staging"
---

Don’t make breaking changes without notice

Announce breaking changes before publishing:

# v2.0.0 - Breaking Changes

The `deploy` skill now requires explicit environment parameter.

Before: "deploy" (deployed to staging)
After: "deploy to staging" or "deploy to production"

Action required: Update your habits by 2024-02-01

Summary

Codex Plugins transformed how our team shares workflows. What used to take days of documentation and walkthroughs now takes one command.

The key changes:

Plugin captures team standards in executable form
One install command replaces hours of setup
Updates propagate to everyone automatically
Documentation stays current because the plugin IS the documentation

For teams struggling with inconsistent setups and slow onboarding, plugin-based workflow sharing is worth the investment. The initial time to create a plugin pays back quickly with every new hire and every workflow update.

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:

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