File: README.md Copy Chapter

Awesome Codex Skills

A curated list of practical Codex skills for automating workflows across the Codex CLI and API.

Give your skills real-world actions Copy Chapter

Skills tell your agent how to work. An MCP Gateway gives it secure access to the tools it needs.

Composio MCP Gateway provides a single MCP endpoint for 1,000+ integrations with built-in authentication, team-based access controls, audit logs, and production-ready reliability.

Quickstart: Add Skills to Codex Copy Chapter

Install with the Skill Installer (recommended) Copy Section

git clone https://github.com/ComposioHQ/awesome-codex-skills.git
cd awesome-codex-skills
# Install one or more skills into $CODEX_HOME/skills (defaults to ~/.codex/skills)
python skill-installer/scripts/install-skill-from-github.py --repo ComposioHQ/awesome-codex-skills --path meeting-notes-and-actions

The installer fetches the skill and places it in $CODEX_HOME/skills/<skill-name>. Restart Codex to pick up new skills.

Manual install Copy Section

1. Copy the desired skill folder (e.g., ./spreadsheet-formula-helper) into $CODEX_HOME/skills/ (defaults to ~/.codex/skills/).
2. Restart Codex so it loads the new metadata.
3. In your next session, describe the task or mention the skill name; Codex will trigger matching skills based on their description frontmatter.

Contents Copy Chapter

• Bernstein - Multi-agent orchestrator with Codex CLI adapter. Runs parallel Codex agents in isolated git worktrees with quality gates.
• What Are Codex Skills?
• Skills
  • Development & Code Tools
  • Productivity & Collaboration
  • Communication & Writing
  • Data & Analysis
  • Meta & Utilities
• Using Skills in Codex
• Creating Skills
• Contributing
• Join the Community

What Are Codex Skills? Copy Chapter

Codex skills are modular instruction bundles that tell Codex how to execute a task the way you want it done. Each skill lives in its own folder with a SKILL.md that includes metadata (name + description) and step-by-step guidance. Codex reads the metadata to decide when to trigger a skill and loads the body only after it fires, keeping context lean.

Skills Copy Chapter

Development & Code Tools Copy Section

• brooks-lint - AI code reviews grounded in six classic engineering books — decay risk diagnostics with book citations, severity labels, and four analysis modes (PR review, architecture audit, tech debt, test quality). Install: python3 ~/.codex/skills/.system/skill-installer/scripts/install-skill-from-github.py --repo hyhmrright/brooks-lint --path skills/brooks-lint --name brooks-lint
• bringyour-migration-auditor - Audit Claude Code to Codex harness migrations for AGENTS.md/CLAUDE.md scope, hooks, MCP config, skills, secrets, and validation notes. Install: python3 ~/.codex/skills/.system/skill-installer/scripts/install-skill-from-github.py --repo unitedideas/bringyour-mcp --path skills/bringyour-migration-auditor --name bringyour-migration-auditor
• codebase-migrate/ - Run large codebase migrations and multi-file refactors in reviewable batches with CI verification.
• codebase-recon - Analyze git history to understand a codebase before reading any code — surfaces hotspots, bug magnets, bus factor, momentum, and high-risk files (hotspot ∩ bug-magnet) via auto-scaled analysis. Install: python3 ~/.codex/skills/.system/skill-installer/scripts/install-skill-from-github.py --repo yujiachen-y/codebase-recon-skill --path skills/codebase-recon --name codebase-recon
• create-plan/ - Quickly draft concise execution plans for coding tasks.
• deploy-pipeline/ - End-to-end Stripe → Supabase → Vercel release pipelines with verify and rollback.
• Emdash Skills - 14-category autonomous product-building OS: CF Workers + Hono + Angular + D1 + Stripe. One-line prompts to deployed SaaS with 94 reference docs, 18 agents, and Codex-native .agents/skills/ support.
• gh-address-comments/ - Address review or issue comments on the open GitHub PR for the current branch using gh.
• gh-fix-ci/ - Inspect failing GitHub Actions checks, summarize failures, and propose fixes.
• mcp-builder/ - Build and evaluate MCP servers with best practices and an evaluation harness.
• pr-review-ci-fix/ - Automated GitHub/GitLab PR review plus CI auto-fix loop via the Composio CLI.
• sentry-triage/ - Diagnose Sentry issues by mapping stack frames to local source — no copy-paste.
• webapp-testing/ - Run targeted web app tests and summarize results.
• AuraKit - All-in-one skill framework: 46 modes, 23 sub-agents, 6-layer OWASP security, 10 lifecycle hooks, ~55% token savings. Install: npx @smorky85/aurakit
• Vibe-Skills - Governed Codex skill harness for staged, test-driven work: routes 340+ skills through requirement freeze, plan approval, execution, verification evidence, and cross-session memory.
• polywave - Parallel agent coordination with structural merge safety. Scout decomposes, Wave agents implement in isolated worktrees with disjoint file ownership. Same protocol on Claude Code and Codex.

