A skill your agent uses whenever a design has many options the user must choose among — menus, navigation, pickers, plan tiers, settings panels, action toolbars, lists of templates, anything that…

Apache-2.0Auto-check passed

Install Hicks Law

skills CLI
$ npx skills add hashgraph-online/awesome-codex-plugins --skill hicks-law -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install hashgraph-online/awesome-codex-plugins hicks-law --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/hashgraph-online/awesome-codex-plugins.git skills-src && mkdir -p .claude/skills && cp -r skills-src/plugins/HDeibler/universal-design-principles/plugins/cognition-and-learnability-principles/skills/hicks-law .claude/skills/hicks-law && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
hicks-law
GitHub stars
1.3k
Token cost
~3.4k tokens
SKILL.md length
1,578 words
Files
2 (incl. references)
Skills in repo
716
Repo updated
First seen
Licence
Apache-2.0

At a glance

A skill your agent uses whenever a design has many options the user must choose among — menus, navigation, pickers, plan tiers, settings panels, action toolbars, lists of templates, anything that…

  • Works in 6 steps: Reduce the count → Group the options → Provide a strong default → …
  • A design has many options the user must choose among — menus
  • SKILL.md covers Definition (in our own words), Origins and research lineage, Why Hick's Law matters and When to apply, plus 7 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Hicks Law is an agent skill from hashgraph-online/awesome-codex-plugins. Use this skill whenever a design has many options the user must choose among — menus, navigation, pickers, plan tiers, settings panels, action toolbars, lists of templates, anything that asks "which one?" Trigger when the user is laying out a navigation menu, designing a settings page, picking the structure of a wizard, building a country/timezone/currency picker, designing a pricing table, or reviewing a UI where users hesitate over which control to use. Trigger when there's debate about "should we add another…

Its SKILL.md is about 3.4k tokens, which your agent loads only when the skill is triggered. The skill folder holds 2 other files, including reference files (for example `references/research-and-formulation.md`).

The repository describes itself as: A curated list of awesome OpenAI Codex / ChatGPT plugins, skills, and resources. The 1 Codex Marketplace. See live plugins at: https://hol.org/plugins/best-codex-plugins. The licence is Apache-2.0.

When your agent uses it

  • A design has many options the user must choose among — menus
  • Settings panels
  • Action toolbars
  • Lists of templates

Example prompts

  • “which one?”
  • “s debate about”
  • “— Hick”
  • “/hicks-law”

Workflow steps

6 steps, taken from the step headings in SKILL.md.

  1. Reduce the count
  2. Group the options
  3. Provide a strong default
  4. Switch interaction mode for very large sets
  5. Defer choices to the right moment
  6. Predict and rank

What it can do on your machine

Read from SKILL.md and the folder at commit 3e1456a. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are html).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Hicks Law loads about 3.4k tokens when it runs, and up to ~4.7k if it reads all its reference files. Until then it costs about 165 tokens; SKILL.md has 1,578 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~165
When it runs · the whole SKILL.md, loaded when a task matches
~3.4k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~4.7k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from hashgraph-online/awesome-codex-plugins at commit 3e1456a, republished under its Apache-2.0 licence (© hashgraph-online). 1,578 words, ~3,406 tokens.

