Web Artifacts Builder
anthropics/skills
Builds multi-component claude.ai HTML artifacts as a small React, TypeScript and Tailwind project, then bundles it into one shareable HTML file.
Imperative scrolling for react-horizontal-scrolling-menu: scrollToItem(getItemById(id), behavior, inline, block), scrollNext/scrollPrev, apiRef for controlling the menu from outside (fire methods…
$ npx skills add asmyshlyaev177/react-horizontal-scrolling-menu --skill menu-scrolling -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install asmyshlyaev177/react-horizontal-scrolling-menu menu-scrolling --agent claude-codeProject scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).
$ git clone --depth 1 https://github.com/asmyshlyaev177/react-horizontal-scrolling-menu.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/menu-scrolling .claude/skills/menu-scrolling && rm -rf skills-srcUse ~/.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/
Install the "menu-scrolling" agent skill from https://github.com/asmyshlyaev177/react-horizontal-scrolling-menu/tree/master/skills/menu-scrolling into .claude/skills/menu-scrolling/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "menu-scrolling", then confirm the skill loads.Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$skill-installer install https://github.com/asmyshlyaev177/react-horizontal-scrolling-menu/tree/master/skills/menu-scrollingType this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
$ npx skills add asmyshlyaev177/react-horizontal-scrolling-menu --skill menu-scrolling -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install asmyshlyaev177/react-horizontal-scrolling-menu menu-scrolling --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/asmyshlyaev177/react-horizontal-scrolling-menu.git skills-src && mkdir -p .agents/skills && cp -r skills-src/skills/menu-scrolling .agents/skills/menu-scrolling && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "menu-scrolling" agent skill from https://github.com/asmyshlyaev177/react-horizontal-scrolling-menu/tree/master/skills/menu-scrolling into .agents/skills/menu-scrolling/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "menu-scrolling", then confirm the skill loads.Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add asmyshlyaev177/react-horizontal-scrolling-menu --skill menu-scrolling -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install asmyshlyaev177/react-horizontal-scrolling-menu menu-scrolling --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/asmyshlyaev177/react-horizontal-scrolling-menu.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/skills/menu-scrolling .cursor/skills/menu-scrolling && rm -rf skills-srcUse ~/.cursor/skills/ instead of .cursor/skills for a personal install.
Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/
Install the "menu-scrolling" agent skill from https://github.com/asmyshlyaev177/react-horizontal-scrolling-menu/tree/master/skills/menu-scrolling into .cursor/skills/menu-scrolling/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "menu-scrolling", then confirm the skill loads.Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gemini skills install https://github.com/asmyshlyaev177/react-horizontal-scrolling-menu.git --path skills/menu-scrolling--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
$ npx skills add asmyshlyaev177/react-horizontal-scrolling-menu --skill menu-scrolling -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install asmyshlyaev177/react-horizontal-scrolling-menu menu-scrolling --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/asmyshlyaev177/react-horizontal-scrolling-menu.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/skills/menu-scrolling .gemini/skills/menu-scrolling && rm -rf skills-srcUse ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.
Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/
Install the "menu-scrolling" agent skill from https://github.com/asmyshlyaev177/react-horizontal-scrolling-menu/tree/master/skills/menu-scrolling into .gemini/skills/menu-scrolling/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "menu-scrolling", then confirm the skill loads.Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gh skill install asmyshlyaev177/react-horizontal-scrolling-menu menu-scrollingInstalls for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
$ npx skills add asmyshlyaev177/react-horizontal-scrolling-menu --skill menu-scrolling -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/asmyshlyaev177/react-horizontal-scrolling-menu.git skills-src && mkdir -p .github/skills && cp -r skills-src/skills/menu-scrolling .github/skills/menu-scrolling && rm -rf skills-srcUse ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.
GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/
Install the "menu-scrolling" agent skill from https://github.com/asmyshlyaev177/react-horizontal-scrolling-menu/tree/master/skills/menu-scrolling into .github/skills/menu-scrolling/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "menu-scrolling", then confirm the skill loads.GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add asmyshlyaev177/react-horizontal-scrolling-menu --skill menu-scrolling -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install asmyshlyaev177/react-horizontal-scrolling-menu menu-scrolling --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/asmyshlyaev177/react-horizontal-scrolling-menu.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/skills/menu-scrolling .opencode/skills/menu-scrolling && rm -rf skills-srcUse ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.
OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/
Install the "menu-scrolling" agent skill from https://github.com/asmyshlyaev177/react-horizontal-scrolling-menu/tree/master/skills/menu-scrolling into .opencode/skills/menu-scrolling/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "menu-scrolling", then confirm the skill loads.OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
menu-scrollingImperative scrolling for react-horizontal-scrolling-menu: scrollToItem(getItemById(id), behavior, inline, block), scrollNext/scrollPrev, apiRef for controlling the menu from outside (fire methods…
Menu Scrolling is an agent skill from asmyshlyaev177/react-horizontal-scrolling-menu. Imperative scrolling for react-horizontal-scrolling-menu: scrollToItem(getItemById(id), behavior, inline, block), scrollNext/scrollPrev, apiRef for controlling the menu from outside (fire methods, never read data), getItemElementById/getItemElementByIndex for just-added items, and page-at-a-time navigation with slidingWindow + getItemsPos. Load when scrolling to an item on mount or selection, controlling the menu from outside, scrolling after adding items dynamically, or when scrollToItem silently does nothing or…
Its SKILL.md is about 3.1k tokens, which your agent loads only when the skill is triggered. The skill folder holds 2 other files, including reference files (for example `references/api.md`).
It sits in Frontend & Design. It works with React. The repository describes itself as: Horizontal scrolling menu component for React with per-item visibility tracking. Supports mouse and touch devices, SSR-safe. The licence is MIT.
Read from SKILL.md and the folder at commit 42c99aa. It shows what the files ask for, not the result of running them.
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.
No scripts in the folder and no shell commands in SKILL.md (its code samples are typescript).
From the folder's file list and the shell code blocks in SKILL.md.
No URLs in SKILL.md.
From URLs in SKILL.md, links to its own repository left out.
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
Menu Scrolling loads about 3.1k tokens when it runs, and up to ~6.2k if it reads all its reference files. Until then it costs about 142 tokens; SKILL.md has 760 words of instructions outside code blocks.
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.
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.
The full file from asmyshlyaev177/react-horizontal-scrolling-menu at commit 42c99aa, republished under its MIT licence (© asmyshlyaev177). 760 words, ~3,136 tokens.
.claude/skills/menu-scrolling/SKILL.md (or your agent's skills folder). This skill also uses 1 other file; get the full folder from GitHub.Click an item to center it. The api object comes from VisibilityContext
inside the menu, from the apiRef prop outside it, and as the first argument
of every callback prop (onInit, onUpdate, onWheel, onScroll).
import React from 'react';
import {
ScrollMenu,
VisibilityContext,
type publicApiType,
} from 'react-horizontal-scrolling-menu';
import 'react-horizontal-scrolling-menu/dist/styles.css';
const ids = ['item-0', 'item-1', 'item-2', 'item-3', 'item-4', 'item-5'];
function Card({ itemId, title }: { itemId: string; title: string }) {
const api = React.useContext<publicApiType>(VisibilityContext);
return (
<div
role="button"
tabIndex={0}
style={{ width: '160px' }}
onClick={() =>
api.scrollToItem(api.getItemById(itemId), 'smooth', 'center')
}
>
{title}
</div>
);
}
export function Menu() {
return (
<ScrollMenu>
{ids.map((id) => (
<Card itemId={id} key={id} title={id} />
))}
</ScrollMenu>
);
}The blessed form is api.scrollToItem(api.getItemById(id), 'smooth', 'center')
— a bare string id is a silent no-op (see Common Mistakes).
getItemElementById(id) / getItemElementByIndex(index) are the
advanced form: they query the DOM directly by data-key / data-index,
which makes them stale-proof for items added in the current render.
Defaults (src/helpers.tsx:60,68-69; src/createApi.ts:131-132,152-153):
| Method | behavior | inline | block |
|---|---|---|---|
| scrollToItem | 'smooth' | 'end' | 'nearest' |
| scrollPrev | 'smooth' | 'end' | 'nearest' |
| scrollNext | 'smooth' | 'start' | 'nearest' |
behavior accepts 'auto' | 'instant' | 'smooth' and falls back to the
transitionBehavior prop when one is set. The optional trailing
{ duration, boundary } argument only takes effect with
noPolyfill={false} — the default native scroll ignores it.
Pass a ref to ScrollMenu; the full context value is assigned to it after
mount. Use it to fire methods only — data read from it goes stale.
import React from 'react';
import {
ScrollMenu,
type publicApiType,
} from 'react-horizontal-scrolling-menu';
import 'react-horizontal-scrolling-menu/dist/styles.css';
const ids = ['item-0', 'item-1', 'item-2', 'item-3', 'item-4', 'item-5'];
function Card({ itemId, title }: { itemId: string; title: string }) {
return <div style={{ width: '160px' }}>{title}</div>;
}
export function PageWithExternalControls() {
const apiRef = React.useRef<publicApiType | null>(null);
const centerItem = (id: string) => {
const api = apiRef.current;
if (api) api.scrollToItem(api.getItemById(id), 'smooth', 'center');
};
return (
<div>
<button onClick={() => apiRef.current?.scrollPrev()}>Prev</button>
<button onClick={() => centerItem('item-3')}>Center item-3</button>
<button onClick={() => apiRef.current?.scrollNext()}>Next</button>
<ScrollMenu apiRef={apiRef}>
{ids.map((id) => (
<Card itemId={id} key={id} title={id} />
))}
</ScrollMenu>
</div>
);
}onInit fires once the menu has rendered and measured its items, so the api
is safe to use right away — no timers. Use 'auto' (instant) so the initial
position does not animate.
import React from 'react';
import {
ScrollMenu,
type publicApiType,
} from 'react-horizontal-scrolling-menu';
import 'react-horizontal-scrolling-menu/dist/styles.css';
const ids = ['item-0', 'item-1', 'item-2', 'item-3', 'item-4', 'item-5'];
function Card({ itemId, title }: { itemId: string; title: string }) {
return <div style={{ width: '160px' }}>{title}</div>;
}
export function MenuStartingAtItemFive() {
const scrollToItemOnInit = (api: publicApiType) => {
const el = api.getItemElementById('item-5');
if (el) api.scrollToItem(el, 'auto', 'start');
};
return (
<ScrollMenu onInit={scrollToItemOnInit}>
{ids.map((id) => (
<Card itemId={id} key={id} title={id} />
))}
</ScrollMenu>
);
}scrollNext/scrollPrev already move one viewport-group. Use
slidingWindow + getItemsPos when you need to control which item of the
target group lands where — e.g. centering the next page:
import {
getItemsPos,
slidingWindow,
type publicApiType,
} from 'react-horizontal-scrolling-menu';
function scrollOnePage(api: publicApiType, direction: 'prev' | 'next') {
const visible = api.items.getVisible().map(([id]) => id);
if (!visible.length) return;
const group = slidingWindow(api.items.toItems(), visible)[direction]();
const target = getItemsPos(group).center;
api.scrollToItem(api.getItemById(target), 'smooth', 'center');
}slidingWindow(allIds, visibleIds) returns { prev(), next() } — each an
id array the size of the visible set, clamped at the row edges.
getItemsPos(group) returns { first, center, last } ids of that group.
Wrong:
api.scrollToItem('item-3', 'smooth', 'center'); // nothing scrollsCorrect:
api.scrollToItem(api.getItemById('item-3'), 'smooth', 'center');The JSDoc example shows a bare 'itemId', but scrollToItem unwraps
target?.entry?.target — a string has no .entry and no .scrollIntoView,
so the call is a silent no-op (the TS type ItemOrElement correctly rejects
strings; plain JS gets no error at all).
Source: src/createApi.ts:307-313 (JSDoc) vs src/helpers.tsx:59-64; https://github.com/asmyshlyaev177/react-horizontal-scrolling-menu/issues/157
Wrong:
const atEnd = apiRef.current?.isLastItemVisible; // in render: never re-rendersCorrect:
const api = apiRef.current;
if (api) api.scrollToItem(api.getItemById('item-3'), 'smooth', 'center');apiRef is a mutable object React cannot re-render on — values read from it
during render go stale. Inside event handlers and timers the visibility
getters read the live ItemsMap and are fine (on <= 8.3.1 they were frozen
even there — read api.items.last()?.visible instead). Reactive state in
components comes from the context hooks.
Source: README.md apiRef section; https://github.com/asmyshlyaev177/react-horizontal-scrolling-menu/issues/167
Wrong:
setItems((prev) => [...prev, newItem]);
const api = apiRef.current;
if (api) api.scrollToItem(api.getItemById(newItem.id)); // undefined target — no-opCorrect:
// after the state update commits (effect or callback):
const api = apiRef.current;
const el = api?.getItemElementById(newItem.id);
if (api && el) api.scrollToItem(el, 'smooth', 'end');The ItemsMap lags children by one render, so the map does not know a
just-appended item yet; getItemElementById/getItemElementByIndex query
the DOM by data-key/data-index and are stale-proof for this case.
Source: https://github.com/asmyshlyaev177/react-horizontal-scrolling-menu/issues/167; discussion #295; stories/AddItemAndScrollToIt
Wrong:
setInterval(() => apiRef.current?.scrollNext(), 3000); // page keeps jumping to the menuCorrect:
setInterval(() => {
if (apiRef.current?.menuVisible.current) apiRef.current.scrollNext();
}, 3000);Scrolling is scrollIntoView-based, so scroll methods called while the menu
is off screen scroll ancestor containers too (the page jumps vertically to
the menu) — gate every programmatic scroll on menuVisible.current.
Source: https://github.com/asmyshlyaev177/react-horizontal-scrolling-menu/issues/276 (#277, #174, #230)
Wrong:
<Card itemId={idx} key={idx} title={String(idx)} />;
// later:
api.getItemById(idx + 1);Correct:
<Card itemId={String(idx)} key={idx} title={String(idx)} />;
// later:
api.getItemById(String(idx + 1));itemId is String()-coerced everywhere internally, so getItemById(5)
looks up "5" — mixing number and string ids causes missed lookups.
Source: CHANGELOG v3.1.1 (#207); src/helpers.tsx:102
Wrong:
const apiRef = React.useRef<publicApiType | null>(null);
apiRef.current.scrollNext(); // during render — crash or no-opCorrect:
const apiRef = React.useRef<publicApiType | null>(null);
React.useEffect(() => {
apiRef.current?.scrollNext();
}, []);apiRef is populated in a useEffect after mount (src/index.tsx:281-287);
before that current is null (or an empty object internally) — call methods
only from effects or event handlers, with optional chaining.
Source: src/index.tsx:148,281-287
Wrong:
const all = api.items.toItems();
const firstVisible = api.items.getVisible()[0]?.[0];
const next = all[all.indexOf(firstVisible) + 3]; // breaks at edges, wrong in RTLCorrect:
const visible = api.items.getVisible().map(([id]) => id);
const next = slidingWindow(api.items.toItems(), visible).next();
api.scrollToItem(api.getItemById(getItemsPos(next).center), 'smooth', 'center');Page-at-a-time and centering math is shipped — slidingWindow().prev()/.next()
plus getItemsPos() handle row edges and RTL; hand-rolled index math misses
both.
Source: README.md Other helpers; stories/OneItemScroll
The library contains zero throws or warnings — every contract violation (missing styles.css, missing/duplicate itemId, string to scrollToItem) fails silently with no error to debug from. Self-check the contracts before shipping. See skills/menu-setup/SKILL.md and skills/menu-visibility/SKILL.md.
The api object mixes live methods, reactive hooks, non-reactive getters
(isFirstItemVisible/isLastItemVisible) and mutable stores (items,
apiRef). Fire methods imperatively; in components rendered under ScrollMenu
read state through the hooks — render reads of the getters never update. See
skills/menu-visibility/SKILL.md.
noPolyfill defaults to true, so the per-call { duration, boundary }
ScrollOptions and the transition props are silently discarded;
noPolyfill={false} restores animation control but re-imports polyfill edge
bugs (RTL, page-level scrolling). See skills/menu-transitions-rtl/SKILL.md.
items.getVisible()), and scroll gating uses menuVisible© asmyshlyaev177, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file
SKILL.md and 1 other file (references) in skills/menu-scrolling of asmyshlyaev177/react-horizontal-scrolling-menu.
Open the folder on GitHubat commit 42c99aa
Menu Scrolling 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.
| Skill | Stars | Used in | Tokens | Auto-check | Licence | Repo updated |
|---|---|---|---|---|---|---|
| Menu Scrolling this skillasmyshlyaev177/react-horizontal-scrolling-menu | 790 | — | ~3.1k | Automated safety check: Pass | MIT | |
| Web Artifacts Builderanthropics/skills | 180k | 41 repos | ~769 | Automated safety check: Pass | Apache-2.0 | |
| React Doctormakeplane/plane | 61k | 12 repos | ~657 | Automated safety check: Pass | AGPL-3.0 | |
| React Router Developmentremix-run/react-router | 57k | 1 repos | ~1.5k | Automated safety check: Pass | MIT | |
| React UI State PatternsChrisWiles/claude-code-showcase | 6.1k | 8 repos | ~1.6k | Automated safety check: Pass | None | |
| GSAP Core Animationgreensock/gsap-skills | 16k | 4 repos | ~3.7k | Automated safety check: Pass | MIT |
anthropics/skills
Builds multi-component claude.ai HTML artifacts as a small React, TypeScript and Tailwind project, then bundles it into one shareable HTML file.
makeplane/plane
Scans React code for lint, accessibility, bundle size and architecture issues, reports a health score and checks that changes do not lower it.
remix-run/react-router
Guides work on React Router apps by first identifying whether the app uses Framework, Data or Declarative mode, then loading the matching reference and the installed package docs.
ChrisWiles/claude-code-showcase
Sets patterns for React interfaces: when to show loading spinners or skeletons, how to surface errors, how to disable buttons during async work and how to handle empty lists.
greensock/gsap-skills
Covers the GSAP core API for tweens, easing, staggers, defaults and matchMedia, and when to choose GSAP over CSS animations or other JavaScript animation libraries.
lobehub/lobehub
Builds single-file interactive HTML prototypes rendered with the real LobeHub UI components and written as production-style React, so they can later be split into files.
asmyshlyaev177/react-horizontal-scrolling-menu
Recipes composed on the react-horizontal-scrolling-menu public API — NOT props: autoplay (setInterval + scrollNext gated on menuVisible), infinite loop/carousel (clone head/tail + scrollLeft…
asmyshlyaev177/react-horizontal-scrolling-menu
Wire mouse, wheel and touch input for react-horizontal-scrolling-menu: onWheel/onScroll are plain (api, event) = void callbacks, while ALL mouse/touch props (onMouseDown, onMouseUp, onMouseMove…
asmyshlyaev177/react-horizontal-scrolling-menu
Detect and upgrade pre-v8 react-horizontal-scrolling-menu patterns that agents trained on older data still generate: destructured visibleElements/isFirstItemVisible/isLastItemVisible/initComplete…
asmyshlyaev177/react-horizontal-scrolling-menu
Build a working react-horizontal-scrolling-menu: install, the mandatory 'react-horizontal-scrolling-menu/dist/styles.css' import, ScrollMenu with a unique itemId per child, arrow components via…
asmyshlyaev177/react-horizontal-scrolling-menu
Server rendering and testing for react-horizontal-scrolling-menu: the library is client-only ('use client' required in React Server Components, else "createContext is not a function"), SSR first…
asmyshlyaev177/react-horizontal-scrolling-menu
Animate react-horizontal-scrolling-menu scrolling and build right-to-left menus: noPolyfill defaults to true since v8, so transitionDuration (default 500), a custom-easing-function…
Works with
Categories
Imperative scrolling for react-horizontal-scrolling-menu: scrollToItem(getItemById(id), behavior, inline, block), scrollNext/scrollPrev, apiRef for controlling the menu from outside (fire methods…. Menu Scrolling is an agent skill from asmyshlyaev177/react-horizontal-scrolling-menu. Imperative scrolling for react-horizontal-scrolling-menu: scrollToItem(getItemById(id), behavior, inline, block), scrollNext/scrollPrev, apiRef for controlling the menu from outside (fire methods, never read data), getItemElementById/getItemElementByIndex for just-added items, and page-at-a-time navigation with slidingWindow + getItemsPos.
Menu Scrolling fits situations like: frontend & Design work in your project.
Run `npx skills add asmyshlyaev177/react-horizontal-scrolling-menu --skill menu-scrolling -a claude-code`. Or copy the skill folder (skills/menu-scrolling in asmyshlyaev177/react-horizontal-scrolling-menu) into .claude/skills/menu-scrolling in your project. Claude Code loads it when a task matches its description.
Run `npx skills add asmyshlyaev177/react-horizontal-scrolling-menu --skill menu-scrolling -a codex`. Or copy the skill folder (skills/menu-scrolling in asmyshlyaev177/react-horizontal-scrolling-menu) into .agents/skills/menu-scrolling in your project. Codex loads it when a task matches its description.
Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add asmyshlyaev177/react-horizontal-scrolling-menu --skill menu-scrolling -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/menu-scrolling, .gemini/skills/menu-scrolling, .github/skills/menu-scrolling and .opencode/skills/menu-scrolling in your project.
SKILL.md names no scripts, command-line tools or credentials: Menu Scrolling is instructions for the agent only.
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.
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.
Menu Scrolling is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.
About 3.1k tokens (SKILL.md is roughly 13k 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 3.1k tokens, read only when the agent opens those files.
Skills that share tags, products or a category with Menu Scrolling: Web Artifacts Builder (anthropics/skills, 180k stars), React Doctor (makeplane/plane, 61k stars), React Router Development (remix-run/react-router, 57k stars) and React UI State Patterns (ChrisWiles/claude-code-showcase, 6.1k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
asmyshlyaev177 (a GitHub user) maintains it in asmyshlyaev177/react-horizontal-scrolling-menu, which has 790 GitHub stars. The repository holds 8 skills in this directory. The repository was last updated on October 1, 2026.
Source: asmyshlyaev177/react-horizontal-scrolling-menu on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.