Productivity & Collaboration Copy Section

• connect/ - Connect Codex to 1000+ apps via the Composio CLI for real actions (Slack, GitHub, Notion, etc.).
• connect-apps/ - Wire up Composio CLI connections for Claude and kick off app workflows from the shell.
• issue-triage/ - Triage Linear or Jira backlogs and run bug sweeps from the terminal.
• linear/ - Manage issues, projects, and team workflows in Linear.
• meeting-insights-analyzer/ - Analyze meeting transcripts for themes, risks, and follow-ups.
• meeting-notes-and-actions/ - Turn meeting transcripts into summaries with decisions and owner-tagged action items.
• internal-comms/ - Craft internal announcements, updates, and stakeholder messaging.
• invoice-organizer/ - Normalize and extract invoice data for tracking and reporting.
• notion-knowledge-capture/ - Convert chats or notes into structured Notion pages with proper linking.
• notion-meeting-intelligence/ - Prepare meeting materials with Notion context plus Codex research.
• notion-research-documentation/ - Synthesize multiple Notion sources into briefs, comparisons, or reports with citations.
• notion-spec-to-implementation/ - Turn Notion specs into implementation plans, tasks, and progress tracking.
• support-ticket-triage/ - Triage customer support tickets with categories, priority, next actions, and draft replies.
• file-organizer/ - Organize, rename, and tidy files to keep workspaces clean.
• paperjsx/ - Generate PPTX presentations, DOCX documents, XLSX spreadsheets, and PDF invoices/reports/charts from structured JSON. Runs locally via @paperjsx/mcp-server — no API key, no network calls.
• skill-share/ - Share skills and reusable instructions across teammates.
• Taisly Agent Kit - Publish approved short-form videos from Codex with a bundled skill, CLI, and remote MCP server for TikTok, Instagram Reels, YouTube Shorts, X, and Facebook.

Communication & Writing Copy Section

• codex-sms-verification - External repo: real-SIM SMS verification for AI agents via VirtualSMS MCP. 145+ countries, 2000+ services, both hosted (mcp.virtualsms.io) and local stdio transports.

• email-draft-polish/ - Draft, rewrite, or condense emails for the right tone and audience.

• changelog-generator/ - Create clear changelogs from commits or summaries.

• content-research-writer/ - Research and draft content with sourced citations.

• diasporic-intelligence - External repo: source-credit skill for consent-governed lineage AI with attribution, provenance, revocation, and non-impersonation boundaries.

• novel-writing - External repo: public Codex skill for fiction planning, chapter drafting, scene continuation, and revision.

• tailored-resume-generator/ - Tailor resumes to job descriptions with quantified impact.

• unslop - External repo: CLI and MCP server that removes AI writing patterns from text: tricolons, em-dash overuse, hedging stacks, and sycophancy openers. Works with Codex, Claude Code, Gemini CLI, and Cursor. Five intensity levels and a lint-only audit mode.

Data & Analysis Copy Section

• spreadsheet-formula-helper/ - Write and debug spreadsheet formulas, pivots, and array formulas.
• competitive-ads-extractor/ - Analyze competitor ads and extract structured insights.
• datadog-logs/ - Filter Datadog logs from the shell via the Composio CLI, with JSON-friendly output and digest workflows.
• developer-growth-analysis/ - Analyze Codex chat history for coding patterns and learning gaps.
• lead-research-assistant/ - Research leads and enrich records with firmographic data.
• domain-name-brainstormer/ - Brainstorm available domain names with criteria and checks.
• raffle-winner-picker/ - Randomly select winners with audit-friendly logs.
• langsmith-fetch/ - Pull LangSmith project/test data for analysis.
• helium-mcp/ - Search real-time news with bias scoring, get live market data, ML options pricing, and balanced news synthesis via MCP.

Meta & Utilities Copy Section

