Skill Package Upgrader
Purpose
This skill guides the AI through the full workflow of upgrading a cluster of related skills into a complete method package. It is a meta-skill: it orchestrates the sequence of actions needed to turn a set of skills into a fully populated, routine-equipped, properly linked method.
When to use
Trigger when the user says any of:
- "upgrade these skills into a method package"
- "create a method from these skills"
- "package these skills into a method"
- "upgrade the skills package" (when referring to a group of skills that should have a method)
- "create routines for this method" (when referring to a method linked to skills)
- Any request that involves taking a group of existing skills and creating/populating a method + routines from them
Core guidance
The Upgrade Workflow (execute in order)
Step 1: Inventory the skills
- Load each named skill using loadSkill (pass exact skill ID and name)
- Load all attached files using loadSkillAsset for each skill
- Read and synthesize the full content of every skill in the cluster
- Confirm the complete list with the user before proceeding
Step 2: Create or identify the method
- Check if a method already exists for this skill cluster (ask the user, or search by name)
- If it exists: use the existing method
- If it doesn't: create it via manage_methods (spawn a method creation card with a clear title, description, and category)
- Wait for the user to confirm the method exists before proceeding
Step 3: Synthesize the method body
- Read all skill content and attached files from Step 1
- Synthesize a comprehensive method document that consolidates the skills' guidance into a workspace convention
- Structure the method using the Authoring Methods from Scratch skill's guidance: purpose, prerequisites, steps, validation, troubleshooting
- The method body should be a workspace-level convention document, not a copy of the skills — it should reframe the skills' behavioral guidance as team standards
- Include: core philosophy, decision frameworks, practical code examples, review checklists, validation criteria
- Hand off to make_method_edit to populate the method body (this applies inline edits to the method document)
- Note: if make_method_edit is not available for local edit, generate the full content and instruct the user to paste it into the method editor
Step 4: Ideate routines
- Scan the skills for recurring, automatable patterns that would benefit from a routine
- For each skill, ask: "What recurring task does this skill govern, and could a routine automate the check or action?"
- Look for patterns like:
- Validation gates (e.g., "when a brief moves to delivery, check the diff against the skill's standards")
- Opportunity scouts (e.g., "when a brief enters refining, propose opportunities related to the skill's domain")
- Compliance checks (e.g., "when code is written, verify it follows the skill's conventions")
- Filter aggressively: only propose routines that are genuinely automatable and add value. Most skills will yield 0-2 routines, not 5.
- Present the ideated routines to the user with: trigger, purpose, and what it does
- Get user confirmation before creating
Step 5: Create the routines
- For each confirmed routine, spawn a routine suggestion card using spawn_thread (kind: routine_suggestion)
- Include in the payload:
- name: short, clear label
- instructions: full markdown body derived from the skill's content, structured as actionable steps
- triggers: the appropriate trigger(s) from the routine trigger enum
- schedules: only if the user named a cadence; otherwise empty array
- Tell the user each routine card has been spawned and they should review and save each one
Step 6: Link skills to the method
- Use manage_methods to link each skill to the method (if not already linked)
- Confirm all skills are linked
Step 7: Summary
- Provide a summary table of everything created: method (with link), routines (with trigger), skills linked
- Note any manual actions the user still needs to take (e.g., pasting method body if inline edit wasn't available)
Key rules
- Always load the full skill content first. Never synthesize a method body or ideate routines from skill titles alone — load the skill and all attached files.
- Filter routines aggressively. Most skills don't need routines. A skill that is purely informational (no recurring check or action) gets zero routines. Say so explicitly.
- One routine per trigger per purpose. Don't create three routines that fire on the same trigger for the same reason — merge them into one.
- The method body is a convention, not a skill copy. Reframe behavioral guidance as team standards. Skills say "always do X." Methods say "our team does X because Y."
- Confirm with the user at each gate. After inventory, after method creation/identification, after routine ideation. Don't batch all steps without checkpoints.
- Never skip the skill loading step. The entire workflow depends on reading the actual skill content. Loading skills is not optional.
Anti-patterns
- Creating a routine for every skill. Most skills don't need routines. If you can't name the specific trigger and the specific automated action, don't create a routine.
- Copying skill content verbatim into the method. The method is a workspace convention, not a skill mirror. Reframe, restructure, and consolidate.
- Creating multiple routines on the same trigger. If two routines fire on the same trigger, merge them into one routine with combined checks.
- Skipping the user confirmation gates. The user must confirm the skill inventory, the routine list, and each routine before creation. Don't auto-create everything.
- Generating routine instructions without reading the skill. Routine instructions must be derived from the actual skill content, not guessed from the skill name.
Concrete example: The Emil Kowalski Design upgrade
This skill was created based on a real upgrade session:
- Skills inventoried:
emil-design-eng, review-animations, improve-animations, find-animation-opportunities, animate, apple-design, animation-vocabulary
- Method created: "Emil Kowalski Design" — workspace convention for UI polish, animation decisions, and component craft
- Method body synthesized: 15-section document covering core philosophy, animation decision framework, component building principles, CSS transform mastery, clip-path animation, spring animations, stagger animations, gesture/drag interactions, performance rules, accessibility, debugging, Sonner principles, review checklist, review format, and validation criteria
- Routines ideated: Two routines identified from the skill cluster:
- Animation Craft Check — trigger:
brief.status_changed.delivering — validates animation code in the diff against the full checklist
- Animation Opportunities Scout — trigger:
brief.status_changed.refining — proposes tasteful animation opportunities where they advance the brief's goal
- Routines created: Both spawned as routine suggestion cards, user reviewed and saved
- Skills linked:
emil-design-eng linked to the method
This is the template for any future skill package upgrade.
1---2name: skill-package-upgrader3description: "Meta-skill that orchestrates upgrading a cluster of related skills into a complete method package: inventories skills, creates/identifies a method, synthesizes the method body, ideates and creates routines, and links skills to the method. Trigger when the user says \\\"upgrade these skills into a method package\\\", \\\"create a method from these skills\\\", \\\"package these skills into a method\\\", \\\"upgrade the skills package\\\", \\\"create routines for this method\\\", or any request involving taking a group of existing skills and creating/populating a method + routines from them."4version: "1.0.0"5category: "Workflows"6metadata:7 source: https://skillmd.com/skills/gethamster/skill-package-upgrader8---910# Skill Package Upgrader1112## Purpose1314This skill guides the AI through the full workflow of upgrading a cluster of related skills into a complete method package. It is a meta-skill: it orchestrates the sequence of actions needed to turn a set of skills into a fully populated, routine-equipped, properly linked method.1516## When to use1718Trigger when the user says any of:1920- "upgrade these skills into a method package"21- "create a method from these skills"22- "package these skills into a method"23- "upgrade the skills package" (when referring to a group of skills that should have a method)24- "create routines for this method" (when referring to a method linked to skills)25- Any request that involves taking a group of existing skills and creating/populating a method + routines from them2627## Core guidance2829### The Upgrade Workflow (execute in order)3031**Step 1: Inventory the skills**3233- Load each named skill using loadSkill (pass exact skill ID and name)34- Load all attached files using loadSkillAsset for each skill35- Read and synthesize the full content of every skill in the cluster36- Confirm the complete list with the user before proceeding3738**Step 2: Create or identify the method**3940- Check if a method already exists for this skill cluster (ask the user, or search by name)41- If it exists: use the existing method42- If it doesn't: create it via manage_methods (spawn a method creation card with a clear title, description, and category)43- Wait for the user to confirm the method exists before proceeding4445**Step 3: Synthesize the method body**4647- Read all skill content and attached files from Step 148- Synthesize a comprehensive method document that consolidates the skills' guidance into a workspace convention49- Structure the method using the Authoring Methods from Scratch skill's guidance: purpose, prerequisites, steps, validation, troubleshooting50- The method body should be a workspace-level convention document, not a copy of the skills — it should reframe the skills' behavioral guidance as team standards51- Include: core philosophy, decision frameworks, practical code examples, review checklists, validation criteria52- Hand off to make_method_edit to populate the method body (this applies inline edits to the method document)53- Note: if make_method_edit is not available for local edit, generate the full content and instruct the user to paste it into the method editor5455**Step 4: Ideate routines**5657- Scan the skills for recurring, automatable patterns that would benefit from a routine58- For each skill, ask: "What recurring task does this skill govern, and could a routine automate the check or action?"59- Look for patterns like:60- Validation gates (e.g., "when a brief moves to delivery, check the diff against the skill's standards")61- Opportunity scouts (e.g., "when a brief enters refining, propose opportunities related to the skill's domain")62- Compliance checks (e.g., "when code is written, verify it follows the skill's conventions")63- Filter aggressively: only propose routines that are genuinely automatable and add value. Most skills will yield 0-2 routines, not 5.64- Present the ideated routines to the user with: trigger, purpose, and what it does65- Get user confirmation before creating6667**Step 5: Create the routines**6869- For each confirmed routine, spawn a routine suggestion card using spawn_thread (kind: routine_suggestion)70- Include in the payload:71- name: short, clear label72- instructions: full markdown body derived from the skill's content, structured as actionable steps73- triggers: the appropriate trigger(s) from the routine trigger enum74- schedules: only if the user named a cadence; otherwise empty array75- Tell the user each routine card has been spawned and they should review and save each one7677**Step 6: Link skills to the method**7879- Use manage_methods to link each skill to the method (if not already linked)80- Confirm all skills are linked8182**Step 7: Summary**8384- Provide a summary table of everything created: method (with link), routines (with trigger), skills linked85- Note any manual actions the user still needs to take (e.g., pasting method body if inline edit wasn't available)8687### Key rules88891. **Always load the full skill content first.** Never synthesize a method body or ideate routines from skill titles alone — load the skill and all attached files.902. **Filter routines aggressively.** Most skills don't need routines. A skill that is purely informational (no recurring check or action) gets zero routines. Say so explicitly.913. **One routine per trigger per purpose.** Don't create three routines that fire on the same trigger for the same reason — merge them into one.924. **The method body is a convention, not a skill copy.** Reframe behavioral guidance as team standards. Skills say "always do X." Methods say "our team does X because Y."935. **Confirm with the user at each gate.** After inventory, after method creation/identification, after routine ideation. Don't batch all steps without checkpoints.946. **Never skip the skill loading step.** The entire workflow depends on reading the actual skill content. Loading skills is not optional.9596### Anti-patterns9798- **Creating a routine for every skill.** Most skills don't need routines. If you can't name the specific trigger and the specific automated action, don't create a routine.99- **Copying skill content verbatim into the method.** The method is a workspace convention, not a skill mirror. Reframe, restructure, and consolidate.100- **Creating multiple routines on the same trigger.** If two routines fire on the same trigger, merge them into one routine with combined checks.101- **Skipping the user confirmation gates.** The user must confirm the skill inventory, the routine list, and each routine before creation. Don't auto-create everything.102- **Generating routine instructions without reading the skill.** Routine instructions must be derived from the actual skill content, not guessed from the skill name.103104### Concrete example: The Emil Kowalski Design upgrade105106This skill was created based on a real upgrade session:1071081. **Skills inventoried:** `emil-design-eng`, `review-animations`, `improve-animations`, `find-animation-opportunities`, `animate`, `apple-design`, `animation-vocabulary`1092. **Method created:** "Emil Kowalski Design" — workspace convention for UI polish, animation decisions, and component craft1103. **Method body synthesized:** 15-section document covering core philosophy, animation decision framework, component building principles, CSS transform mastery, clip-path animation, spring animations, stagger animations, gesture/drag interactions, performance rules, accessibility, debugging, Sonner principles, review checklist, review format, and validation criteria1114. **Routines ideated:** Two routines identified from the skill cluster:112113- **Animation Craft Check** — trigger: `brief.status_changed.delivering` — validates animation code in the diff against the full checklist114- **Animation Opportunities Scout** — trigger: `brief.status_changed.refining` — proposes tasteful animation opportunities where they advance the brief's goal1151165. **Routines created:** Both spawned as routine suggestion cards, user reviewed and saved1176. **Skills linked:** `emil-design-eng` linked to the method118119This is the template for any future skill package upgrade.