master-of
Cross-domain entry point for the master-of skill-gate system: use this when a request needs dormant skills from SEVERAL domains at once (e.g. scrape a competitor AND critique its design, review a UI AND its copy) and you'd otherwise have to invoke /design, /research, /dev, /stock, /planning, /pipelines one at a time. Also the entry point for any category that has no gate of its own (one added later via check-skills). Matches across every category and activates the 1-4 skills that fit, from however many domains. For a request that clearly sits in one of the six built-in domains, invoke that single gate instead; for management/status (scanning, classifying, reporting), invoke 'check-skills'.
- License 许可
- MIT
- 最近更新
- 2026-11-02
- Stars
- ★ 3
- Forks
- 0
01 前言 Front Matter
- name
- master-of
- description
- Cross-domain entry point for the master-of skill-gate system: use this when a request needs dormant skills from SEVERAL domains at once (e.g. scrape a competitor AND critique its design, review a UI AND its copy) and you'd otherwise have to invoke /design, /research, /dev, /stock, /planning, /pipelines one at a time. Also the entry point for any category that has no gate of its own (one added later via check-skills). Matches across every category and activates the 1-4 skills that fit, from however many domains. For a request that clearly sits in one of the six built-in domains, invoke that single gate instead; for management/status (scanning, classifying, reporting), invoke 'check-skills'.
- allowed-tools
- Read
02 资源文件 4
- 参考文档.claude-plugin/plugin.json1.7 KB
- 脚本bin/mo.mjs124.1 KB
- 参考文档hooks/hooks.json250 B
- 脚本hooks/session-start.sh1.0 KB
03 SKILL.md 正文
master-of — overview
This plugin bundles:
- Domain gates:
design/dev/research/stock/planning— on-demand activation for a dormant skill in that domain. Each is a thin pointer to the Activation Protocol below. check-skills— the system's own manager. It scans for new/removed skills and plugins (automatically via theSessionStarthook, or on demand), classifies new finds into the right gate (or a new one), and reports the current full breakdown read-only. See./skills/check-skills/SKILL.mdfor everything about how that works — this file doesn't duplicate it.
Activation protocol (shared by every domain gate)
Every domain gate (design/dev/research/stock/planning) delegates its
actual behavior here instead of repeating it — each gate's own SKILL.md is
just a pointer to this section plus its category key and any
category-specific notes.
When to open a gate at all. Two ways in, both fine: the user invokes it
(/design …), or you open it yourself because the user asked for actual
work that clearly belongs to that domain ("이 화면 다듬어줘", "경쟁사
스크래핑해줘"). Don't open one for a question, an explanation, or chat that
merely mentions the topic — opening costs tokens (100-2,800 per gate), so it
has to be a task you're about to do. When in doubt, ask in one line rather
than opening. Once a gate is open:
- Read
~/.claude/masterof/gates/<category>.txt— the pre-rendered index for that one gate (name | 설명 | Read할 경로, one line per entry). NeverRead~/.claude/masterof/registry.jsonto activate a gate.Readpulls the whole file, and registry.json is ~60KB / ~16k tokens — more than 2.5x the entire per-session saving this system buys, spent on a single activation. The gate files carry the same name/description/path the protocol needs, at 100-2,500 tokens each. registry.json is the source of truth for classification (check-skillswrites it); thegates/files are the read path for activation, regenerated from it byscripts/render-report.tson every change. - Also glance at scale — the related pipelines are already in the file.
Judge whether the request is a narrow, specific task (→ stay with the
domain entries) or something project-/workflow-scale ("전체 다 해줘",
"처음부터 끝까지", a whole new design direction, a whole phase cycle) that a
complete pipeline would handle better. Each gate file ends with a
## 관련 파이프라인section listing exactly the pipelines whosedomainis this category, so this costs no extra read. Don't treatdesignandpipelinesas separate lanes the user has to know to pick between; a design-shaped request should surface a fitting pipeline (e.g.paint) as naturally as it surfaces a supporting skill (e.g.better-ui), when the scale calls for it. If both a narrow skill and a pipeline plausibly fit, say so and let the user choose which scale they want, rather than guessing. - Try to match first — don't show anything yet. Compare what the user
actually asked for (the message that triggered this skill, or the task at
hand) against each entry's
description.- One confident match → say so directly ("이 작업엔
<name>을 쓸게요") andReaditspath. No list, no round-trip. - A small confident cluster (2-4 entries that clearly belong together for this one task) → name them directly the same way and proceed.
- Genuinely ambiguous (several entries plausibly fit and none clearly
wins) → check
~/.claude/masterof/preferences.jsonfor this category before asking:{"mode": "always_ask"}→ print the full list (grouped byclusterforplanning, flat for the others) and ask, offering전체/all, numbers, names, or (forplanning) a cluster name.{"mode": "fixed_default", "default": "<name>"}→ use that entry without asking, but say which one and that it's the saved default (so the user can override in the moment if it's wrong for this task).{"mode": "conditional", "rules": [{"when": "<condition, in plain language>", "use": "<name>"}, ...], "fallback": "always_ask" | "<name>"}→ check each rule'swhenagainst the task in order (plain judgment, not string matching); use the first match'suse; if none match, fall back tofallback(either ask, or another fixed default).{"mode": "smart"}→ judge from context yourself and ask only when truly tied.
- If the user explicitly asks something like "뭐 있어" / "다 보여줘" / "전체 목록", always show the full list regardless of preference mode — that's an explicit request to see everything, not an ambiguous match.
- One confident match → say so directly ("이 작업엔
Readonly what got selected — never the whole category "just in case." Bulk-reading every entry in a category on every invocation is exactly the always-on cost this system exists to avoid; a gate that does that is a bug, not a feature. Carry the base directory with it. A gated skill is activated byReading itsSKILL.mddirectly, which — unlike a realSkillinvocation — supplies no "Base directory for this skill" line. Many of these skills ship companion files and refer to them relatively (RECIPES.md,STANDARDS.md,reference/,scripts/…); with no anchor those references are dead ends. So treat the directory containing theSKILL.mdyou just read (the path in the gate index, minus the filename) as that skill's base directory, and resolve every relative path in its body against it. State it once when you activate ("base:…/skills-library/design/animate/") so it's explicit rather than re-derived each time you follow a reference. Reading a skill is not the same as invoking it — three things theSkilltool would have done for you that you now do yourself:$ARGUMENTSis not substituted. Many skills (every GSD skill, for one) say things like "Phase number: $ARGUMENTS". Treat whatever the user gave after the skill's name — or the specific thing they asked for — as that value, and if the skill needs an argument the user didn't supply, ask for it the way the skill itself says to (most say what to do when it's omitted).allowed-toolsin the frontmatter doesn't pre-approve anything. The skill will work; you may just get permission prompts it wouldn't normally trigger. Don't read that as the skill being broken.disable-model-invocation: truein the frontmatter means the author wants it run only when the user explicitly asks for it BY NAME — never on your own judgment. Opening a gate yourself (the auto-open rule) does not lift that: if the best match carries this flag and the user didn't name it, mention it as an option and let them choose; don't activate it. Commands and agents are gated the same way, and the index tags them. Plugins ship more than skills, and every command and agent costs always-on tokens exactly like a skill does, so they're classified into the same gates. An index line starting[커맨드]or[에이전트]is activated differently from a skill:[커맨드]→Readit. The body is the prompt a/name argsinvocation would have run;$ARGUMENTSis the user's request (same rule as above). Follow it as those instructions, base directory rule included.[에이전트]→Readit. The frontmatter'sdescription/tools/modeland the body (its system prompt) are what the harness would have used to register it as asubagent_type. Since it isn't registered, spawn it yourself:Agentwithsubagent_type: "general-purpose",prompt= the body followed by the concrete task,model= the frontmatter's if it names one you can pass, and thetoolsline restated inside the prompt as a constraint ("only use …"). Say once that you're running it this way.- A gated skill that says "spawn
subagent_type: X" where X isn't in the available agent types is not broken: check the current gate's index (then_all.txt) for[에이전트] Xand run it as above. This is the normal path for frameworks whose skills and agents were gated together. It costs oneReadof X's file per spawn on your side — a framework that spawns many agents per workflow pays that each time, which is whycheck-skillsasks before gating a large agent set. Honor[의존: …]notes. An index line can carry[의존: <plugin> <component> — 현재 꺼짐, 없으면 동작 불가]. That means the skill's plugin is disabled, so the MCP server / agents it needs don't exist this session. If it says 없으면 동작 불가, don't activate it — tell the user it can't work right now and what would fix it (claude plugin enable <plugin>, effective next session), and offer the closest working alternative instead. Without that suffix (a partial), activate but say which parts won't run. The status is as of the last render; the session- start hook is the fresh source and will already have said so if it's off.
- A match is a candidate, not an obligation. The index answers "what exists in this domain", which is not the same question as "does this task actually need it". If the best match is only topically adjacent — it shares the subject but not the job (a "how to build X" guide when the task is "decide whether to build X"; a reviewer skill when the task is to gather facts) — say so and skip the Read instead of activating it for form's sake. Reading a 2-3k token skill that doesn't change what you do costs more than the gate ever saved.
- Briefly confirm what's active, then proceed with the actual task.
Scope: one-shot, in-context only. Nothing persists, nothing is written to settings. Re-invoke the gate for the next unrelated task in that domain.
Multi-activation — several skills, and several domains, at once
Activation is not limited to one skill. A real request often needs two or three things working together ("이 화면 리뷰하고 접근성까지 봐줘", "경쟁사 스크래핑해서 그 디자인 분석해줘"), and forcing the user to invoke gates one at a time, serially, is the single most annoying way this system can behave.
Within one domain — step 3 already covers it: a confident cluster of 2-4 entries is named and read together, not one at a time.
Across domains — same idea, one level up:
- If you can name the domains from the request (usually you can — "스크래핑"
→
research, "디자인 분석" →design), read just those gate files. Two gate files is typically 1-2k tokens total, far cheaper than the combined index. - Only when the domain set is genuinely unclear, read
~/.claude/masterof/gates/_all.txt— every category in one file (~6k tokens). It's the cross-domain fallback, not the default. - Then match within the combined set and activate what fits, naming each one
and which domain it came from ("
firecrawl-scrape(research) +better-ui(design) 두 개 붙일게요"). Read only those. - Cap it at ~4 skills. Beyond that the activations start crowding out the
actual task, and it's a sign the request should be split — or that a single
pipelinesentry is the right answer instead of five supporting skills. - The
pipelinessingle-select rule still holds across domains: at most ONE pipeline, and a pipeline generally shouldn't be combined with supporting skills from other domains — it already runs its own end-to-end workflow.
Invoking the root master-of skill directly (/master-of <요청>) is the
explicit cross-domain entry point: it runs exactly this step — match across
every category first, then activate the 1-4 skills that fit, from however
many domains they happen to live in.
Staying activated across a continued task
Don't re-run the full matching step from scratch on every single message. When a new user request comes in while something is already active from this domain:
- Same or clearly continuing task → keep using what's already active, no re-invocation needed. Do a quick silent check whether a different entry in the category would now fit better (the task may have shifted); if so, mention it as a one-line suggestion rather than silently switching.
- A new, different task in the same domain → re-run the matching step fresh (steps 1-4 above); it may land on the same skill or a different one.
- Unrelated to this domain entirely → treat the previous activation as no longer relevant. Don't carry design-gate guidance into an unrelated research question just because it was active earlier in the session.
There's no counter or timeout enforcing this — it's a judgment call made fresh each turn, the same way you'd judge whether any other piece of earlier context is still relevant. A hard "N turns unused → off" rule isn't something a hook can enforce anyway: once a skill's content is in the transcript, no script can make the model stop referencing it. Task-continuity judgment is the only lever that actually works.
Per-category ambiguity preference (~/.claude/masterof/preferences.json)
Implemented — see step 3 above for how each mode is consulted. All six
categories default to {"mode": "always_ask"} (unchanged behavior) until the
user asks to change one. To change a preference: edit that category's entry
in preferences.json directly (no schema migration needed, it's just a flat
per-category object) and confirm the change back to the user in plain terms.
For everything about scanning, classifying new skills, permanent exemptions,
or generating the status report, see check-skills
(./skills/check-skills/SKILL.md) — that skill owns all of it now. For
whole-pipeline skills where the user must pick exactly one workflow rather
than combine several, see pipelines
(./skills/pipelines/SKILL.md) — its Activation Protocol variant is
single-select, not multi-select.
04 同仓库更多 Skills
flutter-preview
Flutter 위젯 인터랙티브 프리뷰 시스템 및 반응형 UI 레이아웃
dart-unit-test
Dart 및 Flutter 단위 테스트 작성 및 코드 커버리지 리포트 생성
web-scraper
웹 브라우징 및 동적 페이지 데이터 크롤링, 텍스트 정제
sprint-planner
GSD 스프린트 백로그 구성, 태스크 분해 및 마일스톤 추적
krx-analyzer
한국 거래소(KRX) 상장 기업 재무제표 및 공시 데이터 분석
git-workflow
Git 브랜치 전략, 커밋 메시지 컨벤션, PR 템플릿 자동화