• brand-guidelines/ - Apply OpenAI/Codex brand colors and typography to artifacts.
• agent-deep-links/ - Build and validate deep links for Codex, Cursor, and VS Code with Slack-safe formatting and fallback guidance.
• canvas-design/ - Generate structured canvas layouts and design artifacts.
• image-enhancer/ - Upscale and refine images with configurable presets.
• slack-gif-creator/ - Generate GIFs for Slack with captions and styling.
• theme-factory/ - Create reusable theme tokens and palettes.
• video-downloader/ - Download and prepare videos for offline review.
• template-skill/ - Starter template for building new skills.
• skill-installer/ - Helper scripts to install skills from curated lists or GitHub paths.
• skill-creator/ - Guidance for building effective Codex skills with progressive disclosure.

Using Skills in Codex Copy Chapter

• Skills live in $CODEX_HOME/skills (default ~/.codex/skills). Each subfolder needs a SKILL.md with name and description frontmatter.
• After installing or updating a skill, restart Codex so it reloads metadata.
• In a session, describe the task naturally; Codex auto-triggers skills whose descriptions match the request. You can also mention a skill by name if you want it considered.
• To verify installation, list installed skills (ls ~/.codex/skills) and inspect metadata (head ~/.codex/skills/<skill>/SKILL.md).

Creating Skills Copy Chapter

Skill layout:

skill-name/
├── SKILL.md          # Required: instructions + YAML frontmatter
├── scripts/          # Optional: helper scripts for deterministic steps
├── references/       # Optional: long-form docs loaded only when needed
└── assets/           # Optional: templates or files used in outputs

Basic SKILL.md template:

---
name: my-skill-name
---

# My Skill Name

Clear instructions and steps for Codex to execute the task.

Best practices:

• Keep the description exhaustive about when to trigger; keep the body focused on execution steps.
• Use progressive disclosure: put detailed references in references/ and call them out from SKILL.md only when needed.
• Include scripts for repeatable or deterministic operations; mention when Codex should run them.
• Avoid extra docs (README, changelog) inside the skill folder to keep context lean.

Contributing Copy Chapter

PRs welcome. Add real, reusable skills, keep descriptions precise, and include any needed scripts or references. If you add new skills, ensure the description clearly states when Codex should trigger and test that metadata fits within context limits.

Join the Community Copy Chapter

• Join our Discord - Chat with other developers building Codex skills.
• Follow on X - Updates on new skills and features.
• Questions? [email protected]

Resources Copy Chapter

• Top Codex Skills

File: notion-knowledge-capture/evaluations/README.md Copy Chapter

Knowledge Capture Skill Evaluations

Evaluation scenarios for testing the Knowledge Capture skill across different Codex models.

Purpose Copy Chapter

These evaluations ensure the Knowledge Capture skill:

• Correctly identifies content types (how-to guides, FAQs, decision records, wikis)
• Extracts relevant information from conversations
• Structures content appropriately for each type
• Searches and places content in the right Notion location
• Works consistently across Haiku, Sonnet, and Opus

Evaluation Files Copy Chapter

conversation-to-wiki.json Copy Section

Tests capturing conversation content as a how-to guide for the team wiki.

Scenario: Save deployment discussion to wiki
Key Behaviors:

• Extracts steps, gotchas, and best practices from conversation
• Identifies content as How-To Guide
• Structures with proper sections (Overview, Prerequisites, Steps, Troubleshooting)
• Searches for team wiki location
• Preserves technical details (commands, configs)

decision-record.json Copy Section

Tests capturing architectural or technical decisions with full context.

Scenario: Document database migration decision
Key Behaviors:

• Extracts decision context, alternatives, and rationale
• Follows decision record structure (Context, Decision, Alternatives, Consequences)
• Captures both selected and rejected options with reasoning
• Places in decision log or ADR database
• Links to related technical documentation

Running Evaluations Copy Chapter

1. Enable the knowledge-capture skill
2. Submit the query from the evaluation file
3. Provide conversation context as specified
4. Verify all expected behaviors are met
5. Check success criteria for quality
6. Test with Haiku, Sonnet, and Opus

Expected Skill Behaviors Copy Chapter

Knowledge Capture evaluations should verify:

Content Extraction Copy Section

• Accurately captures key points from conversation context
• Preserves specific technical details, not generic placeholders
• Maintains context and nuance from discussion

Content Type Selection Copy Section

• Correctly identifies appropriate content type (how-to, FAQ, decision record, wiki page)
• Uses matching structure from reference documentation
• Applies proper Notion markdown formatting

Notion Integration Copy Section

• Searches for appropriate target location (wiki, decision log, etc.)
• Creates well-structured pages with clear titles
• Uses proper parent placement
• Includes discoverable titles and metadata

