@ericrisco/rsc 0.1.8 → 0.1.10

package/README.md

@@ -11,9 +11,11 @@
 
 # `rsc` — 231 agent skills, one CLI, zero bloat
 
-**A self-recommending skill catalog for Claude Code, Cursor, Codex & Gemini.**
+**A self-recommending skill catalog for 17 coding assistants** — Claude Code,
+Codex, GitHub Copilot, Cursor, Gemini, Windsurf, Cline, Antigravity, Zed and more.
 Describe what you want in plain language. It reads your repo, installs *only* the
-skills that fit — one at a time — and keeps your assistant equipped as you work.
+skills that fit — one at a time — into every assistant you pick, and keeps them
+equipped as you work.
 
 From *"document my company"* to *"ship a FastAPI service"* to *"grow my YouTube
 channel"* — **231 skills across 21 domains**, every one researched against live
@@ -70,9 +72,17 @@ git clone https://github.com/ericrisco/skills.git ~/rsc-skills
 cd ~/rsc-skills && npm install && npm link
 ```
 
-The first run installs the **floor** — `orient` + `rsc-suggest` (always-on) +
-`harness` + `init` — and, in Claude Code, wires a `SessionStart` hook so your
-assistant proposes new skills on its own from then on.
+The first run asks **which assistants** you want — Claude Code, Codex, Copilot,
+Cursor, Gemini, Windsurf, Cline and 11 more (pick any combination) — and installs
+the **floor**:
+`orient` + `rsc-suggest` (always-on) + `harness` + `init`. In Claude Code it
+also wires a `SessionStart` hook so your assistant proposes new skills on its
+own from then on.
+
+Everything stays **in the project**, and the real skill files are written
+**once** to `.rsc/skills/<id>/`. Each assistant you pick gets a lightweight
+symlink back to that shared base — no copy is duplicated across IDEs. (If the
+filesystem can't symlink, it falls back to a real copy automatically.)
 
 ---
 
@@ -102,18 +112,33 @@ Languages:                       ↑↓ move · space toggle · a all · enter c
   ◯ rust
 ```
 
-It auto-detects your IDE and stack, installs only what you chose, then prints the
-exact next steps for **Claude Code / Cursor / Codex / Gemini** — and from there
-keeps proposing the skills a task needs.
+Then it asks **which assistants** to install for — tick as many as you like:
+
+```
+Which assistants do you want to install for?   space toggle · a all · enter confirm
+❯ ◉ Claude Code      (.claude/skills/)   ⟵ detected here
+  ◉ Codex CLI        (AGENTS.md)
+  ◯ GitHub Copilot   (.github/copilot-instructions.md)
+  ◯ Cursor           (.cursor/rules/)
+  ◉ Windsurf         (.windsurf/rules/)
+  ◯ Cline            (.clinerules/)
+  …17 in total — Gemini, Antigravity, Zed, Continue, Roo, Amp, opencode, Jules, Junie, Kiro, Aider
+```
+
+It detects your stack, asks which assistants to install for (the one it found in
+your folder is pre-marked), installs only what you chose, then prints the exact
+next steps for **Claude Code / Codex / Cursor / Gemini / Antigravity** — and from
+there keeps proposing the skills a task needs.
 
 ---
 
 ## The CLI
 
 ```bash
-rsc                                  # plain-language wizard (recommended)
+rsc                                  # plain-language wizard (recommended) — pick skills AND assistants
 rsc add fastapi postgresdb           # install specific skills, by name
 rsc add youtube-api remotion-video   # …grow a channel, edit with Remotion
+rsc add fastapi --target claude,codex   # install into several assistants at once
 rsc install --profile minimal        # the floor: orient + suggest + harness + init
 rsc install --profile core           # floor + the full SDD workflow
 rsc install --profile full           # everything (all 231)
@@ -238,15 +263,33 @@ Each with a `02-DOCS` feedback loop that learns from your own results. `remotion
 
 ## Multi-target
 
-`skills/<name>/` is the source; the installer writes the right format for your
-IDE (auto-detected, or `--target`):
+`skills/<name>/` is the catalog source. On install the real files land **once**
+in the project at `.rsc/skills/<id>/`; each assistant you pick gets a symlink
+(or a converted file) back to that shared base — pick several and nothing is
+duplicated. The wizard asks which ones; `--target a,b` does it non-interactively.
 
-| Target | Destination | Always-on detector |
+| Target | Skill destination (→ `.rsc/skills/<id>/`) | Always-on detector |
 | --- | --- | --- |
