Top 10 Codex Skills in 2026: Weekly Rankings and Builder Picks

Codex skills are moving fast. The August 14, 2026 weekly snapshot is already very different from earlier summer rankings, with computer use, iterative review, product imagery, domain modeling, research, and business automation all entering the Top 10.

Use that list for discovery, not blind installation. Below, we separate what is trending now from the Codex skills that make the most sense in a stable day-to-day builder workflow.

Top 10 Codex Skills Trending This Week

The supplied August 14, 2026 ranking identifies skills.sh as its data source. The graphic describes the list as a weekly popularity ranking with similar entries deduplicated, and explicitly notes that it is not an official OpenAI ranking.

The mix is more interesting than the exact order. This week's list is not dominated by generic coding helpers. It stretches from full computer control to code review loops, commercial image generation, business modeling, research, database APIs, office automation, audio production, and even animated desktop companions.

That suggests the Codex skills ecosystem is moving beyond “help me write code” toward a broader idea: package an entire repeatable workflow, then let the agent invoke it when the task appears.

1. computer-use — Move Codex Beyond the Terminal

computer-use is the most ambitious entry in this week's ranking because it changes what an agent can act on. Instead of restricting automation to files, shell commands, or APIs, a computer-use workflow can operate graphical applications and complete tasks across multiple interfaces.

That opens the door to workflows where one task crosses a browser, desktop application, file manager, internal dashboard, and other GUI software without every product exposing a clean API.

The trade-off is obvious: broader control creates a much larger permission boundary. A computer-use skill should be reviewed more carefully than a reference-only skill because it may interact with authenticated sessions, local applications, private files, or destructive interface actions.

Best for: cross-application automation, desktop testing, workflows without usable APIs, and agent experiments that need real GUI control.

Check before use: what applications it can control, whether actions require confirmation, how credentials are exposed, and whether the workflow can be isolated from sensitive desktop sessions.

2. review-loop — Turn the First Draft Into the Start of the Workflow

review-loop solves a very different problem: agents are often good at producing a first answer and much less disciplined about criticizing it.

A review-loop skill formalizes an iterative cycle:

Do the work
     |
Review the result
     |
Identify weaknesses
     |
Revise
     |
Review again
     |
Pass quality gate

This pattern is useful far beyond code. It can be applied to technical documents, implementation plans, architecture proposals, marketing copy, test suites, research summaries, and other outputs where a second pass materially improves quality.

The important distinction is that the reviewer should provide fresh criticism rather than merely confirm the original agent's reasoning. For demanding work, a separate reviewer context or subagent is usually more useful than asking the same context, “Is this good?”

Best for: code review, writing, QA, architecture, planning, and workflows where first-pass quality is not enough.

Check before use: how the quality threshold is defined and whether repeated loops have a clear stopping condition.

3. product-photography — Turn Product Images Into a Repeatable AI Workflow

product-photography shows how far the skills ecosystem is expanding beyond software development. Instead of generating an isolated image from a prompt, this type of workflow can define a reusable production process for commercial product visuals.

That is useful when a team repeatedly needs studio-style packshots, background variations, campaign images, product compositions, or concept imagery and wants the same generation logic to be reused rather than reconstructed manually every time.

For commercial use, the important questions are not only visual quality. Check the underlying image service, API costs, uploaded product assets, output licensing, brand consistency, and whether reference images leave your environment.

Best for: e-commerce teams, product launches, marketing prototypes, and repeatable AI image production.

Check before use: external generation dependencies, account permissions, usage costs, image rights, and how product assets are transmitted.

4. grill-me — Pressure-Test the Plan Before Codex Builds It

grill-me is simple in concept but valuable in practice. Instead of immediately implementing a vague idea, the agent repeatedly questions assumptions, constraints, dependencies, edge cases, and irreversible decisions until the plan becomes more defensible.

This is especially useful before expensive implementation work. A five-minute assumption discovered during planning is cheaper than a database redesign discovered after production data exists.

