Skill implement
scriptsExécute des tâches logicielles telles que des corrections de bugs, des implémentations de fonctionnalités ou des travaux basés sur un plan en utilisant des modes structurés et un guidage par profil.
- Étoiles GitHub
- 155
- Fichiers
- 66
- Dernier commit
- 10 nov. 2026
- Licence
- —
- Outils autorisés
- —
Que fait la skill implement ?
Exécute des tâches logicielles telles que des corrections de bugs, des implémentations de fonctionnalités ou des travaux basés sur un plan en utilisant des modes structurés et un guidage par profil.
Résumé généré à partir du SKILL.md de la skill.
À propos du skill implement
Les développeurs souhaitant automatiser des tâches d'ingénierie logicielle, comme la correction de bugs, l'implémentation de fonctionnalités ou l'exécution de plans structurés, peuvent utiliser cette SKILL pour gérer des workflows de codage complexes. Elle fonctionne en détectant des profils de projet spécifiques et en chargeant les directives pertinentes avant toute écriture ou investigation de code. La SKILL opère via deux modes distincts : le mode plan pour travailler à partir de documents de fonctionnalités ou de listes de tâches, et le mode autonome pour les modifications ponctuelles comme les issues GitHub ou des corrections de bugs spécifiques.
Pour garantir une haute qualité, la SKILL suit une séquence stricte de chargement de protocoles partagés, de détection de profils et d'établissement d'un contexte de modification. Elle s'appuie sur des outils spécifiques tels que /kk:test pour la vérification et /kk:review-code pour les contrôles de qualité. Afin de lutter contre le biais d'auteur, elle utilise un mode de revue isolé qui génère un sous-agent indépendant pour évaluer l'implémentation. Cette approche structurée garantit que les dépendances sont gérées via /kk:dependency-handling et que tout le travail est vérifié par rapport aux résultats attendus et aux contrats préservés.
Ce qu'un agent peut faire avec
- 1Corriger un bug spécifiqueUn développeur peut assigner une correction de bug autonome ou une issue GitHub pour que l'agent la résolve.
- 2Effectuer des revues de code isoléesLa SKILL peut générer un agent indépendant pour réviser le code sans le biais de l'auteur original.
- 3Gérer de nouvelles dépendances logiciellesLorsqu'une tâche introduit une nouvelle API Kubernetes ou un chart Helm, la SKILL applique une gestion spécialisée.
Rédigé à partir du SKILL.md du skill. Chaque cas d'utilisation est vérifié par rapport à une citation de celui-ci.
Comment installer la skill implement
Chaque commande copie le dossier de la skill dans le répertoire des skills du client. Redémarrez le client ou démarrez une nouvelle session pour la charger.Installer la skill implement dans Plugin
/plugin marketplace add serpro69/claude-toolbox /plugin install kk@claude-toolbox
Installer la skill implement dans Claude Code
~/.claude/skills/implement/SKILL.md
$ npx degit serpro69/claude-toolbox/klaude-plugin/skills/implement ~/.claude/skills/implementInstaller la skill implement dans Claude Code (project)
.claude/skills/implement/SKILL.md
$ npx degit serpro69/claude-toolbox/klaude-plugin/skills/implement .claude/skills/implementInstaller la skill implement dans Codex
~/.agents/skills/implement/SKILL.md
$ npx degit serpro69/claude-toolbox/klaude-plugin/skills/implement ~/.agents/skills/implementInstaller la skill implement dans Gemini CLI
~/.gemini/skills/implement/SKILL.md
$ npx degit serpro69/claude-toolbox/klaude-plugin/skills/implement ~/.gemini/skills/implementInstaller la skill implement dans Claude.ai
npx degit serpro69/claude-toolbox/klaude-plugin/skills/implement implement && zip -r implement.zip implement # claude.ai → Customize → Skills → + → Create skill → Upload a skill → implement.zip
Vérifications automatisées
Exécuté le 14 nov. 2026Rapport complet →Pas encore vérifiée. Une skill doit obtenir 80, sans constat grave, avec assez de données pour être vérifiée. Fonctionnement des vérifications · Ce qu'il faut corriger pour gagner des points
- Dépôt source lié et accessibleserpro69/claude-toolbox/klaude-plugin/skills/implement is public and reachablegithub.com/serpro69/claude-toolbox/tree/HEAD/klaude-plugin/s ↗Réussi
- Licence open source (OSI)No licenseFaille
- Commit ou version publiée au cours de l'année écouléeLast commit 2026-11-10github.com/serpro69/claude-toolbox/commits ↗Réussi
- Aucun téléchargement-exécution ni vol d'identifiants dans les scripts5 of 13 scripts read; none of them downloads and runs code, the rest were not readFaille
- Aucune instruction cachée dans SKILL.mdNo override phrases, safeguard switches, credential requests or hidden charactersgithub.com/serpro69/claude-toolbox/blob/HEAD/klaude-plugin/s ↗Réussi
- Les outils préautorisés sont limitésNo pre-approved tools; the agent asks before using onegithub.com/serpro69/claude-toolbox/blob/HEAD/klaude-plugin/s ↗Réussi
- SKILL.md respecte le format Agent SkillsValid name and description; says when to use it; 135 linesgithub.com/serpro69/claude-toolbox/blob/HEAD/klaude-plugin/s ↗Réussi
SKILL.md
Voir sur GitHubImplementing Work
Start with instruction reads. After this entry point loads, your next tool calls read the three shared protocols below and the selected mode procedure. Do not batch them with repository searches or source/document reads. Reading only this SKILL.md does not open investigation. Complete the profile-loading checkpoint before investigation, tests or edits; only the declared bounded predicate routing below may inspect content earlier. A filename-only scope operation is not that checkpoint.
Conventions
- Read capy knowledge base conventions at shared-capy-knowledge-protocol.md.
- Always read change context at shared-change-context.md, including when no profile matches. It defines the factual record used before editing and refreshed for independent review.
- Read profile detection at shared-profile-detection.md. When the sub-task's target files activate a profile that contributes an
implement/subdirectory (e.g.,${TOOLBOX_PLUGIN_ROOT}/profiles/k8s/implement/), itsindex.mdlists per-task gotchas the skill must consult BEFORE writing. See Step 2.
Modes
Two modes, determined automatically: plan mode when the user references a docs/feat/wip feature or task number; standalone mode otherwise (bug fix, GitHub issue, one-off change). When ambiguous, ask.
- Plan mode: Read plan-mode.md for entry, iteration, and completion procedures.
- Standalone mode: Read standalone-mode.md for entry procedure.
Both modes share the same execution core (Step 2 onward) — instruction loading, investigation and change context, implementation, verification, review.
Required Outputs
After each execution + review cycle, verify all outputs:
- Implementation addresses intended outcomes, preserved contracts and hard task/delivery requirements
- Verification/tests pass for the claimed scope; unverified conditions are explicit
- Code review completed (via
/kk:review-code— which owns indexing its ownkk:review-findings) - Refreshed context and evidence supplied to review; findings resolved or permitted follow-up recorded durably
- Code completion distinguished from release/migration/activation conditions
- New project conventions indexed as
kk:project-conventions(skip if none established) - (Plan mode only)
tasks.mdupdated todone
Indexing ownership: Review skills (/kk:review-code, /kk:review-spec) index their own findings. This skill only indexes kk:project-conventions for non-obvious patterns discovered during implementation. Do NOT duplicate review indexing here.
Review Mode
By default, review checkpoints use isolated mode (/kk:review-code:isolated, /kk:review-spec:isolated). This is mandatory because the implementing session has authorship bias — the same model that wrote the code produces weaker reviews of it. Isolated mode spawns an independent sub-agent with no prior exposure to the implementation.
The user can override at any checkpoint ("use standard review for this one") to fall back to in-session /kk:review-code.
Workflow
Mandatory order — instructions before action. The flow below is strictly sequential. Load this skill, the selected mode procedure, shared protocols and every resolved profile instruction before source/requirement investigation, edits (including task-status edits), tests or implementation decisions. Entry procedures collect minimal task/file metadata solely to select scope and profile guidance; they do not analyze requirement prose. After basic instructions load, the sole early-content exception is routing for a declared detection or conditional-load predicate: inspect at most approximately 16 KiB per candidate file, log the predicate/path, and conservatively load an instruction when its conditional is undecidable within that bound. Routing permits no behavioral analysis, full-diff read, findings, edits or tests.
Phases: load basic instructions and scope metadata → detect profiles and load their content → investigate requirements/source and establish change context → implement and verify → refresh evidence and review → assess completion. Detailed investigation has one entry point in Step 2; mode entry procedures do not duplicate it.
The Process
Step 1: Load Instructions and Mode Context
Read the shared protocols in Conventions, determine mode (see §Modes), then read the appropriate mode file and follow its entry procedure:
- Plan mode: Read plan-mode.md — locates the feature documents and selects task/target metadata for routing.
- Standalone mode: Read standalone-mode.md — selects request/target metadata without investigation.
After completing the mode's entry procedure, continue with Step 2.
Scope routing returns filenames/metadata only. For symbol lookup use a filename-only search (Grep with output_mode: files_with_matches, or rg -l), never matching source lines. In plan mode extract only the task headings/status/dependency/target-path fields specified by the mode procedure; do not use a full Read/cat of tasks.md as metadata, even when it is short. If a target is unclear, route a conservative file list rather than investigating it early.
Step 2: Execute
-
Detect and load profiles. Run
shared-profile-detection.mdagainst candidate target filenames and any diff-so-far, however small the task. Read every Known profiles detection rule in a batch before choosing active profiles. Reconcile the set/count of returned rule-file paths against all expected paths, not the set of matching profiles: a nonmatching rule still must be read, never inferred from an extension. Resolve the plugin root from the loaded skill location (parent ofskills/) or the hook-exported root; do not use profile-directory discovery as a substitute for the Known profiles list. For each active profile, read${TOOLBOX_PLUGIN_ROOT}/profiles/<name>/implement/index.md; ENOENT means no implement guidance for that profile. Read every always-load, matching and conservatively selected instruction. An index or requested read alone is not a loaded checklist. The next action after those returns is to emit the checkpoint below, naming returned paths and each conditional decision. No investigation may share a call with these instruction reads or precede that checkpoint. A failed/missing read keeps this gate closed; an empty profile set skips content loading, never detection.Instruction-loading checkpoint: - Shared protocols and selected mode: [returned paths] - Detection rules: [expected and returned paths reconciled] - Active profiles and implement instructions: [returned paths; conditional decisions] - Unread required instructions: [none, or stop and resolve] -
Load applicable dependency instructions. For an introduced/changed dependency — import, version, unfamiliar call, Kubernetes API, CRD, Helm chart/dependency or container image — apply
/kk:dependency-handlingbefore writing the call. Use its lookup cascade and the active profile'soverview.md; do not guess signatures or configuration. Revisit this gate if investigation discovers a dependency change. -
Investigate and establish change context. This is the common investigation entry point for both modes. First load full requirement context: in plan mode read the entire
tasks.md,design.mdandimplementation.md; in standalone mode examine the request and any referenced issue (gh issue view). Search the mode's declared Capy sources for relevant context, even for trivial work. Then read relevant source/current diff, trace affected entry points and unchanged callers through state and response contracts, and reproduce the problem where useful. Apply the shared change-context contract: establish intended outcomes and their authority, preserved behavior, actual scope/baselines and applicable delivery constraints before implementation edits. On resume, compare current repository state with earlier context and supersede stale evidence. If requirement loading or source exploration adds a target or reveals a new profile/conditional, pause that investigation to re-detect and load its guidance before proceeding.Check whether the proposed approach satisfies the requirement and delivery policy. A concrete conflict requires the affected flow, trade-off and smallest viable alternatives before dependent edits; pending future work is no excuse for breaking a current flow. If explicit requirements conflict and no existing accepted decision settles them, record the alternatives as proposals and stop dependent edits until the user resolves the conflict. Do not invent document precedence, label your preferred interpretation an accepted decision, or weaken one requirement merely because the alternative preserves compatibility. Reuse actual accepted decisions and authorization; choices within those requirements create no new approval gate. State a brief approach for non-trivial work. Keep trivial changes proportionate, without irrelevant release gates or duplicate tests.
Check the proposed resolution against a concrete boundary case. For each conflicting condition, compare the outcome it requires with what the alternative would do. If the alternative permits an outcome an explicit condition forbids, it changes that requirement. In particular, replacing an unconditional guarantee/rejection with conditional or best-effort behavior is not merely an interpretation, even when it satisfies another hard requirement. Record that counterexample and wait for an actual user decision before dependent edits; saying the alternative “honors both” or assigning precedence to a document is not authorization.
In plan mode, set the task to
in-progressand record observations under its labeled Execution context, following plan-mode.md. Standalone context remains conversational unless material work must be deferred. -
Implement. Follow the established requirements and plan, if present. An observation or passing test does not authorize rewriting a requirement. Keep task/subtask progress accurate as work completes.
-
Verify outcomes. Invoke
/kk:testand load its resolved instructions before running verification; running a test command alone does not execute that skill's workflow. Use relevant focused checks for intended behavior, preserved contracts and applicable compatibility cases. Record commands, actual results, baselines and limits. Green tests support only the scenarios exercised; they do not prove deployment readiness.
Step 3: Report and Review
-
Refresh the review context. Reconcile current diff scope, candidate state, requirements, baseline identities and verification references against the repository after edits, fixes or resume. Obtain the actual selected Git diff/current state; do not synthesize diff hunks from remembered edits when a command fails. Retry an authorized read directly or report the specific unavailable evidence. Replace stale claims with dated evidence. Include task scope (done/current/pending tasks in plan mode), factual change context, affected paths, attributed test results and explicit unknowns. Do not pass implementation-session history, author conclusions as certification, or a preselected verdict.
-
Review. Invoke
/kk:review-codein isolated mode (or the registered/kk:review-code:isolatedcommand where available) and follow its full instruction-loading workflow. If the harness has no invocation tool, read that skill's entry point and isolated procedure explicitly. Do not replace it with a direct code-reviewer spawn: the isolated workflow owns both independent-agent and PAL paths, resolved criteria and evidence preparation. Supply the refreshed context and evidence to that workflow, which prepares the same relevant source/historical evidence for both reviewers and handles further evidence requests; do not issue a duplicate PAL review. If the user selected standard review, supply the same factual record to/kk:review-code. Missing specification or deployment evidence narrows conclusions; it does not reduce review to code quality alone. -
Resolve and reverify. Apply required corrections, refresh affected context and tests, and obtain review of the changed evidence before finalizing. Index new non-obvious project conventions if any; review skills own their findings indexing.
-
Assess completion. Report requirement coverage, verification and review outcomes, with code completion separate from release, migration or activation conditions. A known unmet hard task/delivery requirement prevents
doneunless explicit user authorization changes it or accepts an exception; record the source, rationale and prerequisites. Unknown evidence essential to acceptance remains open. An external deployment prerequisite may outlive code completion only when consistent with the agreed contract; describe release readiness as conditional or unknown.Record every deferred material action durably with owner (or explicitly unassigned), reason, concrete next action and verification condition: the current task's Execution context in plan mode; existing tracking or a concise repository-local review note in standalone mode. A final-chat caveat alone is insufficient. Only then mark the plan task
doneif the contract and all Required Outputs are satisfied; otherwise keep required work open. Do not continue with incomplete outputs.
Step 4: Continue (plan mode only)
Follow the iteration procedure in plan-mode.md — move to next task, repeat Steps 1–3.
Step 5: Complete (plan mode only)
Follow the completion procedure in plan-mode.md — final validation, documentation, reflection.
When to Stop and Ask for Help
STOP executing immediately when:
- An external blocker cannot be resolved within the authorized scope
- (Plan mode) Plan has critical gaps preventing starting
- You don't understand a requirement or instruction is ambiguous
- Verification fails repeatedly
Ask for the missing decision or capability rather than inventing a requirement. Continue independent authorized work while dependent work waits; ordinary fixable test failures should be corrected and reverified.
When to Revisit Earlier Steps
Return to Step 1 when:
- Partner updates the plan or clarifies the problem
- Fundamental approach needs rethinking
IMPORTANT! Don't force through blockers — stop and ask.
Remember
- Review plan critically first
- Follow the agreed plan; record explicit authorization for any requirement change
- Don't skip verifications
- Use skills when applicable (
/kk:dependency-handling,/kk:test,/kk:review-code:isolated) (Plan mode: also when the plan says to do so) - Between batches: just report and wait
- Stop when blocked, don't guess
Fichiers de cette skill
66Questions sur la skill implement
Comment installer la skill implement dans Claude Code ?
Exécutez npx degit serpro69/claude-toolbox/klaude-plugin/skills/implement ~/.claude/skills/implement. Claude Code charge les skills depuis ~/.claude/skills (tous les projets) ou .claude/skills (un seul projet) et utilise une skill lorsque sa description correspond à la tâche.
Quels clients peuvent utiliser la skill implement ?
Tout client qui lit le format Agent Skills : Claude Code, Codex, Gemini CLI et claude.ai (envoi sous forme de ZIP). Les scripts de la skill ne s'exécutent que si le client autorise l'exécution de code.
Quels sont les différents modes de la SKILL d'implémentation ?
La SKILL fonctionne selon deux modes : le mode plan, utilisé lors de la référence à un numéro de tâche ou de document (docs/feat/wip), et le mode autonome pour les corrections de bugs, les issues GitHub ou les modifications ponctuelles.
Que doit-on faire avant de commencer l'implémentation ou l'investigation ?
L'agent doit d'abord charger les instructions de base, déterminer le mode, détecter les profils et valider un point de contrôle de chargement des instructions.