Quality Standards Copy Section

• Content is actionable and future-reference ready
• Technical accuracy is preserved
• Organization aids discoverability
• Formatting enhances readability

Creating New Evaluations Copy Chapter

When adding Knowledge Capture evaluations:

1. Use realistic conversation content - Include actual technical details, decisions, or processes
2. Test different content types - How-to guides, FAQs, decision records, meeting notes, learnings
3. Vary complexity - Simple captures vs. complex technical discussions
4. Test discovery - Finding the right wiki section or database
5. Include edge cases - Unclear content types, minimal context, overlapping categories

Example Success Criteria Copy Chapter

Good (specific, testable):

• "Structures content using How-To format with numbered steps"
• "Preserves exact bash commands from conversation"
• "Creates page with title format 'How to [Action]'"
• "Places in Engineering Wiki → Deployment section"

Bad (vague, untestable):

• "Creates good documentation"
• "Uses appropriate structure"
• "Saves to the right place"

File: notion-research-documentation/evaluations/README.md Copy Chapter

Research & Documentation Skill Evaluations

Evaluation scenarios for testing the Research & Documentation skill across different Codex models.

Purpose Copy Chapter

These evaluations ensure the Research & Documentation skill:

• Searches across Notion workspace effectively
• Synthesizes information from multiple sources
• Selects appropriate research report format
• Creates comprehensive documentation with proper citations
• Works consistently across Haiku, Sonnet, and Opus

Evaluation Files Copy Chapter

basic-research.json Copy Section

Tests basic research workflow with synthesis across multiple Notion pages.

Scenario: Research Q4 product roadmap and create summary
Key Behaviors:

• Searches Notion for roadmap-related pages
• Fetches multiple relevant pages (roadmap, product docs, meeting notes)
• Synthesizes information from different sources
• Selects appropriate format (Research Summary)
• Includes citations linking back to source pages
• Creates structured document with clear sections

research-to-database.json Copy Section

Tests creating research documentation in a Notion database with properties.

Scenario: Research competitor landscape and save to Research database
Key Behaviors:

• Searches for existing competitive intelligence in Notion
• Identifies Research database as target
• Fetches database schema to understand properties
• Creates page with correct property values (Research Type, Status, Date, etc.)
• Structures content with comparison format
• Includes source citations for both Notion pages and external research

Running Evaluations Copy Chapter

1. Enable the research-documentation skill
2. Submit the query from the evaluation file
3. Verify the skill searches Notion workspace comprehensively
4. Check that multiple source pages are fetched and synthesized
5. Verify appropriate format is selected (Research Summary, Comprehensive Report, Quick Brief, Comparison)
6. Confirm citations link back to sources
7. Test with Haiku, Sonnet, and Opus

Expected Skill Behaviors Copy Chapter

Research & Documentation evaluations should verify:

Notion Search & Synthesis Copy Section

• Searches workspace with relevant queries
• Fetches multiple source pages (3-5+)
• Synthesizes information across sources
• Identifies patterns and insights
• Handles conflicting information appropriately

Format Selection Copy Section

• Chooses correct format based on scope and depth:
  • Research Summary: Quick overview with key findings
  • Comprehensive Report: Deep analysis with multiple sections
  • Quick Brief: Fast facts and takeaways
  • Comparison: Side-by-side analysis
• Applies format structure consistently
• Uses appropriate sections and headings

Citation & Attribution Copy Section

• Includes citations for all Notion sources
• Uses mention-page tags: <mention-page url="...">
• Attributes findings to specific sources
• Distinguishes between Notion content and Codex research
• Links related documents

Document Quality Copy Section

• Title clearly indicates research topic and date
• Executive summary or key findings upfront
• Organized with clear hierarchy
• Actionable insights and recommendations
• Appropriate depth for the query

Creating New Evaluations Copy Chapter

When adding Research & Documentation evaluations:

1. Test different research types - Product research, competitive analysis, technical investigation, market research
2. Vary source count - Synthesis of 2-3 pages vs. 10+ pages
3. Test format selection - Does it choose the right format for the scope?
4. Include database targets - Not just standalone pages
5. Test citation accuracy - Are all sources properly attributed?
6. Cross-workspace search - Testing search across teamspaces if applicable

Example Success Criteria Copy Chapter

Good (specific, testable):

