make-repeatable
/make-repeatable
Analyze recent work and propose how to make it repeatable. Use when the user says \"make this repeatable\", \"automate this\", \"I want to do this again\", \"turn this into a command\", or discusses creating reusable workflows.
- Author
- mayank-io ↗
- Repository
- mstack ↗
- Licence
- MIT
- Last repository change
- 12.10.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 12.10.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Analyze recent work and propose how to make it repeatable. Use when the user says \"make this repeatable\", \"automate this\", \"I want to do this again\", \"turn this into a command\", or discusses creating reusable workflows.
Triggers from the description
Original author description
Analyze recent work and propose how to make it repeatable. Use when the user says \"make this repeatable\", \"automate this\", \"I want to do this again\", \"turn this into a command\", or discusses creating reusable workflows.
How it works
- When This Skill Applies
- Phase 1: Analysis
- Decision Matrix
- Phase 2: Implementation
- Examples
- Quick Reference: Skill File Location
SKILL.md preview
--- name: make-repeatable description: "Analyze recent work and propose how to make it repeatable. Use when the user says \"make this repeatable\", \"automate this\", \"I want to do this again\", \"turn this into a command\", or discusses creating reusable workflows." --- # Make This Repeatable Analyze the current conversation to identify what work should be made repeatable, then recommend whether to implement it as a **skill** or a **plugin**, and build it upon user approval. ## When This Skill Applies - User says "make this repeatable" - User wants to automate a workflow they just performed - User asks to "turn this into a command" - User says "I'll need to do this again" - Discussions about creating reusable patterns --- ## Phase 1: Analysis ### Step 1: Identify the Repeatable Work Review the conversation history to identify: 1. **What was accomplished** - The end result or goal 2. **Key steps taken** - The sequence of actions 3. **Tools used** - Which Claude Code tools were involved 4. **Inputs required** - What information was needed from the user (these become $ARGUMENTS) 5. **Outputs produced** - Files created, commands run, results generated ### Step 2: Classify the Complexity | Complexity | Characteristics | |------------|-----------------| | **Simple** | Single task, no external tools, just instructions | | **Moderate** | Multi-step workflow, uses standard tools (Read, Edit, Bash) | | **Complex** | Requires external APIs, custom tools, or persistent state | ### Step 3: Evaluate Skill vs Plugin **Recommend a SKILL when:** - The workflow is primarily instructional (guiding Claude's behavior) - No new tools or capabilities are needed - Standard Claude Code tools suffice (Bash, Read, Edit, Grep, etc.) - The pattern is a sequence of prompts/instructions - No external service integration required - No persistent configuration or state needed **Recommend a PLUGIN when:** - New tool capabilities are needed (custom tools) - External API/service integration required (MCP servers) - Hooks are needed (PreToolUse, PostToolUse, Stop) - Multiple related skills should be bundled together - Specialized agents are required - Custom configuration/settings need to be stored - The functionality extends Claude Code itself ### Step 4: Recommend Scope Determine where the skill/plugin should live based on who benefits and what it touches: | Scope | Location | Format | Namespacing | |-------|----------|--------|-------------| | **Project** | `.claude/commands/` in the repo | Single `.md` file per command | Subdirectories → `namespace:command` (e.g., `myteam/deploy.md` → `/myteam:deploy`) | | **User** | `~/.claude/skills/` | `skill-name/SKILL.md` directory | Flat only — no colon namespacing (use hyphen prefixes like `myteam-deploy`) | | **Plugin** | `~/.claude/plugins/` | Plugin manifest + skills | Plugin name is the namespace | **IMPORTANT:** Project-level `.claude/skills/` exists but does NOT support colon-based namespacing via subdirectories. Use `.claude/commands/` for project-scoped commands that need `namespace:name` format. **Recommend PROJECT scope when:** - The skill references project-specific paths, conventions, or file formats - It only makes sense in the context of this repo (e.g., "add status to docs in this project's format") - Other contributors to the repo would benefit from it - Use `.claude/commands/namespace/command.md` for namespaced commands **Recommend USER scope when:** - The skill is a general personal workflow pattern (e.g., "clean up a transcript", "review PR comments") - It works across any project the user works on - It reflects the user's personal preferences or style - Use `~/.claude/skills/skill-name/SKILL.md` (no colon namespacing — use hyphens) **Recommend PLUGIN scope when:** - Already recommending a plugin (from Step 3) — plugins always live in `~/.claude/plugins/` ### Step 5: Present Recommendation Present this format and ask user to confirm or adjust: ```markdown ## Repeatability Analysis ### What You Did [Summary of the work performed in this conversation] ### Key Steps 1. [Step 1] 2. [Step 2] ... ### Inputs Required - [Input 1]: [Description] - [Input 2]: [Description] ### Recommendation: [SKILL / PLUGIN] **Why [Skill/Plugin]:** [2-3 bullet points explaining the choice] ### Scope: [PROJECT / USER / PLUGIN] **Why [scope]:** [1-2 bullet points explaining why this scope fits] **Location:** `[exact path where the file will be created]` ### Proposed Implementation **Name:** `[suggested-name]` **Trigger:** `/[command-name] [arguments]` **What it will do:** [Brief description] --- Ready to build this? (Yes / Adjust name / Change scope / Switch to [skill/plugin]) ``` ## Decision Matrix | Factor | Skill | Plugin | |--------|-------|--------| | Just prompt/instructions | Yes | Overkill | | Needs new tools | No | Yes | | External API integration | No | Yes (MCP) | | Multiple related commands | Consider bundling | Yes | | Needs hooks | No | Yes | | Needs agents | No | Yes | | Needs settings UI | No | Yes | | One-off automation | Yes | No | | Sharable with others | Possible | Better | --- ## Phase 2: Implementation Once the user confirms, proceed to build. ### If Building a SKILL Create at the path determined by the recommended scope: - **Project scope:** `.claude/commands/[namespace]/[command-name].md` (in the repo root) - Supports colon namespacing via subdirectories: `myteam/deploy.md` → `/myteam:deploy` - Format: plain markdown, first line is the description, no YAML frontmatter - Use `$ARGUMENTS` for user-provided arguments - **User scope:** `~/.claude/skills/[skill-name]/SKILL.md` (in the home directory) - Flat directory only — no colon namespacing (use hyphens: `myteam-deploy`) - Format: YAML frontmatter with `name` and `description`, then markdown body ```markdown --- name: [skill-name] description: [One sentence describing when this skill applies. Include trigger phrases like "Use when the user says X, Y, or Z".] --- # [Skill Title] [Brief description of what this skill does] ## When This Skill Applies - [Trigger phrase 1] - [Trigger phrase 2] - [Context when this is useful] ## Inputs This skill accepts arguments: `/[skill-name] [arg1] [arg2]` - **$ARGUMENTS**: [What the arguments represent] Or if specific named inputs: - **arg1**: [Description] - **arg2**: [Description] ## Process ### Step 1: [First Action] [Instructions for Claude] ### Step 2: [Second Action] [Instructions for Claude] ... ## Output Format [What the skill should produce - files, messages, etc.] ## Tools to Use - **[Tool1]**: [When/why to use it] - **[Tool2]**: [When/why to use it] ## Examples ### Example 1 Input: `/[skill-name] example-input` Result: [What happens] ``` **After creating the skill:** 1. Verify the file was created: `ls ~/.claude/skills/[skill-name]/` 2. Tell the user: "Skill created! You can now use `/[skill-name]` or say '[trigger phrase]'" 3. Offer to test it immediately ### If Building a PLUGIN Use the Skill tool to invoke `plugin-dev:create-plugin` with context about what to build: ``` /plugin-dev:create-plugin Context from conversation: - Goal: [What the plugin should accomplish] - Components needed: - Skills: [List skills if any] - Agents: [List agents if any] - Hooks: [List hooks if any] - MCP servers: [List MCP integrations if any] - Key workflows: [The steps identified earlier] - Inputs: [What the user provides] - Outputs: [What gets produced] ``` The plugin-dev:create-plugin skill will handle: 1. Scaffolding the plugin structure 2. Creating the manifest 3. Implementing each component 4. Validating the plugin --- ## Examples ### Skill Examples - "Clean up a YouTube transcript" → Skill (just instructions) - "Create a commit with conventional format" → Skill (Bash + instructions) - "Review PR comments and reply" → Skill (gh CLI + instructions) - "Search Gmail for emails" → Skill (wraps gog CLI) ### Plugin Examples - "Integrate with Gmail" → Plugin (needs MCP server, auth, multiple commands) - "Add code review agents" → Plugin (needs custom agents) - "Prevent certain file edits" → Plugin (needs hooks) - "Bundle my 5 related skills" → Plugin (organization) --- ## Quick Reference: Skill File Location Skills go in: `~/.claude/skills/[skill-name]/SKILL.md` Required frontmatter: ```yaml --- name: skill-name description: Description including trigger phrases --- ``` The description in frontmatter is critical - it tells Claude when to use this skill.
Versions
The database has no other skills named make-repeatable.
Database snapshot: 13.11.2026 · package version 270b1034c3e7 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 90codifying-tasks
Turns recurring work into reusable skills. Use when a task being done now has been done before in this project, when the user says "make this repeatable", "turn this into a skill", "we'll be doing this again", or at the natural end of a multi-step task that will clearly recur.… - 100session-to-skill
Turn a repeated workflow from recent session context into a new plugin skill file. Use when the user says "turn this into a skill", "make this repeatable", "I keep doing this workflow". - 100creating-skills
Creates GitHub Copilot skills with reusable workflows, companion resources, and validation gates. Use when packaging repeatable expertise into a `SKILL.md` folder, deciding what belongs in the skill body versus resources, or producing install-ready skill examples for a team or collection. - 87loop-forge
Turn a one-line description of a repetitive task into a reusable, self-guarding slash command. loop-forge diagnoses the task into one of 5 loop shapes (Batch / Pipeline / Refine / Watch / Explore), interviews for the blanks, and auto-injects two safety devices the user didn't… - 95workflow-skill-creator
Distills a completed user workflow or interaction into a reusable agent skill. Use when the user asks to turn their workflow, interaction, or multi-step process into a skill, or when they say "make this a skill", "create a skill from what we just did", "package this workflow" or… - 100workflow-skill-creator
Distills a completed user workflow or interaction into a reusable agent skill. Use when the user asks to turn their workflow, interaction, or multi-step process into a skill, or when they say "make this a skill", "create a skill from what we just did", "package this workflow" or…