⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

version unknown

molting

mtdmo@mtdmo⭐ 1 stars· last commit 7mo ago· 0 open issues

Perform the shell reset required when an agent's primary model, provider, or effective prompt language changes. Use when you need to refactor prompts, persona, tool rules, and workflow assumptions into a coherent canonical spec with traceability and evaluation. Also use for broader shell cleanup when the operating layer has become bloated or contradictory.

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐ 1 on GitHubGitHub ↗

New / niche

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

Molting

Molting is the controlled rewrite of an agent shell after its primary model changes.

When the default LLM changes, the shell around it rarely transfers cleanly. Prompts, persona, tool habits, formatting rules, and provider-specific patches were tuned around the previous model. If you swap the brain and keep the shell untouched, regressions often show up as lower discipline, weaker tool use, flatter persona, or inconsistent response language.

This repo packages a practical way to handle that transition.

What Molting Is

Molting is instruction-layer refactoring:

  • reread the current operating materials
  • separate hard rules from soft preferences and stale clutter
  • rewrite a cleaner canonical spec for the new primary model
  • preserve traceability and test the rewrite before adoption

What Molting Is Not

  • retraining or fine-tuning
  • a substitute for fixing broken tools or missing documentation
  • permission to mix shells from different primary models without review
  • a reason to skip evaluation just because the rewrite sounds cleaner

When To Use It

  • the primary model or provider changed
  • an established shell performs worse on a new model family
  • response language, verbosity, or tool discipline drifted after migration
  • the shell accumulated provider-specific patches, duplicated rules, or contradictions
  • you want a portable, inspectable operating spec instead of patch-on-patch prompt edits

What A Good Molt Produces

  • a canonical operating spec for the new primary model
  • a traceability map showing what was preserved, merged, clarified, inferred, or removed
  • a risk review covering constraint erosion, persona drift, and tool confusion
  • a focused evaluation plan before the rewrite is adopted

Repository Contents

PathPurpose
docs/framework.mdHuman-readable explanation of the molting framework and decision model.
docs/checklist.mdStep-by-step checklist for running a disciplined molt.
docs/discussion.mdOpen questions and research directions for the framework.
skill/molting/SKILL.mdPortable skill entrypoint for agent systems that support packaged skills.
skill/molting/references/molting-framework.mdPortable framework reference optimized for in-agent use.
skill/molting/references/molting-prompts.mdStaged prompts for interpret -> classify -> rewrite -> trace -> test.
templates/molting-report-template.mdReport template for documenting a completed molt.
examples/coding-agent-primary-model-transition.mdWorked example of a coding-agent shell migration.

Workflow

  1. Inventory the current shell: prompts, persona files, tool policies, formatting rules, examples, and patches.
  2. Interpret the shell before rewriting: mission, priorities, hard constraints, tone, tool semantics, and contradictions.
  3. Classify material into hard rules, soft rules, heuristics, and legacy clutter.
  4. Rewrite a cleaner canonical spec for the new primary model.
  5. Trace the rewrite back to source material so nothing important is silently weakened.
  6. Evaluate before adoption on the behaviors that actually matter.

Common Use Cases

  • moving a coding agent from one primary model family to another
  • translating an existing shell into a new prompt language because the new model behaves better there
  • cleaning up a long-lived agent whose prompts accreted through patches and emergency workarounds
  • packaging an agent definition so it can survive future model or provider swaps with less drift

Design Principles

  • preserve hard constraints before polishing prose
  • treat prompt language changes as shell changes, not cosmetic rewrites
  • remove stale model-specific hacks instead of carrying them forward by default
  • prefer explicit traceability over elegant but unverifiable simplification
  • adopt a molt only after the new shell actually behaves better or more consistently

Status

This repository is intentionally lightweight and doc-first. The framework is ready to use, the skill is portable, and the surrounding materials are meant to make the concept easy to inspect, apply, and extend in public.

If you want to contribute examples, evaluation rubrics, or sharper migration patterns, start with CONTRIBUTING.md.

License

This project is licensed under the MIT License. Use it, modify it, remix it, and ship it.

// HOW IT'S BUILT

// FILES

2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • skill/molting/SKILL.md2.5 KBupstream ↗
    ---
    name: molting
    description: Perform the shell reset required when an agent's primary model, provider, or effective prompt language changes. Use when you need to refactor prompts, persona, tool rules, and workflow assumptions into a coherent canonical spec with traceability and evaluation. Also use for broader shell cleanup when the operating layer has become bloated or contradictory.
    ---
    
    # Molting
    
    Use this skill when the shell around an agent needs a disciplined rewrite, especially after a primary-model migration.
    
    ## Required Inputs
    
    Gather the real operating materials before rewriting anything:
    
    - system and developer prompts
    - persona or soul files
    - tool definitions and tool-use rules
    - formatting and response-style rules
    - examples that materially anchor behavior
    - memory or workflow docs that change how the agent operates
    - provider-specific patches or stale workarounds
    
    If the shell is large or messy, read `references/molting-framework.md` first.
    
    ## Required Deliverables
    
    A proper molt should produce:
    
    - a current-shell interpretation
    - a classification of rules into hard rules, soft rules, heuristics, and legacy clutter
    - a rewritten canonical operating spec
    - a traceability map
    - a risk review
    - an evaluation plan
    - an adoption recommendation
    
    ## Workflow
    
    1. Gather the current shell exactly as it exists.
    2. Interpret what the agent is actually designed to do.
    3. Classify instructions by importance.
    4. Rewrite a cleaner canonical spec for the new primary model.
    5. Map the rewrite back to the source.
    6. Review molting risks.
    7. Evaluate before adoption.
    
    ## Guardrails
    
    - Do not treat molting as retraining.
    - Do not use molting to hide broken tools or missing documentation.
    - Do not casually mix shells from different primary models without traceability.
    - Do not weaken hard rules just because the rewrite reads better.
    - Do not translate the shell into a new prompt language without reviewing tool semantics, tone, and escalation behavior.
    - Do not silently invent new capabilities.
    
    ## Output Standard
    
    Prefer a reviewable artifact, not a freeform rewrite. The final output should make it easy to answer:
    
    - what stayed
    - what changed
    - what was removed
    - what still needs testing
    
    If you need a human-readable structure, use `../../templates/molting-report-template.md`.
    
    ## Resources
    
    - Read `references/molting-framework.md` for the full doctrine, workflow, and failure modes.
    - Read `references/molting-prompts.md` for staged prompts that support interpret -> classify -> rewrite -> trace -> test.
    
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/mtdmo-molting-skill-molting.md

// REPO STATS

1 stars
0 open issues
Last commit: 7mo ago