use-tools
Skill68 starsChanged 2 days agoMITView on GitHub
The project's ready-made tools — what exists, where it lives, and why looking first is not optional. Load this BEFORE building any interface piece that feels generic: a picker, a cropper, a dialog for translations, a microphone, a code viewer, a media trimmer. Also load it when the owner says "we already made that", "why is there no window", "use the tool we built" — that sentence usually means a tool exists and was not found. Tools live in `_tools/<id>/` and are listed in `_tools/TOOLS.json`; anything built beside them is a second copy nobody asked for.
2 other projects use a version of this.
Adopted by
Most recently taken up by
- Fractera/web4-node-starter-kitword for word, first seen Nov 15, 2026
- Fractera/Agentic-Engineering-Infrastructureword for word, first seen Nov 8, 2026
Other versions2 projects use a version of this.
Word for word · 2
- Fractera/Agentic-Engineering-Infrastructure★ 68100% same
- Fractera/web4-node-starter-kit★ 68100% same
Edited · 0
None found.
Wrote their own version · 0
None found.
How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.
In this repository91 other files it gives its agents.
- app/AGENTS.mdAGENTS.md
- CLAUDE.mdCLAUDE.md
- adopt-suggested-skillSkill
- ai-elementsSkill
- ai-sdkSkill
- answer-elementSkill
- ask-elementSkill
- audit-broken-charactersSkill
- build-product-with-ownerSkill
- content-factorySkill
- core-build-returnSkill
- core-scheduleSkill
- create-elementSkill
- create-multilingual-content-entrySkill
- dedicated-serverSkill
- design-and-settings-of-elementsSkill
- element-permissionSkill
- element-powerSkill
- expand-site-languageSkill
- explain-this-projectSkill
- find-skillsSkill
- fractera-vs-anthropicSkill
- handle-needSkill
- helpful-linksSkill
- help-in-browserSkill
- humanizerSkill
- integratorSkill
- interface-designSkill
- know-the-architectSkill
- manage-app-settingsSkill
- money-and-resourcesSkill
- node-typeSkill
- own-agentsSkill
- persist-env-var-with-rebuildSkill
- place-page-in-menuSkill
- provider-rulesSkill
- release-templateSkill
- researchSkill
- review-pageSkill
- route-to-elementSkill
- self-reviewSkill
- shadcnSkill
- shape-the-needSkill
- skill-creatorSkill
- study-for-elementSkill
- supervise-elementSkill
- translate-pendingSkill
- ultracode-sessionSkill
- use-agentic-ragSkill
- use-ai-generationSkill
- use-aioSkill
- use-app-configSkill
- use-auth-providersSkill
- use-authSkill
- use-browserSkill
- use-channelsSkill
- use-chatSkill
- use-code-shapeSkill
- use-databaseSkill
- use-dataSkill
- The first 60 shown.
The file
We split this skill into the rules it gives an agent
3 rules. About 0 are common, 3 are distinctive, and 0 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈3
Distinctive · estimate
This author's own choices. Worth a look.
0
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 37
Every part is kept once and found on its own: who needs only the crop takes the crop.
- Distinctive: line 176
Ask first whether the thing is genuinely reusable or belongs to one screen.
- Distinctive: line 186
If it is a tool: put the words on the server and hand them to the island as props — the panel's dictionary is 82 languages and never …
≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
use-tools
Informational, not binding. Know a better way for the case in front of you — do it your way and say so. You are trusted with the creative work on this project.
A tool here is a small reusable piece with a home: one folder, one tool.json card beside its code,
one place in the showcase that says what it does, how to use it and what it needs. Not a helper
hidden in a feature folder — those are invisible, and invisible is the same as absent.
🔒 What a tool is — decided at its birth, not after (step 733)
The owner, 2026-11-12: «модели не понимают когда их создавать и куда их складывать и вторая задача более первичная чем первая» — a
search finds only what was born as a tool. The definition is his and lives in the panel glossary (architect-home.i18n.ts, «Tool»):
«Инструмент это то что решает задачу и используют для этого визуальный интерфейс. Один инструмент может быть частью другого»
A tool solves a task and shows its own interface for it. It does not know which page it stands on: its material comes from outside and its result goes back out — the translations dialog «connects to any entity with translatable fields», the terminal paste window «does not know the socket». That is why any element can use it.
Tools nest. The owner's example: an image-editing form is a modal window; inside it the crop; beside it the voice input that turns speech into text («перерисуй это изображение в таком стиле»); and the call to the image technology that carries the words out. Four tools, one inside another — and the form is a tool too.
A combination is kept as a recipe: its own code (the glue) and its parts by id and version, never copies of the parts inside it. Every part is kept once and found on its own: who needs only the crop takes the crop; who needs the form takes the form, and the form brings its parts.
Not a tool: a shadcn primitive (a button or a field solves no task by itself); a section (how a page's content looks); a widget (code of one page address — it reads that page's data; the tools it holds are taken, not written inside it). A server job without a screen of its own (transcription, a model call) is not a separate tool — it is a part of the tool whose interface calls it.
Three questions, in this order, about the piece you are about to write — each a yes or a no, no guessing about the future:
- Is it how the content of a page looks (a hero, prices, questions)? → a section (
use-sections). - Is it bound to this page — reads its data, knows where it stands? → a widget of that route (
use-widgets); the tools inside it are taken or born as tools, never written into the widget. - Does it solve a task with its own interface, its material coming from outside? → a tool, even when one place needs it today.
Made of other tools — they are its parts: each found by
parts_findor born first as a tool of its own, from the inside out.
A task solved INSIDE a widget is taken out into a tool, and the widget holds it — the row «state dot + element name» was written three times in one step (722) because nobody asked the third question at the first copy. The same set of tools combined in a second place becomes a combination tool of its own.
Where it goes: _tools/<id>/ with its card tool.json first (the task, the interface, its parts) — in the element where it is born.
On a person's node the core is Fractera's and takes no new tools (CLAUDE.md §6); the core's own tools come with Fractera's releases.
Where to look, in this repository
The list: _tools/TOOLS.json and each tool's own folder _tools/<id>/: what it does, how to use it, what it gives you, what
it needs (browser, HTTPS, an OpenAI key, ffmpeg), which package must be installed, and who already calls it.
🔒 THE CATALOGUE IS GENERATED FROM THE FOLDER, AND A SECOND LIST IS FORBIDDEN. Each tool carries
_tools/<id>/tool.json; npm run build:tools-map renders _tools/TOOLS.json from those cards and
check:tools-map fails the build when a folder has no card, when a card promises an entry file that
is not on disk, or when the map is stale. So the honest answer to "what tools does this project
have?" is the folder — never a list in prose.
✗ This is not a precaution, it is a repair. Until 2026-08-31 this project's own CLAUDE.md said
"Five ready pieces" while _tools/ held six: socials-ai had arrived, was wired into the socials
field, and was named nowhere. A hand-written list diverges silently, and nothing wakes up, because
there is nothing to wake.
🔒 THE DESCRIPTION LIVES IN tool.json, NEXT TO THE CODE. Editing what a tool does means editing
its card in the same commit — text torn from its code goes stale on the day the tool changes. The
page's dictionary holds only field labels.
🔒 Прочитай соседний инструмент прежде, чем писать свой
Пять готовых лежат рядом (_tools/), и первый шаг всегда один: открой ближайший по смыслу и
прочитай целиком. Берётся устройство — из каких частей собран, где договор, как объявлены слова,
как он сообщает об отказе; берётся вид — ритм, размеры, состояния. Не берётся его логика: она про
другой предмет.
Причина та же, по которой это записано у виджетов: набор, собранный каждым по-своему, перестаёт быть набором. Инструмент, чей отказ выглядит иначе, чем у соседа, читается как чужой, даже когда работает безупречно.
Look before you build — the failure this prevents is real, not theoretical
The translations dialog existed for months. Its own header said "connects to any entity with translatable fields". It was written for the footer and menu sections specifically. And when the translate button in those very sections was built, it was built from scratch: a call to the door and one line of text — no language cards, no manual editing, no per-language save.
Nobody was lazy. The tool sat in components/i18n/, not in _tools/, and no catalogue listed it.
There was nowhere to look. That is the whole lesson: a tool without a home does not exist, no
matter how good it is.
So: before writing an interface piece that feels generic, open the showcase — or read
_tools/TOOLS.json, which is what the showcase reads. It costs one file read. Building the second
copy costs a day, and the copies drift apart quietly afterwards.
✗ This paragraph used to send you to bridges/app/lib/tools-registry.ts, and that file does not
exist in this repository (corrected 2026-08-31). It is the panel's, and the panel lives outside
your repository. Exactly the failure the removed "two homes" law caused, in the same skill: an agent
reading it either hunts for something absent or decides the rule is not for him.
Two homes on purpose — and only one of them is yours
🔒 THE MIRROR IS THE PLATFORM'S BUSINESS, NOT YOURS. Some tools also exist in the panel, outside
your repository, and the section below explains why that duplication is deliberate. Read it as
background, not as an instruction: you can neither see nor edit the panel's copy, and the same
correction was already made once in CLAUDE.md, where a federal law about "two homes" stood in the
guest's document until 2026-08-24. Your side of it is one sentence — a tool lives in _tools/<id>/,
in your repository, and that is what makes it yours.
The same tool is copied on both sides: bridges/app/_tools/ (panel) and the app's _tools/.
Deleting one of the two breaks something real:
- Panel-only would make the app depend on the panel at runtime — and the owner's right to detach and run alone dies with it.
- App-only would put the panel's own forms inside the user's repository, where he can delete them and break the panel he is using.
Copies drift. That is the price, and it is paid deliberately. What keeps it survivable: each copy carries a header naming its mirror and listing what differs and why. Typically the dialog primitive (the panel's shadcn vs the app's shared dialog), where languages come from (a prop vs the app's own config), and which door does the work. Behaviour stays common.
Distribution is by copy, never by network call. The app does not read tools from the panel at
runtime — it installs a copy into its own tools/<id>/ and edits it as its own code. A tool is
almost always adjusted to the task; reading it over the network would mean either forbidding edits
or drifting silently between what is installed and what runs.
What a tool must carry to count as one
_tools/<id>/ with client / server / types — one folder, so that "take the tool" means
"copy the folder" and not "hunt seven files across the tree".
_tools/<id>/tool.json beside it, and this is the part that is easy to skip and fatal to skip:
| Field | What goes in it |
entry | the file a caller imports; the gate checks it exists on disk |
needs | honest requirements — browser, https, openai-key, ffmpeg |
npmDeps | packages this repository lacks; a missing package is a decision for the owner before installing, not a surprise at build time |
usedBy | who already calls it. Empty is legal and is said in words ("not used by anything yet"), never left blank |
en / ru | title · what it does · how to use it · value it gives. Written for a person, not a changelog |
Then npm run build:tools-map, and the tool appears in the showcase by itself — there is no list to
add yourself to. check:tools-map refuses the build if the card is missing or stale.
Half of that is not a tool. It is a component someone will fail to find.
A component from a foreign registry: read the technique, not the manifest
🔒 npmDeps answers what will be INSTALLED. It never answers what the reader GETS. A visual
component brought in from someone else's registry (AI Elements, shadcn-style catalogues, a snippet
from a docs site) can add no package at all and still hand every visitor without JavaScript a broken
surface — the known case paints its text with bg-clip-text text-transparent, so the letters are
transparent and only the background makes them visible.
Before installing, grep its source for how it draws content: transparent, bg-clip-text,
clip-path, mask-image, visibility, initial. Anything found there is a decision for the
static twin (use-widgets), not a detail — and it is invisible in the dependency list, in the demo
and in the screenshot, because all three run JavaScript.
Pairs with the CLI law — ANTI-PATTERNS.md, "An unknown flag on a foreign CLI means do
everything": same suspicion of outside code, a different axis. That one is about what it may
execute, this one about what it may hide.
When you build a new one
Ask first whether the thing is genuinely reusable or belongs to one screen. A tool that serves one caller is a component in that caller's folder, and pretending otherwise puts a card in the showcase that nobody reads.
🔒 THE REQUEST FORM ASKS THAT QUESTION FOR YOU, AND ITS ANSWER TRAVELS TO YOU. The card at the
bottom of the showcase has a second field — where will you use it — precisely because that is what
separates a tool from a widget: will a SECOND caller want exactly this thing. When a request reaches
pre-steps/ with that field empty, it is not a formality you may skip; it is the question to ask
before the first line.
If it is a tool: put the words on the server and hand them to the island as props — the panel's
dictionary is 82 languages and never travels to the browser. Take the owner's existing pieces
rather than adding your own: the microphone, the cropper and the code viewer are already there.
Name refusals plainly and link to where they are cured; "could not" tells a person nothing about
what to do next. And write the tool.json card in the same commit as the code — a card added
later is a card written from memory.
If a tool was deleted, do not rebuild it from memory
The starter's own tools live in its latest version: https://github.com/Fractera/fractera-next-starter. Take the ARCHITECTURE from there — folder shape, contract, layer boundaries — not the text or the images of that project. Copying a whole page into someone else's product carries their identity along with it; copying the structure is exactly what the specimens exist for.
A tool rebuilt from memory differs from the original in the details nobody notices until the first refusal: no focus trap, the card's language lost, the reason hidden behind "could not".
Proof
A tool is done when it works in a browser on both sides — not when types are green. Green types proved nothing about the translate button: it compiled perfectly and showed a line of text where a window belonged.
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