• "Searches Notion for 'roadmap' and 'Q4' and 'product'"
• "Fetches at least 3 different source pages"
• "Includes citation for each key finding using mention-page tags"
• "Creates page with title format 'Research: [Topic] - [Date]'"
• "Uses Research Summary format with sections: Executive Summary → Key Findings → Details → Recommendations → Sources"

Bad (vague, untestable):

• "Searches Notion effectively"
• "Creates comprehensive research"
• "Uses sources appropriately"
• "Good documentation"

File: notion-spec-to-implementation/evaluations/README.md Copy Chapter

Spec to Implementation Skill Evaluations

Evaluation scenarios for testing the Spec to Implementation skill across different Codex models.

Purpose Copy Chapter

These evaluations ensure the Spec to Implementation skill:

• Finds and parses specification pages accurately
• Breaks down specs into actionable implementation plans
• Creates tasks that Codex can implement with clear acceptance criteria
• Tracks progress and updates implementation status
• Works consistently across Haiku, Sonnet, and Opus

Evaluation Files Copy Chapter

basic-spec-implementation.json Copy Section

Tests basic workflow of turning a spec into an implementation plan.

Scenario: Implement user authentication feature from spec
Key Behaviors:

• Searches for and finds the authentication spec page
• Fetches spec and extracts requirements
• Parses requirements into phases (setup, core features, polish)
• Creates implementation plan page linked to original spec
• Breaks down into clear phases with deliverables
• Includes timeline and dependencies

spec-to-tasks.json Copy Section

Tests creating concrete tasks from a specification in a task database.

Scenario: Create tasks from API redesign spec
Key Behaviors:

• Finds spec page in Notion
• Extracts specific requirements and acceptance criteria
• Searches for or creates task database
• Fetches task database schema
• Creates multiple tasks with proper properties (Status, Priority, Sprint, etc.)
• Each task has clear title, description, and acceptance criteria
• Tasks have dependencies where appropriate
• Links all tasks back to original spec

Running Evaluations Copy Chapter

1. Enable the spec-to-implementation skill
2. Submit the query from the evaluation file
3. Verify the skill finds the spec page via search
4. Check that requirements are accurately parsed
5. Confirm implementation plan is created with phases
6. Verify tasks have clear, implementable acceptance criteria
7. Check that tasks link back to spec
8. Test with Haiku, Sonnet, and Opus

Expected Skill Behaviors Copy Chapter

Spec to Implementation evaluations should verify:

Spec Discovery & Parsing Copy Section

• Searches Notion for specification pages
• Fetches complete spec content
• Extracts all requirements accurately
• Identifies technical dependencies
• Understands acceptance criteria
• Notes any ambiguities or missing details

Implementation Planning Copy Section

• Creates implementation plan page
• Breaks work into logical phases:
  • Phase 1: Foundation/Setup
  • Phase 2: Core Implementation
  • Phase 3: Testing & Polish
• Includes timeline estimates
• Identifies dependencies between phases
• Links back to original spec

Task Creation Copy Section

• Finds or identifies task database
• Fetches database schema for property names
• Creates tasks with correct properties
• Each task has:
  • Clear, specific title
  • Context and description
  • Acceptance criteria (checklist format)
  • Appropriate priority and status
  • Link to spec page
• Tasks are right-sized (not too big, not too small)
• Dependencies between tasks are noted

Progress Tracking Copy Section

• Implementation plan includes progress markers
• Tasks can be updated as work progresses
• Status updates link to completed work
• Blockers or changes are noted

Creating New Evaluations Copy Chapter

When adding Spec to Implementation evaluations:

1. Test different spec types - Features, migrations, refactors, API changes, UI components
2. Vary complexity - Simple 1-phase vs. complex multi-phase implementations
3. Test task granularity - Does it create appropriately-sized tasks?
4. Include edge cases - Vague specs, conflicting requirements, missing details
5. Test database integration - Creating tasks in existing task databases with various schemas
6. Progress tracking - Updating implementation plans as tasks complete

Example Success Criteria Copy Chapter

Good (specific, testable):

• "Searches Notion for spec page using feature name"
• "Creates implementation plan with 3 phases: Setup → Core → Polish"
• "Creates 5-8 tasks in task database with properties: Task (title), Status, Priority, Sprint"
• "Each task has acceptance criteria in checklist format (- [ ] ...)"
• "Tasks link back to spec using mention-page tag"
• "Task titles are specific and actionable (e.g., 'Create login API endpoint' not 'Authentication')"

Bad (vague, untestable):

• "Creates good implementation plan"
• "Tasks are well-structured"
• "Breaks down spec appropriately"
• "Links to spec"