Good uses include:

• product requirements;
• architecture proposals;
• RFCs;
• database design;
• API contracts;
• new features;
• migration plans;
• high-impact automation.

Best for: developers and product teams that want the agent to challenge a plan before writing code.

Check before use: whether it explores available code and documentation itself instead of wasting time asking questions the repository can already answer.

5. domain-modeling — Clarify the Business Before Modeling the Software

domain-modeling targets a common source of software failure: developers and stakeholders using the same words to mean different things.

A domain workflow can help clarify business terminology, definitions, rules, boundaries, authority, ambiguous concepts, and exceptional cases before those assumptions become database schemas or public APIs.

This is particularly useful in products with concepts such as accounts, workspaces, subscriptions, organizations, ownership, permissions, orders, inventory, policies, or lifecycle states where seemingly small terminology differences can affect the entire system.

The skill should not automatically turn business concepts into technical architecture. Its highest value is often creating a stable vocabulary and identifying unresolved business rules before implementation begins.

Best for: SaaS platforms, complex business systems, migrations, API design, and teams using domain-driven design concepts.

Check before use: whether conclusions are grounded in authoritative product or business evidence rather than invented domain assumptions.

6. hyperframes-audio — Bring Mixing and Audio Automation Into Agent Workflows

hyperframes-audio represents another shift away from purely coding-oriented skills. It focuses on the relationships inside an audio mix: track gain, fades, crossfades, ducking, effects, automation, and voiceover balance.

This becomes interesting when video or audio production is already programmatic. Instead of treating sound as a final manual step, the agent can work from repeatable rules about how music, speech, effects, and other tracks should interact.

For teams creating demos, explainers, social clips, training content, or generated media at scale, the value is consistency rather than one impressive audio result.

Best for: programmatic video, generated media, automated editing, voiceover workflows, and repeatable audio post-production.

Check before use: source media rights, generated-audio dependencies, expected render environment, and whether preview and export behavior match.

7. prisma-client-api — Give Codex a Focused Prisma Reference

prisma-client-api is one of the most directly useful software-development entries in the weekly Top 10. It focuses on Prisma Client queries, filtering, relations, CRUD operations, pagination, result shaping, and transactions.

A focused reference skill can be more reliable than expecting the model to reconstruct every API detail from memory, particularly when library behavior changes across versions.

It is most useful when Codex repeatedly works in a Prisma codebase and needs to distinguish between operations such as findUnique, findMany, upsert, nested relations, transactions, filters, and result-selection patterns.

Best for: TypeScript and JavaScript applications built with Prisma.

Check before use: whether the skill matches the Prisma version used by the actual project and whether generated migrations or raw SQL receive additional review.

8. ai-research-explore — Make AI Research More Auditable

ai-research-explore is notable because the workflow is aimed at research exploration rather than simply summarizing papers.

For AI research, a useful agent should distinguish between an interesting idea and an established result. Candidate hypotheses need literature contrast, fair baselines, reproducible experiments, ablations, and evidence before they can support stronger claims.

A structured research skill can help keep those requirements visible while the agent explores possible directions.

Best for: machine-learning research, experiment planning, literature-driven exploration, and research teams that want reproducible evidence trails.

Check before use: whether source claims are traceable, whether baselines are actually comparable, and whether novelty is being treated as a hypothesis rather than a fact.

9. lark-base — Connect Codex to Structured Business Records

lark-base pushes Codex into operational workflows. Lark Base, also known as Feishu Base in Chinese environments, is used for structured records, tables, views, and business processes that often sit between spreadsheets and purpose-built databases.

An agent skill for this environment can be useful for reading and updating records, organizing structured information, and supporting operational workflows that live outside a traditional source-code repository.

This is a reminder that useful agent automation increasingly crosses software-development and business systems.

Best for: internal operations, project tracking, lightweight CRM workflows, content operations, and teams already using Lark or Feishu.