-| `claude` | `~/.claude/skills/rsc/<id>/` | SessionStart hook in `settings.json` |
-| `cursor` | `.cursor/rules/<id>.mdc` | always-apply rule |
-| `codex` | `.codex/rsc/<id>/` + `AGENTS.md` | block in `AGENTS.md` |
-| `gemini` | `.gemini/rsc/<id>/` + `GEMINI.md` | block in `GEMINI.md` |
+| `claude` | `.claude/skills/rsc/<id>/` → symlink | SessionStart hook in `.claude/settings.json` |
+| `codex` | `.codex/rsc/<id>/` → symlink | block in `AGENTS.md` |
+| `copilot` | `.github/rsc/<id>/` → symlink | block in `.github/copilot-instructions.md` |
+| `cursor` | `.cursor/rules/<id>.mdc` (converted) | always-apply rule |
+| `gemini` | `.gemini/rsc/<id>/` → symlink | block in `GEMINI.md` |
+| `windsurf` | `.windsurf/rsc/<id>/` → symlink | rule in `.windsurf/rules/rsc-suggest.md` |
+| `cline` | `.clinerules/rsc/<id>/` → symlink | rule in `.clinerules/rsc-suggest.md` |
+| `antigravity` | `.antigravity/rsc/<id>/` → symlink | block in `.antigravity/AGENTS.md` |
+| `zed` | `.zed/rsc/<id>/` → symlink | block in `AGENTS.md` |
+| `continue` | `.continue/rsc/<id>/` → symlink | rule in `.continue/rules/rsc-suggest.md` |
+| `roo` | `.roo/rsc/<id>/` → symlink | rule in `.roo/rules/rsc-suggest.md` |
+| `amp` | `.amp/rsc/<id>/` → symlink | block in `AGENTS.md` |
+| `opencode` | `.opencode/rsc/<id>/` → symlink | block in `AGENTS.md` |
+| `jules` | `.jules/rsc/<id>/` → symlink | block in `AGENTS.md` |
+| `junie` | `.junie/rsc/<id>/` → symlink | block in `.junie/guidelines.md` |
+| `kiro` | `.kiro/rsc/<id>/` → symlink | doc in `.kiro/steering/rsc-suggest.md` |
+| `aider` | `.aider/rsc/<id>/` → symlink | block in `CONVENTIONS.md` |
+
+> `codex`, `zed`, `amp`, `opencode` and `jules` all share the one root
+> `AGENTS.md`; the block is idempotent, so picking several writes it once.
 
 ---
 

package/manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.1.8",
+  "version": "0.1.10",
   "counts": {
     "skills": 231
   },