Download SKILL.mdSave it as .claude/skills/hicks-law/SKILL.md (or your agent's skills folder). This skill also uses 1 other file; get the full folder from GitHub.
name
hicks-law
description
Use this skill whenever a design has many options the user must choose among — menus, navigation, pickers, plan tiers, settings panels, action toolbars, lists of templates, anything that asks "which one?" Trigger when the user is laying out a navigation menu, designing a settings page, picking the structure of a wizard, building a country/timezone/currency picker, designing a pricing table, or reviewing a UI where users hesitate over which control to use. Trigger when there's debate about "should we add another option?" — Hick's Law is the principle that costs the option a price. Routes to sub-aspect skills for menus, defaults, and pricing.

Hick's Law

Hick's Law (more precisely, the Hick-Hyman Law) is the empirical observation that the time required to make a decision among a set of options grows with the logarithm of the number of options. Stated as a formula:

T = b · log₂(n + 1)

Where T is decision time, n is the number of equally likely choices, and b is a constant determined by the cognitive context. The +1 accounts for the time to begin processing the choice set at all. The logarithmic growth is the design-relevant insight: doubling the number of options does not double decision time, but it does add a roughly constant increment each time.

Definition (in our own words)

When a user must select one option from a set, the time and cognitive effort required to make that selection rise as the set grows — but not linearly. The user can scan and pick from a small set quickly; they need progressively more time as the set grows; and beyond a certain size (typically around 7–10 options for a flat list) they switch from scanning to searching, which is a different and slower mode.

Origins and research lineage

  • Hick (1952) measured reaction time as a function of the number of stimulus alternatives in a simple keypress task. He found a logarithmic relationship.
  • Hyman (1953) extended this with similar results across varied stimulus types, confirming the general law.
  • Card, Moran & Newell (1983) in The Psychology of Human-Computer Interaction incorporated Hick's Law into the early model human processor framework that grounded decades of HCI design.
  • Modern critiques (e.g., Seow 2005) note that Hick's Law strictly applies to highly practiced, equally-likely choices among visually distinguishable items. Real-world UI choices often violate these conditions — items aren't equally likely, users aren't fully practiced, items have semantic content the user must read. The law is a guide, not a measurement.

The takeaway: more options is more decision cost, the cost grows sub-linearly, and beyond about 7 options the dominant cost shifts from "scan and pick" to "search the list."

Why Hick's Law matters

In product design, every option you put in front of the user is paid for in two currencies: decision time (the user must consider it) and decision fatigue (the user has fewer mental resources for the next decision). On a single screen, the cost of one extra option is small. Across a workflow with many decision points, the costs compound.

Designs that respect Hick's Law feel "easy" — users move through them without stalling. Designs that ignore it feel "complicated" — users hover, deliberate, and sometimes abandon.

When to apply

  • Navigation IA. Top-level navigation should typically be 5–7 items. Beyond that, the user can't hold the structure in working memory while scanning.
  • Action toolbars. A toolbar with 12 buttons asks a Hick's Law question on every glance. Cap visible actions; tuck the rest into menus or palettes.
  • Pickers. Country / timezone / currency / template pickers can have hundreds of items. Don't make the user choose from a flat list of 195 countries — switch to a different interaction (search, recents).
  • Wizards. Multi-step flows with many branches at each step compound the law: 4 choices × 4 choices × 4 choices = 64 paths to consider, even if the user only walks one.
  • Settings. A settings page with 30 toggles asks the user to evaluate 30 options. Group, default, and progressively disclose.

When NOT to apply (or when to misapply it)

Hick's Law is sometimes invoked to justify removing options that users actually need. Beware of these failure modes:

  • The "fewer-is-always-better" trap. Some tasks have irreducible complexity — a tax form genuinely has 50 fields. Hick's Law doesn't say "remove fields"; it says "structure the choices so the user faces fewer at once."
  • Assuming Hick's Law applies to text input. Free-text input isn't choosing from a set; it's recall. Hick's Law doesn't apply directly. (Recognition over Recall does — see that principle.)
  • Assuming all options are equally weighted. When one option dominates probability (e.g., 80% of users want "Pro" plan), the cost is closer to "scan for the obvious one and click" than to a pure Hick's Law decision. Strong defaults change the equation.
  • In expert contexts. Practiced users on familiar tools can navigate large option sets quickly via spatial memory and shortcuts. A power-user IDE can have 200 menu items because experts don't scan them; they fly to known locations.

Strategies for reducing Hick's Law cost

1. Reduce the count

The most direct strategy. Audit the option set: which options are rarely used? Hide them behind "More" / "Advanced" / a command palette. The remaining set should be small enough to scan at a glance.

The 80/20 rule pairs naturally with Hick's Law here: surface the 20% of options that handle 80% of cases; tuck the rest.

2. Group the options

A flat list of 30 items is hard. Three groups of 10 items, each with a heading, is much easier — the user makes a fast group choice (Hick's Law on 3), then a slower within-group choice (Hick's Law on 10).

Flat (Hick's cost: log₂(31) ≈ 4.95)
  Item 1 … Item 30

Grouped (Hick's cost: log₂(4) + log₂(11) ≈ 2 + 3.46 = 5.46)
  Group A
    Item 1 … Item 10
  Group B
    Item 11 … Item 20
  Group C
    Item 21 … Item 30

The arithmetic suggests grouping is worse by raw Hick's Law math. It isn't, in practice, because:

  • The user often only needs items in one group (cognitive load is on log₂(4) + log₂(11), not their sum).
  • Group headings make the structure recognizable and learnable — repeat visits are faster.
  • Visual chunking aids working memory.

The math underestimates how badly humans handle long flat lists.

3. Provide a strong default

If you can pre-select the most likely option, you've cut the choice from N to "1 (the default) or N−1 (everything else)." Most users accept the default, so most users pay almost no decision cost.

This is the single highest-leverage Hick's Law strategy: a good default eliminates the decision for most users.

Show full SKILL.md (636 more words)Show less
4. Switch interaction mode for very large sets

Beyond ~10 options, scanning becomes search. The right interaction is no longer a <select> or radio group — it's a typeahead combobox or a command palette where the user types to filter. Filter-as-you-type collapses Hick's Law into the much faster Recognition-over-Recall.

≤ 5 options:  radio buttons or segmented control (all visible, instant pick)
≤ 10 options: select dropdown
≤ ~20 options: select with categories
> 20 options: combobox / typeahead / command palette
5. Defer choices to the right moment

A common Hick's Law mistake: presenting many options up-front when the user hasn't yet supplied the context that would narrow them. Defer.

  • A "Send a notification" form that asks "channel? (email/SMS/push/Slack/Teams) frequency? (instant/digest/weekly) audience? (everyone/admins/me)" before the user even has a draft — high Hick's cost. Better: let the user write the message first, then pick channel.
6. Predict and rank

If you can predict which options the user is likely to want (from their history, role, recency), put those at the top with a "Recent" or "Suggested" group. The user often finds their option without scanning the full list.

Worked examples

Example 1: country picker
html
<!-- Anti-pattern: 195 countries in a flat select -->
<select>
  <option>Afghanistan</option>
  <option>Albania</option>
  …
  <option>Zimbabwe</option>
</select>

Decision cost is high (effectively a search, not a scan). Plus, the dropdown UI doesn't allow type-to-find effectively.

html
<!-- Right: combobox with typeahead, plus recents -->
<combobox>
  <input placeholder="Search country" />
  <listbox>
    <group label="Recent">
      <option>United States</option>
      <option>Canada</option>
    </group>
    <group label="All countries">
      <option>Afghanistan</option>
      …
    </group>
  </listbox>
</combobox>

The user types "ger," sees Germany, picks it. Hick's Law collapsed to recognition.

Example 2: navigation
html
<!-- Anti-pattern: 14 top-nav items -->
<nav>
  <a>Home</a><a>Dashboard</a><a>Projects</a><a>Tasks</a><a>Reports</a>
  <a>Calendar</a><a>Files</a><a>Inbox</a><a>Notifications</a><a>Team</a>
  <a>Customers</a><a>Vendors</a><a>Settings</a><a>Help</a>
</nav>

User can't decide where to start; eyes sweep, fatigue.

html
<!-- Right: 5 top-level groups, with sub-nav under each -->
<nav>
  <a>Work</a>           <!-- Dashboard, Tasks, Calendar, Files -->
  <a>Inbox</a>          <!-- Notifications, Messages -->
  <a>People</a>         <!-- Team, Customers, Vendors -->
  <a>Reports</a>
  <a>Settings</a>
</nav>

Five groups; user picks one in <1 second; sub-nav resolves the within-group choice.

Example 3: settings
html
<!-- Anti-pattern: 30 toggles in a flat list -->
<form>
  <label><input type="checkbox" /> Send daily summary email</label>
  <label><input type="checkbox" /> Send weekly summary email</label>
  <label><input type="checkbox" /> Notify on mention in any channel</label>
  …(27 more)
</form>

The user is asked to evaluate 30 boolean choices, most of which they don't care about.

html
<!-- Right: grouped, with strong defaults pre-selected -->
<form>
  <fieldset>
    <legend>Email digest</legend>
    <label><input type="radio" name="digest" value="off" /> Off</label>
    <label><input type="radio" name="digest" value="daily" checked /> Daily (recommended)</label>
    <label><input type="radio" name="digest" value="weekly" /> Weekly</label>
  </fieldset>

  <fieldset>
    <legend>Push notifications</legend>
    <label><input type="radio" name="push" value="off" /> Off</label>
    <label><input type="radio" name="push" value="mentions" checked /> Mentions only (recommended)</label>
    <label><input type="radio" name="push" value="all" /> All activity</label>
  </fieldset>

  <details>
    <summary>Advanced (Slack, calendar, custom rules)</summary>
    …(advanced settings, hidden by default)…
  </details>
</form>

Now the user faces 3 + 3 = 6 visible choices, both with sensible defaults. Most users accept the defaults. Power users open the disclosure.

Example 4: a wizard

A 4-step wizard with 4 choices at each step has 256 logical paths. The user sees only 4 at a time, so per-step cost is manageable. But cumulative decision fatigue can be high.

Mitigations:

  • Show progress (Stepper) so the user knows the end is in sight.
  • Default each step's choice based on prior steps when possible.
  • Allow "I'll come back to this" with a save-and-resume.

Anti-patterns

  • The "kitchen-sink" toolbar. All possible actions visible at once. Users freeze; the toolbar becomes wallpaper.
  • The "expert mode by default" trap. A new user is shown the same option-rich interface as a power user. They bounce.
  • Hidden costs in disclosure. Putting 20 options inside a "More" disclosure doesn't reduce Hick's Law cost; it just makes the user pay it after a click. Sometimes correct (advanced rarely-used settings), sometimes a procrastination of the real fix.
  • Asking before you have to. A configuration step at sign-up that asks 8 questions before the user has used the product. Defer until the user has context to answer.

Heuristics

  1. The 7-second test. Time how long it takes a fresh user to pick the right item from your list. >7 seconds suggests Hick's Law cost is too high; restructure.
  2. The Pareto check. Look at usage analytics. If 80% of usage is concentrated in 20% of options, surface that 20%; demote the rest.
  3. The "default-acceptance" rate. Pick a setting where you have a default. What percent of users keep the default? If high, the default is doing its Hick's Law work. If low, your default is wrong (or the question shouldn't have a default).
  • 80-20-rule — partner principle; identifies which options to surface and which to demote.
  • recognition-over-recall — the cognitive shift that lets typeahead collapse Hick's Law for very large sets.
  • progressive-disclosure — the structural strategy for hiding the long tail.
  • chunking — the perceptual basis for why grouped options outperform flat ones.
  • satisficing — users pick the first acceptable option; defaults exploit this.
  • flexibility-usability-tradeoff (interaction) — adding options gives flexibility and costs usability; Hick's Law quantifies the cost.

Sub-aspect skills

  • hicks-law-menus — applying the law to dropdowns, command palettes, navigation menus.
  • hicks-law-defaults — using defaults as the primary Hick's Law mitigation.
  • hicks-law-pricing — applying the law to plan/tier selection where the choice itself is the conversion event.

© hashgraph-online, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 1 other file (references) in plugins/HDeibler/universal-design-principles/plugins/cognition-and-learnability-principles/skills/hicks-law of hashgraph-online/awesome-codex-plugins.

  • SKILL.md
  • references/research-and-formulation.md

Open the folder on GitHubat commit 3e1456a

Compare with similar skills

Hicks Law next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Hicks Law compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Hicks Law this skillhashgraph-online/awesome-codex-plugins1.3k—~3.4kAutomated safety check: PassApache-2.0
Hicks LawOwl-Listener/designer-skills2.9k1 repos~665Automated safety check: PassMIT
Optionsasgeirtj/system_prompts_leaks69k—~918Automated safety check: PassCC0-1.0
Options Strategy BacktestingHKUDS/Vibe-Trading35k—~2kAutomated safety check: PassMIT
Remove Option Or Flaggetsentry/sentry46k—~3kAutomated safety check: PassCustom licence
Options PayoffHKUDS/Vibe-Trading35k—~6.8kAutomated safety check: PassMIT

Similar skills

  • Hicks Law

    Owl-Listener/designer-skills

    Apply Hick's Law — decision time grows with the number of simultaneous choices.

    2.9k GitHub starsUsed in 1 repo~665 tokens
    Auto-check passed
  • Options

    asgeirtj/system_prompts_leaks

    Present multiple design options as a vertical stack of anchored turns

    69k GitHub stars~918 tokensUpdated today
    Auto-check passed
  • Backtests multi-leg option strategies by synthesizing Black-Scholes prices from the underlying, simulating PnL, Greeks exposure and expiration for crypto and equity options.

    35k GitHub stars~2k tokensUpdated today
    Business, Finance & HRAuto-check passed
  • Remove Option Or Flag

    getsentry/sentry

    Official

    Remove a Sentry option or FlagPole feature flag whose rollout is finished, in the correct PR order across sentry, getsentry, and sentry-options-automator.

    46k GitHub stars~3k tokensUpdated today
    Auto-check passed
  • Options Payoff

    HKUDS/Vibe-Trading

    Option P&L analysis methodology: payoff diagrams, breakeven calculation, multi-leg strategy visualization, and Greeks-based scenario analysis.

    35k GitHub stars~6.8k tokensUpdated today
    Business, Finance & HRAuto-check passed
  • Add CLI Option

    remotion-dev/remotion

    Official

    Add a new Remotion CLI or config option by creating an AnyRemotionOption, registering CLI parsing, wiring config setters, and updating documentation.

    63k GitHub stars~1.5k tokensUpdated today
    Media & CreativeAuto-check passed

More from hashgraph-online/awesome-codex-plugins

All 716 skills in this repo
  • Anime Reaction Gif

    hashgraph-online/awesome-codex-plugins

    Create original anime-style reaction stickers as looping GIFs and MP4 previews, using generated character pose sheets and timed key poses.

    1.3k GitHub stars~922 tokensUpdated today
    Auto-check passed
  • Calibredb

    hashgraph-online/awesome-codex-plugins

    Manage and query Calibre libraries with the calibredb CLI (local paths or Calibre Content server URLs).

    1.3k GitHub stars~1k tokensUpdated today
    Auto-check passed
  • Rust API Test Harness

    hashgraph-online/awesome-codex-plugins

    A skill your agent uses when adding, changing, testing, or debugging Rust HTTP APIs and services, especially when Codex needs black-box integration tests, random-port app startup, real database test…

    1.3k GitHub stars~1.7k tokensUpdated today
    Auto-check passed
  • Art

    hashgraph-online/awesome-codex-plugins

    Make a studio's game look like something at build time — a cover from a real frame of the game (free), painted covers, backdrops, textures and character plates from image models through the…

    1.3k GitHub stars~2.4k tokensUpdated today
    Auto-check passed
  • Calle

    hashgraph-online/awesome-codex-plugins

    Use CALL-E from Codex through the calle CLI. An agent skill from hashgraph-online/awesome-codex-plugins.

    1.3k GitHub stars~2.9k tokensUpdated today
    Auto-check passed
  • Game Balance Economy

    hashgraph-online/awesome-codex-plugins

    Balance game difficulty, resources, rewards, probability, progression, economies, and dominant strategies.

    1.3k GitHub stars~618 tokensUpdated today
    Auto-check passed

Questions about Hicks Law

What does Hicks Law do?

A skill your agent uses whenever a design has many options the user must choose among — menus, navigation, pickers, plan tiers, settings panels, action toolbars, lists of templates, anything that…. Hicks Law is an agent skill from hashgraph-online/awesome-codex-plugins." Trigger when the user is laying out a navigation menu, designing a settings page, picking the structure of a wizard, building a country/timezone/currency picker, designing a pricing table, or reviewing a UI where users hesitate over which control to use.

When should I use Hicks Law?

Hicks Law fits situations like: A design has many options the user must choose among — menus; settings panels; action toolbars; lists of templates.

How do I install Hicks Law in Claude Code?

Run `npx skills add hashgraph-online/awesome-codex-plugins --skill hicks-law -a claude-code`. Or copy the skill folder (plugins/HDeibler/universal-design-principles/plugins/cognition-and-learnability-principles/skills/hicks-law in hashgraph-online/awesome-codex-plugins) into .claude/skills/hicks-law in your project. Claude Code loads it when a task matches its description.

How do I install Hicks Law in Codex?

Run `npx skills add hashgraph-online/awesome-codex-plugins --skill hicks-law -a codex`. Or copy the skill folder (plugins/HDeibler/universal-design-principles/plugins/cognition-and-learnability-principles/skills/hicks-law in hashgraph-online/awesome-codex-plugins) into .agents/skills/hicks-law in your project. Codex loads it when a task matches its description.

Can I use Hicks Law in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add hashgraph-online/awesome-codex-plugins --skill hicks-law -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/hicks-law, .gemini/skills/hicks-law, .github/skills/hicks-law and .opencode/skills/hicks-law in your project.

What does Hicks Law need to run?

SKILL.md names no scripts, command-line tools or credentials: Hicks Law is instructions for the agent only.

Does Hicks Law access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Hicks Law safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Hicks Law use?

Hicks Law is published under the Apache-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Hicks Law use?

About 3.4k tokens (SKILL.md is roughly 14k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 1.3k tokens, read only when the agent opens those files.

What are the alternatives to Hicks Law?

Skills that share tags, products or a category with Hicks Law: Hicks Law (Owl-Listener/designer-skills, 2.9k stars), Options (asgeirtj/system_prompts_leaks, 69k stars), Options Strategy Backtesting (HKUDS/Vibe-Trading, 35k stars) and Remove Option Or Flag (getsentry/sentry, 46k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Hicks Law?

hashgraph-online (a GitHub organization) maintains it in hashgraph-online/awesome-codex-plugins, which has 1,267 GitHub stars. The repository holds 716 skills in this directory. The repository was last updated on October 10, 2026.

Source: hashgraph-online/awesome-codex-plugins on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.