Check before use: authentication scope, table permissions, which records may be modified, and whether write operations require confirmation.

10. hatch-pet — A More Playful Side of Codex Skills

hatch-pet is the least business-critical entry in the Top 10 and one of the most revealing. It packages a workflow for creating a Codex-compatible animated pet, including the visual assets and animation structure required to turn a concept into a working desktop companion.

Its presence in a trending list matters because skills do not have to be purely utilitarian. A reusable package can encode creative pipelines, asset rules, validation, and packaging just as easily as it can encode CI debugging or database operations.

Best for: creative Codex experiments, personalized desktop experiences, demonstrations of image-generation workflows, and agent UI experiments.

Check before use: generated-image dependencies, asset packaging requirements, and any external generation services involved.

Trending Does Not Mean Best for Your Codex Setup

The weekly list is useful because it reveals what people are experimenting with right now. It is less useful as a universal installation order.

A backend developer may get far more value from Prisma and CI skills than from product photography. A design team may care more about computer use and visual-generation workflows. A research lab may put research exploration and review loops ahead of everything else.

The better question is:

Which workflow do you perform often enough that Codex should stop relearning it from scratch?

For broader discovery across different agent platforms and use cases, use the AI Agent Skill Finder before installing a large collection of overlapping skills.

Top 10 Codex Skills for a Stable Builder Workflow

The weekly Top 10 is about momentum. The following editor-recommended stack is about repeatable software-building value. It favors workflows with clear triggers, inspectable sources, focused permissions, and outcomes that developers can verify.

1. skill-creator

skill-creator helps turn a successful one-off Codex session into a reusable workflow.

That can preserve review rules, test procedures, release steps, validation logic, writing examples, or team-specific processes that otherwise need to be pasted into every new conversation.

Best for: creating custom Codex workflows.

Install first if: your team repeatedly gives Codex the same checklist or procedure.

2. gh-fix-ci

gh-fix-ci gives Codex a structured process for investigating failed GitHub checks, reviewing logs, summarizing the failure, proposing a fix, applying an approved change, and verifying the result.

Best for: GitHub Actions, failed PR checks, test failures, build errors, lint problems, and type-checking failures.

Why it matters: it encourages evidence-first debugging instead of guessing from a partial error message.

3. gh-address-comments

gh-address-comments focuses on a highly bounded development task: inspect review feedback on the current pull request and address selected comments without turning the entire branch into an uncontrolled refactor.

Best for: pull-request review cleanup and human-agent collaboration.

Install first if: Codex regularly updates branches after human review.

4. playwright-interactive

playwright-interactive gives Codex a persistent browser-testing workflow for web and Electron applications.

That matters because successful compilation does not prove that an interface actually works. An agent needs to be able to inspect states, click controls, exercise flows, and verify the visible result.

Best for: web-app QA, dashboards, Electron software, responsive testing, and UI debugging.

5. security-best-practices

security-best-practices gives Codex a separate workflow for security-focused review rather than treating security as another generic code-quality comment.

Best for: authentication, permissions, tokens, file uploads, webhook handling, public APIs, user-generated content, and backend services.

Why it matters: code can be correct in its happy path and still be unsafe.

6. sentry

sentry brings production evidence into debugging workflows.

Rather than asking Codex to speculate about an intermittent production issue, the skill can structure investigation around issue and event data before code changes are proposed.

Best for: error triage, production debugging, unresolved issue review, and incident investigation.

7. Vercel Agent Skills

Vercel Agent Skills provide focused guidance around frontend development, React, Next.js, performance, accessibility, and deployment-related workflows.

Best for: SaaS frontends, Next.js applications, dashboards, marketing sites, and Vercel deployments.

Why it matters: generated frontend code may render correctly while still creating waterfalls, oversized bundles, accessibility failures, or inefficient rendering behavior.

8. Supabase Agent Skills

Supabase Agent Skills focus on Postgres, authentication, row-level security, migrations, storage, vectors, functions, and related backend workflows.

