Contenu du pack

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

AI Assistant Coding Skills

When to use

• You code with a conversational command-line assistant and your sessions drift into long, unfocused chats that produce large unreviewed diffs
• The assistant keeps losing context mid-task and re-asking questions you already answered
• You want the assistant's help but refuse to let it run commands or edit files without your eyes on each step
• Your prompts are improvised every session, so the same task gets a different quality of help each time
• You need a repeatable way to turn a chat session into a finished, tested change

Workflow

1. Scope the kit (input: how you work with the assistant → output: kit inventory)
   Define the working style before building anything: this kit assumes a conversational command-line assistant — you type, it replies, you stay in the loop every turn. It is built for short sessions, small tasks, and developers who keep their hands on the keyboard. The default kit: session briefing, task scoping, guided implementation, change review, and session handoff. Five skills, no more at first — a kit with twenty skills nobody remembers mid-session is worse than five that become habit.
2. Lock the conversation spine (input: project conventions → output: conversation spine)
   Write the spine every kit skill will draw from: the project's stack and conventions, the assistant's standing rules (ask before running commands, propose diffs before applying, never edit more than one concern per turn), how context is provided (which files to point at, what to paste, what never to paste), and the definition of done for a session. The spine is the single source of truth — every skill in the kit enforces the same rules, so the assistant behaves the same in session one and session fifty.
3. Build the skills in session order (input: conversation spine → output: five working skills)
   Build in the order a real session runs: session briefing first (a short opening prompt that loads the spine, the task, and the relevant files into the conversation), then task scoping (a back-and-forth that narrows the task to one concrete change with acceptance checks, before any code is written), then guided implementation (turn-by-turn: assistant proposes, you approve, one small diff at a time), then change review (a dedicated pass that reads the full diff, hunts for regressions, and checks the acceptance checks), then session handoff (a written summary of what changed, what was decided, and what is left, so the next session starts warm). 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: no skill lets the assistant apply a change the human has not seen; every session starts with a briefing, never with "here is my codebase, fix it"; every implementation turn produces a diff small enough to read in one glance; every session ends with a review pass and a handoff note; and the assistant asks a clarifying question rather than guessing at an ambiguous requirement. A kit that fails any gate goes back to the skill that failed.
5. Compose the session workflow (input: passing kit → output: brief-to-merged sequence)
   Wire the skills into the order a real task runs: briefing loads context, scoping narrows the task, implementation proceeds one approved diff at a time, review checks the whole change, handoff records the outcome. Define the handoffs: scoping's acceptance checks become review's checklist; review's findings become the next session's briefing. The kit is only done when a task can go from vague idea to reviewed change inside this loop without leaving it.
6. Maintain the kit (input: session friction, repeated mistakes → output: updated spine and skills)
   After every few sessions, collect the moments the assistant guessed wrong, re-asked, or overreached — each one is a missing rule in the spine or a missing step in a skill. Update the spine once and let every skill inherit the fix. Retire any prompt that no longer matches how you actually work; a stale briefing teaches the assistant the wrong habits.

Aperçu du modèle

AI Assistant Coding Skills — Kit Template

Build the kit in order: spine first, then briefing, scoping, implementation, review, handoff.

1. Working-style brief

Assistant type: Conversational command-line assistant (human drives, turn by turn) Session length: {short / medium} | Task size: {one small change per session}

2. Conversation spine (single source of truth)

3. Kit inventory

4. Quality gate (every skill must pass)

[ ] No change applied that the human has not seen [ ] Every session starts with a briefing, never a bare "fix it" [ ] Every implementation turn produces a diff readable in one glance

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