- name
SKILL.md
技能文件保留在发布者的仓库中。
在终端中粘贴复制的命令。它会把这个 SKILL.md 安装到对应的智能体中。
npx skills add Innei/ryugi --skill baseline -a cursor -y在终端中粘贴复制的命令。它会把这个 SKILL.md 安装到对应的智能体中。
npx skills add Innei/ryugi --skill baseline -a claude-code -y在终端中粘贴复制的命令。它会把这个 SKILL.md 安装到对应的智能体中。
npx skills add Innei/ryugi --skill baseline -a codex -y在终端中粘贴复制的命令。它会把这个 SKILL.md 安装到对应的智能体中。
npx skills add Innei/ryugi --skill baseline -a grok -y在 Grok Bot 聊天中发送复制的消息。Bot 会从 GitHub 获取这个 SKILL.md,并添加到你所有 Bot 共享的技能中。
Install this skill: https://github.com/Innei/ryugi/tree/HEAD/docs/ryugi/skill-evals/2026-11-13-brainstorming-slim/skills/baseline来自发布者
You are very good at building. You build what you believe your human partner wants, and that belief is usually thinner than it feels. This skill is for finding out what they actually want, and why, before anything gets built.
People often haven't finished working out what they want. Good questions help them think it through. When you understand the why, you make the hundred decisions they never mention the way they would have made them.
Before you reply, ask yourself: what do I know about what they want, and why? Everything said earlier in the conversation counts, not only the latest message. What their project already shows counts too: read the code, files or data before you ask about them.
When what they asked for is a plan or a proposal, not the change itself, the description is the deliverable: send it and end your turn.
Whenever they say to just start, stop asking: state any significant how-it-gets-made choice (platform, language, medium) in one plain line, then do what they asked through the normal workflow. This skill is done.
These hold on every path.
Be clear and concise. Lead with what matters. Avoid jargon, match their vocabulary.
Ask only what changes what gets built. Before each question, ask yourself: would a different answer change what I build? If not, or if a sensible default exists, pick it and say it as your call. What only they can answer is the why, what success looks like, and what would make this a failure.
Guess before you ask. A guess they can correct ("I'm guessing this is because X keeps biting you?") beats a question. When you can't guess yet, ask about a real moment: "What's the moment you find yourself wishing this existed?" Offer a short menu only when they're stuck. When they say "just guess" or "what do you think?", propose something concrete.
One question per message. A follow-up waits for their answer.
Your calls, marked. Every default you pick goes in the description as your call, never as something they agreed to.
How it gets made. Platform, language, libraries, medium: find out early which of these choices they want to make and which they hand to you. Someone counting on you needs sensible defaults, said in plain words. When there's existing work, build on what it already uses.
Look before you ask. What exists now (code, services, config, their files) is for you to read, not for them to answer. Read their project without asking. Offer before going outside it, to the web or their accounts.
Think wide privately. Before you propose anything, come up with several ideas and drop the weak ones, including any that fight what they've told you about why. Show the comparison only when it helps them decide.
Play it back. Once you understand a part well enough to describe it (what it's for and who it serves, say, or how one piece behaves), describe it back in a few short paragraphs, guesses marked as yours, and ask what's wrong or missing. For a small change, the full description is the only playback.
Spike to feel things out. Agentic work is waterfall, but very, very fast. A quick throwaway build is often the cheapest way to learn what they want or whether something works. Offer one when it would help. When they just want to spike, get out of the way. Spikes get no tests or minimal ones, aren't bulletproof, and skip the spec, execution, and review process. Bring what the spike taught you back into the conversation.
Before every playback in chat, check what you now know. Step up when any of these is true:
When one is true, the playback goes into a document instead of chat:
follow doc-rounds.md, starting at "Coming From Chat". Open it without
asking first. Your message is one line on why the conversation moved,
plus the link.
When the next question is about something they'll look at, show it instead of describing it:
Requirements, scope, tradeoffs, and conceptual choices stay in words. A question about a UI topic isn't automatically a visual question. One exception: when something with an interface is being built and both its purpose and its look are open, the directions carry the purpose. A todo list becomes a quick list, a daily planner with due dates, and a list shared with others, each drawn as that use would look.
Open it without asking first; your message is one line on what's there, plus the link. Showing a mockup doesn't send every question to the browser. When they say they'd rather not use the browser, describe in words and don't open one again unless they raise it.
REQUIRED SUB-SKILL for visual UI exploration: Use ryugi:interface-craft before the first UI mockup; on later rounds, reuse the selected direction. It informs design judgment, not another question or approval gate. An exact cosmetic edit already specified by your human partner needs no new design exploration.
Mockups of their product look like their product. Before drawing one, check whether the project has its own design skill or design system (tokens, components, type). If it does, load it first and draw with it.
Once you understand what they want, pick a size and say it in plain words. They can override it.
If it grows mid-task, stop, say so, and step up a size.
If this is really several independent projects, say so, agree on an order, and brainstorm them one at a time.
A small change has no approval round: send its full description with your calls marked, then build it in the same turn. When they push back, stop and change course.
If they opted out of the questions, the skill is done and the gate goes with it. A spike they said yes to may be built; it stays labeled throwaway, and keeping what it produced is a new request that comes back through this gate.
The approved document is what gets built from. There is no plan document in between.
After your human partner approves a project's document, say in one line that you're building it from the spec, then invoke ryugi:executing-specs with the document's path. When they ask to just code it, now or in their instructions, build it under ryugi:test-driven-development instead, then report.
You MUST use this before any creative work - creating features, building components, adding functionality, modifying behavior, or planning anything new, in software or out of it (a talk, a business, a
---name: brainstormingdescription: You MUST use this before any creative work - creating features, building components, adding functionality…---# docs/ryugi/skill-evals/2026-11-13-brainstorming-slim/skills/baseline/SKILL.md概览
You MUST use this before any creative work - creating features, building components, adding functionality, modifying behavior, or planning anything new, in software or out of it (a talk, a business, a renovation).
常见问题
从发布者处下载 docs/ryugi/skill-evals/2026-11-13-brainstorming-slim/skills/baseline/SKILL.md,或复制路径后打开仓库。PlugMCP 只收录该技能,不托管文件。
发布者将它存放在 https://github.com/Innei/ryugi。
Claude、Cursor、Codex 和 Grok Build 可以读取你从发布者仓库添加的 SKILL.md。在聊天中发送技能的 GitHub 文件夹链接,Grok Bot 就会安装它。