Best for: Supabase applications, SaaS backends, RLS policies, migrations, indexes, and database architecture.

Why it matters: permissions and schema assumptions are two areas where plausible AI-generated backend code can create serious problems.

9. Cloudflare Skills

Cloudflare Skills cover platform-specific development across Workers, Pages, Durable Objects, R2, D1, KV, Vectorize, Wrangler, and other Cloudflare services.

Best for: edge applications, APIs, agents, Cloudflare storage, and deployment workflows.

Why it matters: platform-aware instructions reduce the chance that Codex generates generic server code that ignores the environment in which it will actually run.

10. n8n Official Skills

n8n skills help with workflow structure, expressions, pagination, loops, sub-workflows, AI-agent nodes, error paths, and automation debugging.

Best for: self-hosted automation, internal operations, AI pipelines, and n8n troubleshooting.

Why it matters: automation failures frequently come from data shape, credentials, expressions, pagination, or missing error branches rather than the headline business logic.

Trending Skill or Stable Skill: Which Should You Install First?

Codex Skills vs Plugins vs AGENTS.md

These three mechanisms overlap, but they solve different problems.

Use a Skill for a Reusable Workflow

A skill packages procedural knowledge around a repeatable task. It normally includes a SKILL.md file and can also include references, assets, scripts, and supporting resources.

The official Codex skills documentation explains how skills extend Codex with specialized workflows and domain knowledge.

Use AGENTS.md for Repository Rules

AGENTS.md is better suited to instructions that should remain attached to a repository: project structure, required commands, coding conventions, testing expectations, architecture notes, or branch rules.

For example, AGENTS.md may say:

Run npm test before completing a change.
Do not modify generated schema files manually.
Use the existing service abstraction for API calls.

A skill can then define a complete reusable workflow for investigating a failed CI run or conducting a security review across many repositories.

Use a Plugin When the Package Needs More Than Skills

A plugin makes more sense when a distributed package also needs commands, integrations, tools, configuration, apps, or other resources alongside one or more skills.

The simplest rule is:

Repository-specific rules  -> AGENTS.md
Reusable workflow          -> Skill
Broader installable bundle -> Plugin

How to Audit a Codex Skill Before Installing It

The larger the skills ecosystem becomes, the more important this section becomes. A skill is executable workflow context, not just a clever prompt copied from the internet.

1. Confirm the Actual Source

Prefer OpenAI-curated skills, official vendor repositories, or community repositories with identifiable maintainers and visible development history.

A familiar skill name is not proof of ownership. Multiple repositories can publish workflows under similar names.

2. Read SKILL.md Before You Run Anything

Look for:

• when the skill activates;
• what tools it expects;
• what files it reads;
• what files it can modify;
• what network services it contacts;
• which scripts it executes;
• what credentials it requires;
• how success is verified.

3. Inspect Bundled Scripts

A short, harmless-looking SKILL.md can invoke a much more powerful script.

Review shell commands, package installs, network requests, destructive file operations, environment-variable handling, generated code, and authentication flows before running a third-party skill against valuable data.

4. Match Permissions to the Job

The requested authority should make sense for the workflow.

A Prisma reference skill should not need control of your desktop. A design workflow should not require production database credentials. A browser automation skill should not inherit authenticated sessions unless the requested task genuinely requires them.

5. Check External Costs and Services

Skills for AI video, product photography, music, research tools, or other hosted services may trigger API usage and paid generation.

Know which service is being called and who pays before turning a repeatable workflow into repeatable spending.

6. Avoid Installing Everything

More skills do not automatically make Codex better.

Overlapping skill descriptions can create selection noise, make auditing harder, and leave developers unsure which workflow the agent actually followed.

Start with three to five skills tied to work you genuinely repeat. Add another only when a real recurring workflow justifies it.

7. Test New Skills Away From Production

Use a disposable repository, sample records, non-production credentials, or isolated browser session when testing unfamiliar community skills.

