Contenu du pack

Un fichier SKILL.md (le guide pratique) + un modèle de départ. Aperçu :

AI Code Editor Skills

When to use

• You work in an editor with AI built in and your completions, chat edits, and manual edits are fighting each other in the same file
• The editor's AI keeps suggesting code that ignores your project's conventions because no rules file tells it otherwise
• You accept multi-file edits without reviewing the diff and discover the damage in the next test run
• Chat answers live in a side panel while the code lives in the file, and the two keep drifting apart
• You want the editor's AI to be a reliable pair programmer, not an autocomplete that occasionally rewrites your architecture

Workflow

1. Scope the kit (input: editor setup, project, habits → output: kit inventory)
   Define the working style before building anything: this kit assumes an AI code editor — the AI lives inside the editor, sees your open files and selections, and edits through diffs you accept or reject in place. It is built for developers who stay in the editor all day and want help right where you type, not in a separate chat window. The default kit: rules file, selection edits, in-editor chat, multi-file changes, and diff review. Five skills, no more at first — a kit with twenty skills nobody configures is worse than five that shape every keystroke.
2. Lock the editor spine (input: project conventions → output: editor spine)
   Write the spine every kit skill will draw from: the project's stack and style rules as the editor's rules file, what the AI may suggest unasked (completions) versus what needs an explicit ask (refactors, multi-file edits), which files and secrets are excluded from AI context, and the acceptance rule for every AI change (review the diff, run the tests, never blind-accept). The spine is the single source of truth — it lives in the rules file the editor reads, not in a document nobody opens.
3. Build the skills in editing order (input: editor spine → output: five working skills)
   Build in the order the work actually flows: rules file first (project conventions, style, and exclusions encoded where the editor's AI reads them on every suggestion), then selection edits (highlight code, ask for a precise change to the selection only, nothing outside it), then in-editor chat (questions and explanations answered against the open files, with answers that reference exact lines), then multi-file changes (a change scoped across files with an explicit file list, a preview of every affected file, and one acceptance decision per file), then diff review (a dedicated pass over every AI-produced diff before it is kept — line by line, in the editor). Each skill gets its own prompt, its own input checklist, and its own output format.
4. Apply the quality bar (input: five draft skills → output: kit that passes every gate)
   Run each skill against the same bar before the kit ships: every AI suggestion follows the rules file — a suggestion that violates a written convention is a kit failure; every selection edit touches only the selection; every multi-file change lists its files before touching any of them; every AI change is reviewed as a diff before acceptance; and no AI output enters the codebase without the tests running. A kit that fails any gate goes back to the skill that failed.
5. Compose the editing workflow (input: passing kit → output: open-file-to-committed sequence)
   Wire the skills into the order a real editing session runs: rules file shapes every suggestion, selection edits handle the small precise changes, in-editor chat answers the questions that need file context, multi-file changes handle the cross-cutting work with per-file acceptance, diff review closes every change. Define the handoffs: chat conclusions that change the code become selection edits or multi-file changes, never pasted-in text; multi-file changes end in diff review, never in blind acceptance. The kit is only done when a feature can go from idea to reviewed, tested diff without leaving the editor.
6. Maintain the kit (input: bad suggestions, accepted-then-reverted edits → output: updated spine and skills)
   Every accepted-then-reverted AI edit is a kit failure with a cause: a missing rule, a selection that was too broad, a multi-file change that touched a file it should not have. Log them and fix the spine — usually by adding one line to the rules file. Retire any prompt or rule that no longer matches the project; a stale rules file teaches the editor's AI the wrong conventions on every keystroke.

Aperçu du modèle

AI Code Editor Skills — Kit Template

Build the kit in order: spine first, then rules file, selection edits, in-editor chat, multi-file changes, diff review.

1. Editor brief

Editor type: AI code editor (AI built in — completions, chat, diffs in place) Session style: {stay in the editor all day, help where you type}

2. Editor spine (single source of truth — mirrored in the rules file)

3. Kit inventory

4. Quality gate (every skill must pass)

[ ] Every AI suggestion follows the rules file [ ] Every selection edit touches only the selection [ ] Every multi-file change lists its files before touching any of them

Le pack de compétence lui-même (SKILL.md + modèle) est rédigé en anglais.

Acheter le pack complet — $4.99 Pro — les 511 compétences