@@ -3971,7 +3971,7 @@
     },
     {
       "id": "specify",
-      "description": "Use when a feature, change, or product idea is still fuzzy and needs to become a written spec BEFORE any planning or code — turn a one-line intent into a WHAT/WHY specification (problem, goals, users, scope, behaviour, acceptance criteria) with zero implementation detail. Triggers: 'write a spec for…', 'spec this out', 'especifica esta feature', 'I want to add X but haven't thought it through', 'capture requirements for…', 'what should this feature do', 'draft a PRD', 'define the feature before we build', kicking off an SDD feature after the constitution exists, or any moment someone jumps to HOW before WHAT is agreed. Asks ONE focused question at a time only where it cannot infer, then writes 02-DOCS/wiki/sdd/specs/<slug>.md and marks open points to clarify. NOT the technical plan (that's `plan`), NOT the de-risking ambiguity sweep (that's `clarify`), NOT project-wide principles (that's `constitution`).",
+      "description": "Use when a feature, change, or product idea is still fuzzy and needs brainstorming into an APPROVED spec BEFORE any planning or code — the brainstorming front door of SDD. Turns a one-line intent into a WHAT/WHY spec (problem, goals, users, scope, behaviour, acceptance) with zero implementation detail, via one-question-at-a-time dialogue, 2-3 proposed approaches with a recommendation, and a design the user approves before anything gets built. Triggers: 'write a spec for…', 'spec this out', 'brainstorm this feature', 'especifica esta feature', 'I want to add X', 'tengo una idea', 'se me ha ocurrido', '¿y si…?', 'wouldn't it be nice if…', 'let's think this through', 'what should this feature do', 'draft a PRD', or any moment someone jumps to HOW before WHAT is agreed. NOT the technical plan (that's `plan`), NOT the de-risking ambiguity sweep (that's `clarify`), NOT project-wide principles (that's `constitution`).",
       "tags": [
         "sdd",
         "spec",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ericrisco/rsc",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Eric Risco's agent-skills catalog as a granular, self-recommending CLI installer.",
   "type": "module",
   "bin": {
@@ -40,6 +40,7 @@
     "cursor",
     "codex",
     "gemini",
+    "antigravity",
     "cli",
     "skills",
     "ai"

package/scripts/doctor.js

@@ -3,8 +3,8 @@ import { targetPaths } from '../targets/index.js';
 import { readState } from './lib/state.js';
 import { loadManifest } from './lib/manifest.js';
 
-export function doctor({ target, home }) {
-  const paths = targetPaths(target, home);
+export function doctor({ target, home, cwd }) {
+  const paths = targetPaths(target, home, cwd);
   const state = readState(paths.stateFile);
   const manifest = loadManifest();
   const report = {

package/scripts/install-apply.js

@@ -1,36 +1,48 @@
 #!/usr/bin/env node
-import { rmSync, existsSync } from 'node:fs';
+import { rmSync, existsSync, cpSync, mkdirSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { planInstall } from './install-plan.js';
-import { targetPaths, writeSkill, wireHook } from '../targets/index.js';
+import { targetPaths, writeSkill, wireHook, baseDir } from '../targets/index.js';
 import { readState, writeState } from './lib/state.js';
 
 const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
 
-export async function applyInstall({ skillIds, target, home }) {
-  const paths = targetPaths(target, home);
-  const plan = planInstall({ skillIds, target, home });
+// Materialize the real skill files into the project-local base exactly once.
+// Re-installs and other assistants reuse it instead of copying again.
+function ensureBase(id, cwd) {
+  const dest = baseDir(id, cwd);
+  if (!existsSync(dest)) {
+    mkdirSync(dirname(dest), { recursive: true });
+    cpSync(join(ROOT, 'skills', id), dest, { recursive: true });
+  }
+  return dest;
+}
+
+export async function applyInstall({ skillIds, target, home, cwd = process.cwd() }) {
+  const paths = targetPaths(target, home, cwd);
+  const plan = planInstall({ skillIds, target, home, cwd });
   const state = readState(paths.stateFile);
   for (const step of plan) {
     if (step.kind === 'skill') {
-      const files = await writeSkill(target, step.id, join(ROOT, step.from), step.to);
-      state.skills[step.id] = { files };
+      const base = ensureBase(step.id, cwd);
+      const files = await writeSkill(target, step.id, base, step.to);
+      state.skills[step.id] = { files, base };
     } else if (step.kind === 'hook') {
-      await wireHook(target, paths, join(ROOT, 'skills', 'suggest', 'SKILL.md'));
+      await wireHook(target, paths, join(ensureBase('suggest', cwd), 'SKILL.md'));
     }
   }
   writeState(paths.stateFile, state);
   return state;
 }
 
-export function listInstalled({ target, home }) {
-  const paths = targetPaths(target, home);
+export function listInstalled({ target, home, cwd = process.cwd() }) {
+  const paths = targetPaths(target, home, cwd);
   return Object.keys(readState(paths.stateFile).skills);
 }
 
-export async function uninstall({ skillIds, target, home, dryRun }) {
-  const paths = targetPaths(target, home);
+export async function uninstall({ skillIds, target, home, cwd = process.cwd(), dryRun }) {
+  const paths = targetPaths(target, home, cwd);
   const state = readState(paths.stateFile);
   const removed = [];
   for (const id of skillIds) {

package/scripts/install-plan.js

@@ -1,7 +1,7 @@
 import { targetPaths } from '../targets/index.js';
 
-export function planInstall({ skillIds, target, home }) {
-  const t = targetPaths(target, home);
+export function planInstall({ skillIds, target, home, cwd }) {
+  const t = targetPaths(target, home, cwd);
   const plan = [];
   for (const id of skillIds) {
     plan.push({ kind: 'skill', id, from: `skills/${id}`, to: t.skillDir(id) });

package/scripts/rsc.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { loadManifest, skillsForProfile } from './lib/manifest.js';
-import { detectTarget } from '../targets/index.js';
+import { detectTarget, TARGETS } from '../targets/index.js';
 import { detectRepo } from './detect-repo.js';
 import { rank } from './consult.js';
 import { expandRecommends, toOutcomes, hasOutcome } from './lib/recommend.js';
@@ -45,18 +45,26 @@ async function manualSelect() {
   return [...chosen];
 }
 
+// Ask which assistants to install into. The detected one is pre-labelled but
+// nothing is auto-applied — the user always confirms the set (one or many).
+async function selectAgents() {
+  const detected = detectTarget();
+  const items = TARGETS.map((t) => ({
+    id: t.id,
+    label: `${t.label}  (${t.hint})${t.id === detected ? '   ⟵ detected here' : ''}`,
+  }));
+  const chosen = await pickFrom('Which assistants do you want to install for? (space to toggle, a = all)', items);
+  return chosen.length ? chosen : [detected];
+}
+
 // After installing, remind the user how to actually start — per IDE — and that
 // rsc keeps recommending skills as they work. The harness/SDD *init* runs INSIDE
 // the assistant (with the user present), never blindly from this CLI.
-function printNextSteps(target, ids) {
+function printNextSteps(targets, ids) {
   const hasHarness = ids.includes('harness');
   const hasSdd = ids.includes('sdd') || ids.includes('sdd-init');
-  const openLine = {
-    claude: 'Open **Claude Code** in this project folder.',
-    cursor: 'Open **Cursor** in this project folder.',
-    codex: 'Open **Codex CLI** (it reads AGENTS.md) in this project folder.',
-    gemini: 'Open **Gemini CLI** in this project folder.',
-  }[target] || 'Open your assistant in this project folder.';
+  const label = (id) => TARGETS.find((t) => t.id === id)?.label || id;
+  const openLine = `Open this project in: ${targets.map((t) => `**${label(t)}**`).join(' · ')}`;
 
   say('\n────────────────────────────────────────────────────────');
   say('👉 When you start working (these steps happen in your assistant, not here):');
@@ -82,7 +90,7 @@ function printNextSteps(target, ids) {
 async function wizard() {
   const m = loadManifest();
   await banner();
-  say('  the skill catalog for your assistant (Claude Code · Cursor · Codex · Gemini)\n');
+  say('  the skill catalog for your assistant (Claude Code · Codex · Cursor · Gemini · Antigravity)\n');
   const choice = await select('What do you want to do?', [
     { key: 'base', label: 'Base install — the essentials (orient + suggest + harness + init)' },
     { key: 'sdd', label: 'Base + Spec-Driven Development — the specify → plan → implement → ship flow' },
@@ -102,33 +110,50 @@ async function wizard() {
     return;
   }
 
-  const target = detectTarget();
-  say(`\nI'll install ${ids.length} skills into ${target}:`);
+  const targets = await selectAgents();
+  say(`\nI'll install ${ids.length} skills for: ${targets.join(', ')}`);
   say('   ' + ids.join(', '));
+  say('   (real files live once in .rsc/skills/ — each assistant just links to them)');
   if (!(await confirm('Install it?'))) {
     say('No problem. Anytime: npx @ericrisco/rsc');
     return;
   }
-  await applyInstall({ skillIds: ids, target });
-  say(`\n✅ Installed ${ids.length} skills into ${target}.`);
-  printNextSteps(target, ids);
+  for (const target of targets) {
+    await applyInstall({ skillIds: ids, target });
+    say(`   ✅ ${target}`);
+  }
+  say(`\n✅ Installed ${ids.length} skills for ${targets.length} assistant(s).`);
+  printNextSteps(targets, ids);
 }
 
 async function main() {
-  const target = flag('target') || detectTarget();
+  // --target accepts one id or a comma list (e.g. --target claude,codex). No flag → detect.
+  const f = flag('target');
+  const targets = typeof f === 'string'
+    ? f.split(',').map((s) => s.trim()).filter(Boolean)
+    : [detectTarget()];
+  const target = targets[0];
   switch (cmd) {
     case undefined:
       return wizard();
-    case 'add':
-      await applyInstall({ skillIds: [...new Set(['orient', 'suggest', ...argv.slice(1)])], target });
-      return void say(`✅ Installed: ${argv.slice(1).join(', ')}`);
+    case 'add': {
+      // Positional args = skill ids; skip flags and any flag value (the token after a --flag).
+      const requested = [];
+      for (let i = 1; i < argv.length; i++) {
+        if (argv[i].startsWith('--')) { i++; continue; }
+        requested.push(argv[i]);
+      }
+      const ids = [...new Set(['orient', 'suggest', ...requested])];
+      for (const t of targets) await applyInstall({ skillIds: ids, target: t });
+      return void say(`✅ Installed for ${targets.join(', ')}: ${requested.join(', ')}`);
+    }
     case 'install': {
       const profile = flag('profile') || 'minimal';
       const without = argv.filter((a, i) => argv[i - 1] === '--without');
       let ids = skillsForProfile(loadManifest(), profile);
       ids = [...new Set(['orient', 'suggest', ...ids])].filter((id) => !without.includes(id));
-      await applyInstall({ skillIds: ids, target });
-      return void say(`✅ Profile '${profile}' installed into ${target} (${ids.length} skills)`);
+      for (const t of targets) await applyInstall({ skillIds: ids, target: t });
+      return void say(`✅ Profile '${profile}' installed for ${targets.join(', ')} (${ids.length} skills)`);
     }
     case 'consult': {
       const ids = await recommendIds(argv.slice(1).join(' '));

package/skills/specify/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: specify
-description: "Use when a feature, change, or product idea is still fuzzy and needs to become a written spec BEFORE any planning or code — turn a one-line intent into a WHAT/WHY specification (problem, goals, users, scope, behaviour, acceptance criteria) with zero implementation detail. Triggers: 'write a spec for…', 'spec this out', 'especifica esta feature', 'I want to add X but haven't thought it through', 'capture requirements for…', 'what should this feature do', 'draft a PRD', 'define the feature before we build', kicking off an SDD feature after the constitution exists, or any moment someone jumps to HOW before WHAT is agreed. Asks ONE focused question at a time only where it cannot infer, then writes 02-DOCS/wiki/sdd/specs/<slug>.md and marks open points to clarify. NOT the technical plan (that's `plan`), NOT the de-risking ambiguity sweep (that's `clarify`), NOT project-wide principles (that's `constitution`)."
+description: "Use when a feature, change, or product idea is still fuzzy and needs brainstorming into an APPROVED spec BEFORE any planning or code — the brainstorming front door of SDD. Turns a one-line intent into a WHAT/WHY spec (problem, goals, users, scope, behaviour, acceptance) with zero implementation detail, via one-question-at-a-time dialogue, 2-3 proposed approaches with a recommendation, and a design the user approves before anything gets built. Triggers: 'write a spec for…', 'spec this out', 'brainstorm this feature', 'especifica esta feature', 'I want to add X', 'tengo una idea', 'se me ha ocurrido', '¿y si…?', 'wouldn't it be nice if…', 'let's think this through', 'what should this feature do', 'draft a PRD', or any moment someone jumps to HOW before WHAT is agreed. NOT the technical plan (that's `plan`), NOT the de-risking ambiguity sweep (that's `clarify`), NOT project-wide principles (that's `constitution`)."
 tags: [sdd, spec, requirements]
 recommends: [clarify, plan]
 profiles: [core, full]
@@ -15,12 +15,12 @@ A spec is a contract about behaviour and outcomes, readable by a non-technical s
 
 ## Detect the moment — and hold the gate
 
-The instant the user is **thinking about a new feature or change** — "I want to add…", "can we build…", "it should also…", "wouldn't it be nice if…", "necesito que haga…", "quiero añadir…" — this phase owns it, *even if a stack skill (nextjs/fastapi/flutter…) also fired and is itching to build it*. Catch it here first.
+Fire on the **faintest** sign the user is thinking about a new feature or change — not just "spec this", but any musing: "I want to add…", "can we build…", "it should also…", "wouldn't it be nice if…", "what if we…", "I've been thinking about…", "let's brainstorm…", "tengo una idea", "se me ha ocurrido", "¿y si…?", "estaría guapo que…", "quiero añadir…", "necesito que haga…". This phase owns that moment, *even if a stack skill (nextjs/fastapi/flutter…) also fired and is itching to build it*. Catch it here first — being too eager to brainstorm is cheap; skipping it is expensive.
 
-**The hard gate (non-negotiable for any non-trivial feature):**
-> No feature code gets written until (1) this spec exists and the user has **approved** it, and (2) `plan` has produced a technical plan + task list. If the user tries to jump straight to "just build it", do not. Name the gate in one friendly line, capture the spec, and walk the chain. The only bypass is a genuinely one-line, low-risk change (typo/copy/config) — say so out loud and skip.
+**The hard gate — every feature, including the "obvious" ones:**
+> No implementation starts — not a stack skill, not `plan`-to-code, not "just a quick version" — until the user has **approved a design** (the spec at step 9 below) and `plan` has produced the technical plan + task list. If the user says "just build it", do not; name the gate in one friendly line and run the loop. "Too simple to need a design" is the rationalization that wastes the most work — every feature gets the loop. The only thing that skips it is a literal one-line, zero-risk change (typo/copy/config) — say so out loud and do it.
 
-You are not slowing them down; you are making the intent reviewable *before* code exists, which is cheaper than discovering the misunderstanding in a PR. End every spec by handing to `clarify`/`plan` — never to `implement`.
+You are not slowing them down; you make the intent reviewable *before* code exists, which is far cheaper than discovering the misunderstanding in a PR. End every spec by handing to `clarify`/`plan` — never to `implement`.
 
 ## The one rule that defines this skill
 
@@ -78,16 +78,24 @@ A criterion that needs a human to "decide if it's good enough" is not done yet
 
 ## The pass, end to end
 
+Run these in order. It is a collaborative dialogue, not a form you fill in silence — and **you do not skip to a design dump.** Track the steps with a todo list so none is dropped.
+
 ```text
-1. READ profile + sdd config + constitution + existing specs → set verbosity, inherit principles, avoid dupes
-2. IF risky/architectural, DRAFT proposal first              → alternatives, tradeoffs, risks, rollback
-3. RESTATE the intent in one sentence                        → confirm you understood before drafting
-4. INFER every section you can                               → from constitution, wiki, the intent itself
-5. ASK the gaps that change scope, one at a time             → record each answer, then ask the next
-6. DRAFT 02-DOCS/wiki/sdd/specs/<slug>.md                     → WHAT/WHY only, template sections filled
-7. LIST Points to clarify                                    → open questions + assumptions, the clarify handoff
-8. INDEX it in root CLAUDE.md Knowledge map                   → under the sdd/specs topic
-9. END with result envelope and HAND OFF to clarify           → name the next phase explicitly
+1. EXPLORE context        → profile + sdd config + constitution + existing specs + wiki + recent git
+2. SCOPE check            → if the request is several independent subsystems, DECOMPOSE into sub-specs first,
+                            then brainstorm the FIRST one; each gets its own spec → plan → build cycle
+3. RESTATE in one sentence→ confirm you understood the intent before anything else
+4. ASK, one at a time     → only the gaps that change scope; multiple-choice when you can; wait, record, repeat
+5. PROPOSE 2-3 approaches → distinct directions with honest trade-offs; lead with your recommendation and why
+6. PRESENT the design     → section by section (problem, users, behaviour, acceptance), scaled to complexity;
+                            after EACH section ask "does this look right?" and adjust before moving on
+7. WRITE the spec         → 02-DOCS/wiki/sdd/specs/<slug>.md (WHAT/WHY), index it in CLAUDE.md, commit if a repo
+8. SELF-REVIEW            → scan for TODO/placeholder, contradictions, ambiguity, scope creep; fix inline
+9. USER APPROVES          → ask them to read the written spec and confirm; loop on changes until they approve
+10. HAND OFF              → only now, result envelope → clarify/plan. NEVER to implement.
+```
+
+**The gate is steps 5-9, and it is the point of this skill.** Implementation does not begin — not `plan`-to-code, not a stack skill, not "just a quick version" — until the user has approved the design at step 9. This holds for **every** feature, including ones that feel too small to design; "too simple to spec" is exactly where unexamined assumptions cost the most. The only thing that skips the loop is a literal one-line, zero-risk change (a typo, a copy tweak) — name it as such and do it.
 ```
 
 `<slug>` is a short kebab-case name derived from the feature (e.g. `bulk-csv-import`, `magic-link-login`). If a spec with that slug exists, read it and update rather than overwrite.
@@ -165,6 +173,9 @@ The proposal is allowed to mention options and tradeoffs; the spec that follows
 | Dump 12 questions in one message | One focused question per turn. Infer the rest from the constitution and wiki. |
 | Ask a question you could answer from the constitution | Read it first. Only ask what genuinely changes the spec. |
 | Write "it should work well / be fast / be intuitive" | Not testable. Make it a binary Given/When/Then or move it to Points to clarify. |
+| Skip the whole loop because "this is too simple to design" | That's the rationalization that wastes the most work. Every feature gets the loop; only a literal one-line, zero-risk change skips. |
+| Present one approach as the answer | Offer 2-3 distinct directions with trade-offs and a recommendation; let the user choose before you write the spec. |
+| Hand to `plan`/`implement` before the user approved the written spec | The approval at step 9 is the gate. No design approved → nothing gets built. |
 | Skip non-goals because "it's obvious" | Unsaid scope becomes assumed scope. State what you are *not* doing. |
 | Resolve every ambiguity yourself to look finished | Inventing answers is worse than naming gaps. List them in Points to clarify. |
 | Start designing the solution because it's clearer | Stay on WHAT/WHY. The plan is a later, separate phase. |

package/targets/{codex.js → _md-block.js}

@@ -1,13 +1,17 @@
-import { cpSync, readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
 import { dirname } from 'node:path';
+import { linkOrCopy } from './index.js';
 
+// Shared adapter for every assistant whose "always-on" surface is a plain
+// markdown instructions/rules file (AGENTS.md, copilot-instructions.md, a
+// .windsurf/.roo/.continue rule, …). Skills are symlinked to the shared base;
+// the suggest block is injected between idempotent markers so re-installs and
+// multiple assistants sharing one file never duplicate it.
 const MARK_START = '<!-- rsc-suggest:start -->';
 const MARK_END = '<!-- rsc-suggest:end -->';
 
 export function writeSkill(id, fromDir, toPath) {
-  mkdirSync(dirname(toPath), { recursive: true });
-  cpSync(fromDir, toPath, { recursive: true });
-  return [toPath];
+  return linkOrCopy(fromDir, toPath);
 }
 
 export function wireHook(paths, sourceMd) {

package/targets/claude.js

@@ -1,10 +1,9 @@
-import { cpSync, readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
 import { dirname } from 'node:path';
+import { linkOrCopy } from './index.js';
 
 export function writeSkill(id, fromDir, toPath) {
-  mkdirSync(dirname(toPath), { recursive: true });
-  cpSync(fromDir, toPath, { recursive: true });
-  return [toPath];
+  return linkOrCopy(fromDir, toPath);
 }
 
 export function wireHook(paths) {

package/targets/index.js

@@ -1,55 +1,120 @@
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
+import { existsSync, lstatSync, mkdirSync, rmSync, symlinkSync, cpSync } from 'node:fs';
+import { join, dirname, relative } from 'node:path';
 import { homedir } from 'node:os';
+import * as claudeAdapter from './claude.js';
+import * as cursorAdapter from './cursor.js';
+import * as mdAdapter from './_md-block.js';
 
+// Project-local single source of truth. Real skill files live here exactly once;
+// every assistant gets a lightweight pointer (symlink) back to it — no duplication.
+export function baseDir(id, cwd = process.cwd()) {
+  return join(cwd, '.rsc', 'skills', id);
+}
+
+// Point an assistant's skill folder at the shared base via a relative symlink.
+// Falls back to a real copy when the filesystem rejects symlinks (e.g. Windows
+// without privileges). Idempotent: replaces any existing link/dir at toPath.
+export function linkOrCopy(fromDir, toPath) {
+  mkdirSync(dirname(toPath), { recursive: true });
+  try { lstatSync(toPath); rmSync(toPath, { recursive: true, force: true }); } catch { /* nothing there */ }
+  try {
+    symlinkSync(relative(dirname(toPath), fromDir), toPath, 'dir');
+  } catch {
+    cpSync(fromDir, toPath, { recursive: true });
+  }
+  return [toPath];
+}
+
+// One row per assistant. `root` is where its skill folder lives (relative to the
+// project), `hook` is the file that gets the always-on suggest block, `adapter`
+// picks how skills + hook are written. `skillExt` (cursor only) means each skill
+// is a single converted file, not a linked directory.
+const SPEC = {
+  // JSON-hook + linked skill dirs
+  claude: { root: '.claude/skills/rsc', hook: '.claude/settings.json', adapter: 'claude' },
+  // Converted .mdc rules
+  cursor: { root: '.cursor/rules', hook: '.cursor/rules/rsc-suggest.mdc', adapter: 'cursor', skillExt: '.mdc' },
+  // AGENTS.md family — all read the same root AGENTS.md
+  codex: { root: '.codex/rsc', hook: 'AGENTS.md', adapter: 'md' },
+  opencode: { root: '.opencode/rsc', hook: 'AGENTS.md', adapter: 'md' },
+  amp: { root: '.amp/rsc', hook: 'AGENTS.md', adapter: 'md' },
+  jules: { root: '.jules/rsc', hook: 'AGENTS.md', adapter: 'md' },
+  zed: { root: '.zed/rsc', hook: 'AGENTS.md', adapter: 'md' },
+  // Own markdown instructions/rules file
+  gemini: { root: '.gemini/rsc', hook: 'GEMINI.md', adapter: 'md' },
+  antigravity: { root: '.antigravity/rsc', hook: '.antigravity/AGENTS.md', adapter: 'md' },
+  copilot: { root: '.github/rsc', hook: '.github/copilot-instructions.md', adapter: 'md' },
+  windsurf: { root: '.windsurf/rsc', hook: '.windsurf/rules/rsc-suggest.md', adapter: 'md' },
+  cline: { root: '.clinerules/rsc', hook: '.clinerules/rsc-suggest.md', adapter: 'md' },
+  roo: { root: '.roo/rsc', hook: '.roo/rules/rsc-suggest.md', adapter: 'md' },
+  continue: { root: '.continue/rsc', hook: '.continue/rules/rsc-suggest.md', adapter: 'md' },
+  junie: { root: '.junie/rsc', hook: '.junie/guidelines.md', adapter: 'md' },
+  kiro: { root: '.kiro/rsc', hook: '.kiro/steering/rsc-suggest.md', adapter: 'md' },
+  aider: { root: '.aider/rsc', hook: 'CONVENTIONS.md', adapter: 'md' },
+};
+
+const ADAPTER = { claude: claudeAdapter, cursor: cursorAdapter, md: mdAdapter };
+
+// Wizard multi-select list, in "most famous first" order. label/hint are display
+// only; detectTarget just pre-marks the one found in the folder.
+export const TARGETS = [
+  { id: 'claude', label: 'Claude Code', hint: '.claude/skills/' },
+  { id: 'codex', label: 'Codex CLI', hint: 'AGENTS.md' },
+  { id: 'copilot', label: 'GitHub Copilot', hint: '.github/copilot-instructions.md' },
+  { id: 'cursor', label: 'Cursor', hint: '.cursor/rules/' },
+  { id: 'gemini', label: 'Gemini CLI', hint: 'GEMINI.md' },
+  { id: 'windsurf', label: 'Windsurf', hint: '.windsurf/rules/' },
+  { id: 'cline', label: 'Cline', hint: '.clinerules/' },
+  { id: 'antigravity', label: 'Antigravity', hint: '.antigravity/' },
+  { id: 'zed', label: 'Zed', hint: 'AGENTS.md' },
+  { id: 'continue', label: 'Continue', hint: '.continue/rules/' },
+  { id: 'roo', label: 'Roo Code', hint: '.roo/rules/' },
+  { id: 'amp', label: 'Amp', hint: 'AGENTS.md' },
+  { id: 'opencode', label: 'opencode', hint: 'AGENTS.md' },
+  { id: 'jules', label: 'Jules', hint: 'AGENTS.md' },
+  { id: 'junie', label: 'JetBrains Junie', hint: '.junie/guidelines.md' },
+  { id: 'kiro', label: 'Kiro', hint: '.kiro/steering/' },
+  { id: 'aider', label: 'Aider', hint: 'CONVENTIONS.md' },
+];
+
+// Best-effort default for the wizard's pre-mark. Unique config dirs win; the
+// shared AGENTS.md / GEMINI.md fall through to codex / gemini.
 export function detectTarget(cwd = process.cwd()) {
-  if (existsSync(join(cwd, '.cursor'))) return 'cursor';
-  if (existsSync(join(cwd, '.codex')) || existsSync(join(cwd, 'AGENTS.md'))) return 'codex';
-  if (existsSync(join(cwd, '.gemini')) || existsSync(join(cwd, 'GEMINI.md'))) return 'gemini';
+  const dir = (d) => existsSync(join(cwd, d));
+  if (dir('.cursor')) return 'cursor';
+  if (dir('.windsurf')) return 'windsurf';
+  if (dir('.clinerules')) return 'cline';
+  if (dir('.roo')) return 'roo';
+  if (dir('.continue')) return 'continue';
+  if (dir('.junie')) return 'junie';
+  if (dir('.kiro')) return 'kiro';
+  if (dir('.zed')) return 'zed';
+  if (dir('.opencode')) return 'opencode';
+  if (dir('.amp')) return 'amp';
+  if (dir('.jules')) return 'jules';
+  if (dir('.antigravity')) return 'antigravity';
+  if (existsSync(join(cwd, '.github', 'copilot-instructions.md'))) return 'copilot';
+  if (dir('.codex') || dir('AGENTS.md')) return 'codex';
+  if (dir('.gemini') || dir('GEMINI.md')) return 'gemini';
   return 'claude';
 }
 
 export function targetPaths(target, home = homedir(), cwd = process.cwd()) {
-  switch (target) {
-    case 'claude':
-      return {
-        root: join(home, '.claude', 'skills', 'rsc'),
-        skillDir: (id) => join(home, '.claude', 'skills', 'rsc', id),
-        stateFile: join(home, '.claude', 'skills', 'rsc', '.rsc-state.json'),
-        hookTarget: join(home, '.claude', 'settings.json'),
-      };
-    case 'cursor':
-      return {
-        root: join(cwd, '.cursor', 'rules'),
-        skillDir: (id) => join(cwd, '.cursor', 'rules', `${id}.mdc`),
-        stateFile: join(cwd, '.cursor', 'rules', '.rsc-state.json'),
-        hookTarget: join(cwd, '.cursor', 'rules', 'rsc-suggest.mdc'),
-      };
-    case 'codex':
-      return {
-        root: join(cwd, '.codex', 'rsc'),
-        skillDir: (id) => join(cwd, '.codex', 'rsc', id),
-        stateFile: join(cwd, '.codex', 'rsc', '.rsc-state.json'),
-        hookTarget: join(cwd, 'AGENTS.md'),
-      };
-    case 'gemini':
-      return {
-        root: join(cwd, '.gemini', 'rsc'),
-        skillDir: (id) => join(cwd, '.gemini', 'rsc', id),
-        stateFile: join(cwd, '.gemini', 'rsc', '.rsc-state.json'),
-        hookTarget: join(cwd, 'GEMINI.md'),
-      };
-    default:
-      throw new Error(`unknown target ${target}`);
-  }
+  const s = SPEC[target];
+  if (!s) throw new Error(`unknown target ${target}`);
+  const rootAbs = join(cwd, ...s.root.split('/'));
+  return {
+    root: rootAbs,
+    skillDir: (id) => (s.skillExt ? join(rootAbs, `${id}${s.skillExt}`) : join(rootAbs, id)),
+    stateFile: join(rootAbs, '.rsc-state.json'),
+    hookTarget: join(cwd, ...s.hook.split('/')),
+  };
 }
 
-export async function writeSkill(target, id, fromDir, toPath) {
-  const { writeSkill: w } = await import(`./${target}.js`);
-  return w(id, fromDir, toPath);
+export function writeSkill(target, id, fromDir, toPath) {
+  return ADAPTER[SPEC[target].adapter].writeSkill(id, fromDir, toPath);
 }
 
-export async function wireHook(target, paths, sourceMd) {
-  const { wireHook: w } = await import(`./${target}.js`);
-  return w(paths, sourceMd);
+export function wireHook(target, paths, sourceMd) {
+  return ADAPTER[SPEC[target].adapter].wireHook(paths, sourceMd);
 }

package/targets/gemini.js

@@ -1,29 +0,0 @@
-import { cpSync, readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
-import { dirname } from 'node:path';
-
-const MARK_START = '<!-- rsc-suggest:start -->';
-const MARK_END = '<!-- rsc-suggest:end -->';
-
-export function writeSkill(id, fromDir, toPath) {
-  mkdirSync(dirname(toPath), { recursive: true });
-  cpSync(fromDir, toPath, { recursive: true });
-  return [toPath];
-}
-
-export function wireHook(paths, sourceMd) {
-  const body = stripFrontmatter(readFileSync(sourceMd, 'utf8'));
-  const block = `${MARK_START}\n${body}\n${MARK_END}`;
-  let doc = existsSync(paths.hookTarget) ? readFileSync(paths.hookTarget, 'utf8') : '';
-  if (doc.includes(MARK_START)) {
-    doc = doc.replace(new RegExp(`${MARK_START}[\\s\\S]*?${MARK_END}`), block);
-  } else {
-    doc += `\n\n${block}\n`;
-  }
-  mkdirSync(dirname(paths.hookTarget), { recursive: true });
-  writeFileSync(paths.hookTarget, doc);
-  return [paths.hookTarget];
-}
-
-function stripFrontmatter(md) {
-  return md.replace(/^---\n[\s\S]*?\n---\n?/, '');
-}