This is particularly important for entries such as computer-use, browser workflows, database operations, and business-platform integrations because they can act on systems outside the source-code sandbox.

What the August Ranking Says About Codex Skills in 2026

The most interesting signal in the uploaded ranking is not that computer-use happened to be number one.

It is that the Top 10 now covers almost the entire path from thinking to execution:

Challenge the idea
        |
Model the domain
        |
Research the problem
        |
Write and query software
        |
Review the result
        |
Operate applications
        |
Create media
        |
Update business systems
        |
Package the output

That is a much broader role than “coding assistant.”

Skills are gradually turning Codex into a workflow platform where specialized procedures can be discovered, installed, audited, and reused without placing every rule into one giant prompt.

For users building private agent workflows around their own files and datasets, the same pattern can be combined with local storage. The ZimaCube 2 Personal Cloud NAS can act as a self-hosted storage layer while skills define how agents process, review, organize, or automate those assets.

Final Takeaway

The August 14 snapshot is useful because it shows what builders are exploring now: computer control, iterative review, AI product imagery, plan interrogation, domain modeling, audio automation, Prisma development, AI research, Lark operations, and personalized Codex experiences.

But a trending list should be treated as a discovery feed, not an installation queue.

For a stable Codex setup, start with the workflows you already repeat. Add skill-creator when you need to preserve your own process, gh-fix-ci and gh-address-comments for GitHub work, playwright-interactive for browser verification, and specialized vendor skills only when they match the technologies your project actually uses.

Then use weekly rankings to find new capabilities worth testing.

The best Codex skill is not necessarily the one at number one this week. It is the smallest, clearest, most auditable workflow that saves you from solving the same problem manually again next week.

FAQ

What are the Top 10 trending Codex skills in the August 14, 2026 snapshot?

The supplied ranking lists computer-use, review-loop, product-photography, grill-me, domain-modeling, hyperframes-audio, prisma-client-api, ai-research-explore, lark-base, and hatch-pet. The image identifies skills.sh Trending as the underlying data source and notes that the ranking is not an official OpenAI list.

Is computer-use an official OpenAI Codex skill?

The weekly graphic should not be interpreted as an OpenAI-maintained leaderboard. Trending skills can come from OpenAI, vendors, or community repositories, so ownership and source should be checked individually before installation.

Does the number-one trending skill mean it is the best Codex skill?

No. A weekly ranking reflects short-term interest or activity. It does not prove that the skill is the safest, most maintained, or most useful option for your particular repository and workflow.

What is the most useful Codex skill for developers?

There is no universal answer. gh-fix-ci is useful for recurring GitHub CI failures, playwright-interactive for web applications, security-best-practices for sensitive backend work, and skill-creator for turning your own repeated process into a reusable workflow.

What does review-loop do?

review-loop formalizes an iterative work, critique, revision, and re-review cycle. It is useful when one-pass output is not good enough and a fresh reviewer or subagent can identify weaknesses before the result is accepted.

What is the difference between a Codex skill and AGENTS.md?

AGENTS.md is better for durable instructions attached to one repository. A skill packages a reusable workflow that can be triggered across projects and may include scripts, references, assets, and other supporting resources.

Can Codex skills execute scripts?

Yes. Skills can package supporting scripts and resources. That can make workflows more reliable, but it also means third-party skills should be reviewed for file access, shell commands, network requests, credentials, dependencies, and destructive operations.

Are trending Codex skills safe to install?

Not automatically. Review the source repository, maintainer, SKILL.md, bundled scripts, external services, permissions, installation commands, and recent activity before giving a skill access to private repositories or authenticated systems.

How many Codex skills should I install?

Start with a small set tied to workflows you actually repeat. Three to five focused skills are usually easier to audit and understand than a large collection with overlapping triggers.

Where can I discover more Codex and AI agent skills?

You can browse the live skills.sh directory for community activity, and use the ZimaSpace AI Agent Skill Finder to narrow skills by platform and use case before testing them.