A skill your agent uses whenever a user must navigate within a non-trivial space — a multi-page web app, a documentation site, a hierarchical settings panel, a conference site, a multi-step flow, a…

Apache-2.0Auto-check passedFrontend & Design

Install Wayfinding

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

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

GitHub CLI
$ gh skill install hashgraph-online/awesome-codex-plugins wayfinding --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/wayfinding .claude/skills/wayfinding && 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
wayfinding
GitHub stars
1.2k
Token cost
~4.2k tokens
SKILL.md length
2,162 words
Files
2 (incl. references)
Skills in repo
686
Repo updated
First seen
Licence
Apache-2.0

At a glance

A skill your agent uses whenever a user must navigate within a non-trivial space — a multi-page web app, a documentation site, a hierarchical settings panel, a conference site, a multi-step flow, a…

  • Works in 4 steps: Orientation → Route decision → Route monitoring → …
  • A user must navigate within a non-trivial space — a multi-page web app
  • SKILL.md covers Definition (in our own words), Origins and research lineage, The four stages and When to apply, plus 8 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Wayfinding is an agent skill from hashgraph-online/awesome-codex-plugins. Use this skill whenever a user must navigate within a non-trivial space — a multi-page web app, a documentation site, a hierarchical settings panel, a conference site, a multi-step flow, a campus, a building, an app with deep IA. Trigger when the user asks how navigation should be structured, when users get lost, when "I can't find X" complaints recur, when designing breadcrumbs, sitemaps, search, or recovery flows. Wayfinding is one of the foundational principles in 'Universal Principles of Design' (Lidwell…

Its SKILL.md is about 4.2k 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-cross-domain.md`).

It sits in Frontend & Design, covering Static sites and blogs and Technical SEO. 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 user must navigate within a non-trivial space — a multi-page web app
  • A documentation site
  • A hierarchical settings panel
  • A conference site

Example prompts

  • “t find X”
  • “Universal Principles of Design”
  • “/wayfinding”

Workflow steps

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

  1. Orientation
  2. Route decision
  3. Route monitoring
  4. Destination recognition

What it can do on your machine

Read from SKILL.md and the folder at commit 78497e5. 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

Wayfinding loads about 4.2k tokens when it runs, and up to ~6.7k if it reads all its reference files. Until then it costs about 181 tokens; SKILL.md has 2,162 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~181
When it runs · the whole SKILL.md, loaded when a task matches
~4.2k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~6.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 78497e5, republished under its Apache-2.0 licence (© hashgraph-online). 2,162 words, ~4,217 tokens.

Download SKILL.mdSave it as .claude/skills/wayfinding/SKILL.md (or your agent's skills folder). This skill also uses 1 other file; get the full folder from GitHub.
name
wayfinding
description
Use this skill whenever a user must navigate within a non-trivial space — a multi-page web app, a documentation site, a hierarchical settings panel, a conference site, a multi-step flow, a campus, a building, an app with deep IA. Trigger when the user asks how navigation should be structured, when users get lost, when "I can't find X" complaints recur, when designing breadcrumbs, sitemaps, search, or recovery flows. Wayfinding is one of the foundational principles in 'Universal Principles of Design' (Lidwell, Holden, Butler 2003); it's also the only principle from that source not previously covered by these plugins. Routes to sub-aspect skills for spatial metaphors, search-and-recovery, and breadcrumbs.

Wayfinding

Wayfinding is the process by which people use spatial and environmental information to orient themselves, choose a path, monitor their progress along it, and recognize when they've arrived. It originated as an architectural and urban-design concept — how people find their way through buildings, campuses, cities — and translates almost directly to information architecture and navigation design in software.

Definition (in our own words)

Whenever a user must move from where they are now to where they want to be — across rooms in a building, across pages in a web app, across screens in a multi-step flow — they perform a sequence of cognitive operations: figuring out where they are, deciding which way to go, checking that they're still on the right path, and recognizing the destination when it appears. Designs that make any of these four operations harder than necessary produce the universal symptom: users get lost, double back, give up, or call support.

Origins and research lineage

  • Kevin Lynch, The Image of the City (MIT Press, 1960). The foundational text. Lynch interviewed residents of Boston, Jersey City, and Los Angeles about how they navigated their cities, and identified five elements of the cognitive map: paths, edges, districts, nodes, and landmarks. These five categories still organize the field.
  • Romedi Passini, Wayfinding in Architecture (1984) and Wayfinding: People, Signs, and Architecture (with Paul Arthur, 1992). Translated Lynch's urban concepts into architectural design, particularly for hospitals, airports, and other complex public buildings where wayfinding failure is consequential.
  • Roger Downs and David Stea, Cognitive Maps and Spatial Behavior (1973), and the broader cognitive-mapping research tradition in environmental psychology.
  • Lidwell, Holden & Butler, Universal Principles of Design (2003), articulated the four-stage model (orientation, route decision, route monitoring, destination recognition) that is the most-cited contemporary summary in design education.
  • Web wayfinding translates the same framework. Steve Krug's Don't Make Me Think (2000) is the most-cited application to web design; the "where am I, where can I go, what's here" trio of questions is wayfinding restated for screens.

The four stages

A useful structure adapted from the design-research literature:

1. Orientation

Where am I right now? What's around me? Where is my destination relative to here?

In a building: signs, landmarks (the central atrium, the colored carpet, the unique sculpture), maps at decision points.

In an app: the page title, the breadcrumb, the highlighted nav item, the URL, the visible chrome that anchors the user in the system's structure.

A user with poor orientation feels "lost in the app" — even if they could reach their destination by clicking forward, they don't know where they currently are or how the current page relates to the rest.

2. Route decision

Given where I am and where I'm going, which path do I take?

In a building: signage at each junction, with the destination clearly named and an unambiguous direction.

In an app: navigation that lists destinations clearly, with link text matching the destination's name. Search as the universal "I don't know which path; just take me there" recovery.

A user with poor route-decision support faces too many choices, ambiguous labels, or paths that look equivalent. They guess; they're often wrong.

3. Route monitoring

Am I still on the right path? Is the destination getting closer or farther?

In a building: continued signage along the path, intermediate landmarks, paths that have clear "this leads somewhere" character (a long hallway with the destination at the end, not a series of identical turns).

In an app: visible progress indicators (steppers, breadcrumbs that fill in as you go), a stable URL pattern that reflects depth, transitions that show the user moving "into" rather than "across."

A user with poor route monitoring takes a step, looks up, doesn't recognize where they are anymore, and either retreats or guesses again.

4. Destination recognition

Have I arrived?

In a building: the destination has a clear identity — a marked door, a desk, a sign. Dead-ends or terminals reinforce arrival ("you have reached the end of the path; this must be it").

In an app: a clear page title, a layout that matches the user's mental image of the destination, no ambiguity about whether this is the right page or a stop-along-the-way.

A user with poor destination recognition arrives at the right page and doesn't realize it. They scroll, check again, click somewhere else.

When to apply

  • Designing or auditing IA. Wayfinding is the IA discipline applied at the user's eye level.
  • Designing onboarding flows or wizards. Multi-step flows are explicit wayfinding exercises.
  • Documentation sites. Doc users routinely report "I know it's in here somewhere" — a wayfinding failure.
  • Settings panels with depth. Whenever users must drill into a sub-section to change a value, all four stages apply.
  • Help / support surfaces. Users land here in a degraded wayfinding state already; design must repair their orientation before doing anything else.

When NOT to apply (or when to be careful)

  • Single-page tools. A calculator, a simple form, a one-screen dashboard doesn't have wayfinding to design.
  • When the IA itself is wrong. Wayfinding is about helping users navigate the IA you have. If the underlying IA is incoherent (the user expects "Settings → Notifications" and you've put notifications under "Account → Preferences → Communications"), no amount of wayfinding cosmetics will fix it. Restructure first.
  • In voice-only or text-only conversational interfaces. Wayfinding intuitions about visual landmarks don't transfer; replaced by narrative ordering, prompts, and confirmation.

Worked examples

The examples are framework-agnostic — written in plain HTML, conceptual mockup, or general structure — to make the wayfinding decisions visible. Apply them to your stack of choice.

Example 1: a documentation site

A docs site with 200 pages of content is a wayfinding nightmare unless designed deliberately.

Orientation: every page has a sidebar showing the user's current section expanded and the current page highlighted. The breadcrumb at the top shows the path from root. The URL pattern (/docs/section/subsection/page) reinforces depth.

Route decision: the sidebar lists sibling pages and parent sections. A search box (with type-to-filter) handles "I don't know where this is, take me there."

Route monitoring: as the user clicks deeper, the URL extends and the breadcrumb grows. The sidebar's currently-active item visibly shifts. Internal links use a slightly different style than external links so the user can predict outcomes before clicking.

Destination recognition: every page has a single H1 matching its title in the nav. The sidebar's current-item highlight confirms "you are here." The page's own structure — code samples, examples, conclusion — matches the user's expectation of what a docs page contains.

html
<aside class="sidebar">
  <nav>
    <h2>Getting Started</h2>
    <ul>
      <li><a href="/docs/install">Installation</a></li>
      <li><a href="/docs/quickstart" aria-current="page">Quickstart</a></li>
      <li><a href="/docs/configuration">Configuration</a></li>
    </ul>
    <h2>Guides</h2>
    <ul>...</ul>
  </nav>
</aside>

<main>
  <nav aria-label="Breadcrumb">
    <ol>
      <li><a href="/docs">Docs</a></li>
      <li><a href="/docs/getting-started">Getting Started</a></li>
      <li aria-current="page">Quickstart</li>
    </ol>
  </nav>
  <h1>Quickstart</h1>
  <article>...</article>
</main>
Example 2: a hierarchical settings panel

A settings page with three sections, each with sub-sections, easily becomes "I changed something here last week and now I can't find it again."

Orientation: persistent settings nav (sidebar or stepped tabs) shows all top-level sections; current section highlighted; current sub-section nested visible.

Route decision: the section names map to user vocabulary, not internal team vocabulary. "Notifications" not "Push Subscriptions Service Configuration."

Route monitoring: clicking into a sub-section preserves the parent context; the settings nav still shows the user is inside "Notifications → Email."

Destination recognition: each settings page has a clear title, the controls relevant to that page only, and an obvious save affordance (or auto-save with confirmation toast). No ambiguity about whether a setting belongs to this page or another.

Example 3: a multi-step wizard

A 5-step checkout flow asks the user to navigate forward through known territory.

Orientation: stepper at top shows all 5 steps with current step highlighted and completed steps marked.

Route decision: the user typically only goes forward (Continue button) but should be able to go back to fix earlier steps without losing data.

Route monitoring: between steps, transitions are forward-feeling (slide-in from right, page builds); the stepper updates immediately to confirm the move.

Destination recognition: the final step is visually distinct ("Review your order" with a summary, a single "Place order" CTA); the post-purchase screen ("Thanks! Your order #12345 is confirmed") makes arrival unambiguous.

Show full SKILL.md (854 more words)Show less
Example 4: search as wayfinding recovery

For complex apps, search is the universal escape hatch: when wayfinding fails, the user types what they want and the system locates it.

html
<header>
  <input type="search" placeholder="Search docs, settings, projects..."
         aria-label="Search" id="global-search" />
</header>

<!-- Results show source/location for each match: -->
<ul class="search-results">
  <li>
    <a href="/docs/api/auth">
      <h3>Authentication</h3>
      <p class="path">Docs › API Reference › Authentication</p>
      <p class="snippet">Authentication uses bearer tokens...</p>
    </a>
  </li>
  <li>
    <a href="/settings/notifications">
      <h3>Email digest frequency</h3>
      <p class="path">Settings › Notifications</p>
    </a>
  </li>
</ul>

The breadcrumb-style path on each result is wayfinding for the search itself: it tells the user not just what matched but where it lives, building their cognitive map of the system.

Cross-domain examples

Hospital wayfinding

Hospitals are notorious wayfinding cases — anxious or unwell visitors with low cognitive bandwidth navigating large, often confusingly-labeled buildings. The best hospital wayfinding systems use:

  • Color-coded zones (Cardiology = blue, Oncology = green) so users orient by hue.
  • Floor-by-floor maps at every elevator landing.
  • "You are here" markers on every map — orientation made explicit.
  • Distinct landmarks at decision points (a sculpture, a fountain, a colored wall) that work even when signs are missed.
  • Greeters as a redundant human wayfinding system for users who fail the visual one.

Software equivalent: clear section identity (color, icon), maps (sitemap, breadcrumb), explicit current-location markers, distinct visual landmarks per section, and search as the human-greeter analog.

Airport wayfinding

Airports succeed where hospitals struggle because they:

  • Use a small vocabulary of unmistakable signs (Departures, Arrivals, Baggage Claim, Gates A/B/C).
  • Repeat key signs at frequent intervals (no decision point lacks a sign).
  • Use universal pictograms (planes, suitcases, restrooms) that survive language barriers.
  • Position signs at multiple heights so they're visible above crowds.

Software lessons: limit the IA vocabulary; repeat orientation cues frequently; use universal iconic representations; position chrome where users look.

Theme parks

Disney's parks deliberately use sightlines and "weenies" (a Walt Disney term for visual landmarks at the end of paths — Cinderella's Castle being the canonical one) to draw guests through the park without instruction. The wayfinding is invisible because the architecture itself does it.

Software equivalent: a well-designed app's home screen shows users where they can go without explicit nav — the visual hierarchy is the wayfinding.

Anti-patterns

  • The mystery URL. A page at /p/8f3c7a with no breadcrumb, no nav highlight, no obvious source. The user can't form a cognitive map.
  • "You are here" missing. A nav that doesn't highlight the current item. Users can't orient.
  • Ambiguous link labels. "Click here," "Read more," "Settings" (which settings?). Route decision degraded.
  • Inconsistent labels. A link called "Profile" leads to a page titled "Account Information" leads to a sub-section called "Personal Details." Each rename costs the user's mental map.
  • Hidden current page. No breadcrumb, no page title, no nav highlight. The user has only the URL — and even URLs are often opaque (/u/3829/?t=2).
  • Dead-end pages. A page the user lands on with no way out except the browser back button. Even error pages should offer a path forward.
  • Search-only IA. "If you need it, just search." Useful as a recovery; abdicating navigation in favor of search forces the user to type instead of recognize.

Heuristics

  1. The "where am I?" test. Drop a fresh user onto a random deep page in your app. Within 5 seconds, can they identify (a) what page they're on, (b) what section it belongs to, (c) how to get to the home page? If not, orientation is broken.
  2. The "find X" test. Give a user a goal ("change your notification frequency to weekly digest"). Time them. >60 seconds suggests route decision is broken.
  3. The "did I arrive?" test. After clicking, can the user tell whether they got to the right page or a transitional one? Ambiguity here means destination recognition is broken.
  4. The "trace your steps" test. Ask the user to retrace the path they took to get here. If they can't, route monitoring was inadequate.
  5. The 404 audit. Look at your top broken-link / 404 URLs. Each is a wayfinding failure (or a missing page that should exist).
  • mental-model — wayfinding works through the user's mental map; mental models are the substrate.
  • recognition-over-recall — recognizing a destination is easier than recalling its path.
  • progressive-disclosure — wayfinding's natural ally: don't show all of the IA at once; reveal as the user descends.
  • hierarchy (perception) — visual hierarchy is the orientation cue inside any single page.
  • consistency — wayfinding only works if the rules don't change between pages.
  • errors (interaction) — wayfinding errors (taking a wrong path) need recovery paths.
  • visibility — invisible nav makes wayfinding impossible; nav must be perceivable.
  • affordance (interaction) — links must look like links; navigation chrome must look navigable.

Sub-aspect skills (read these for specific applications)

  • wayfinding-physical-spatial-metaphors — when and how to borrow physical wayfinding metaphors (rooms, doors, paths) for software navigation; when to discard them.
  • wayfinding-search-and-recovery — designing search as the universal wayfinding recovery; lost-state pages, 404s, error recovery.
  • wayfinding-breadcrumbs-and-context — breadcrumbs, current-page indicators, "you are here" patterns; deciding when to use them and how to make them load-bearing rather than decorative.

Closing

Wayfinding is one of the cleanest cross-domain transfers in design — the same four stages apply to a hospital corridor and a settings page. The user looking lost in your dashboard and the visitor lost in a hospital basement are running the same cognitive process and failing it for the same reasons. Build for the four stages, and the user's experience of "moving through" your product becomes effortless in a way they never have to articulate.

© 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/wayfinding of hashgraph-online/awesome-codex-plugins.

  • SKILL.md
  • references/research-and-cross-domain.md

Open the folder on GitHubat commit 78497e5

Compare with similar skills

Wayfinding 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.

Wayfinding compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Wayfinding this skillhashgraph-online/awesome-codex-plugins1.2k—~4.2kAutomated safety check: PassApache-2.0
Agent Readiness Auditdocker/docs4.7k—~1.8kAutomated safety check: PassApache-2.0
Static SEOjdevalk/skills104—~4.8kAutomated safety check: PassMIT
Astro SEOjdevalk/skills104—~4.9kAutomated safety check: PassMIT
Docs AuditorInfrasity-Labs/dev-gtm-claude-skills139—~3kAutomated safety check: PassMIT
SEO GoogleAgriciDaniel/codex-seo7912 repos~3.4kAutomated safety check: PassMIT

Similar skills

  • Official

    Audit a documentation site for agent-friendliness: discovery, markdown delivery, crawlability, semantic structure, machine-readable surfaces, and content legibility.

    4.7k GitHub stars~1.8k tokensUpdated today
    Frontend & DesignAuto-check passed
  • Static SEO

    jdevalk/skills

    Audits and improves SEO for static HTML sites. An agent skill from jdevalk/skills.

    104 GitHub stars~4.8k tokensUpdated 3 mo ago
    Frontend & DesignAuto-check passed
  • Astro SEO

    jdevalk/skills

    Audits and improves SEO for Astro sites. An agent skill from jdevalk/skills.

    104 GitHub stars~4.9k tokensUpdated 3 mo ago
    Marketing & SEOAuto-check passed
  • Docs Auditor

    Infrasity-Labs/dev-gtm-claude-skills

    Audits any developer documentation site across 33 checks in 7 categories and produces a scored report (out of 100) with Pass / Warn / Fail status per check.

    139 GitHub stars~3k tokensUpdated 3 mo ago
    Marketing & SEOAuto-check passed
  • SEO Google

    AgriciDaniel/codex-seo

    Google SEO APIs: Search Console (Search Analytics, URL Inspection, Sitemaps), PageSpeed Insights v5, CrUX field data with 25-week history, Indexing API v3, and GA4 organic traffic.

    791 GitHub starsUsed in 2 repos~3.4k tokens
    Frontend & DesignAuto-check passed
  • SEO Setup

    alisamadiii/Portfolio

    Full SEO/metadata setup and audit for client websites (Astro, Next.js, any static site).

    180 GitHub stars~1.7k tokensUpdated today
    Marketing & SEOAuto-check passed

More from hashgraph-online/awesome-codex-plugins

All 686 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.2k 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.2k 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.2k 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.2k GitHub stars~2.4k 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.2k GitHub stars~618 tokensUpdated today
    Auto-check passed
  • Manuscript Engagement Analytics

    hashgraph-online/awesome-codex-plugins

    Analyze nonfiction manuscripts for reader engagement signals, including heading-level word counts, slow starts, long slogs, weak takeaway titles, value pacing, beta-reader comment dropoff, and…

    1.2k GitHub stars~875 tokensUpdated today
    Auto-check passed

Questions about Wayfinding

What does Wayfinding do?

A skill your agent uses whenever a user must navigate within a non-trivial space — a multi-page web app, a documentation site, a hierarchical settings panel, a conference site, a multi-step flow, a…. Wayfinding is an agent skill from hashgraph-online/awesome-codex-plugins. Use this skill whenever a user must navigate within a non-trivial space — a multi-page web app, a documentation site, a hierarchical settings panel, a conference site, a multi-step flow, a campus, a building, an app with deep IA.

When should I use Wayfinding?

Wayfinding fits situations like: A user must navigate within a non-trivial space — a multi-page web app; A documentation site; A hierarchical settings panel; A conference site.

How do I install Wayfinding in Claude Code?

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

How do I install Wayfinding in Codex?

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

Can I use Wayfinding 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 wayfinding -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/wayfinding, .gemini/skills/wayfinding, .github/skills/wayfinding and .opencode/skills/wayfinding in your project.

What does Wayfinding need to run?

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

Does Wayfinding 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 Wayfinding 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 Wayfinding use?

Wayfinding 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 Wayfinding use?

About 4.2k tokens (SKILL.md is roughly 17k 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 2.5k tokens, read only when the agent opens those files.

What are the alternatives to Wayfinding?

Skills that share tags, products or a category with Wayfinding: Agent Readiness Audit (docker/docs, 4.7k stars), Static SEO (jdevalk/skills, 104 stars), Astro SEO (jdevalk/skills, 104 stars) and Docs Auditor (Infrasity-Labs/dev-gtm-claude-skills, 139 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Wayfinding?

hashgraph-online (a GitHub organization) maintains it in hashgraph-online/awesome-codex-plugins, which has 1,242 GitHub stars. The repository holds 686 skills in this directory. The repository was last updated on October 8, 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.