# Skill Forge > | - **Type:** Skill - **Install:** `agentstack add skill-elliotjlt-claude-skill-potions-skill-forge` - **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior - **Seller:** [ElliotJLT](https://agentstack.voostack.com/s/elliotjlt) - **Installs:** 0 - **Category:** [AI & ML](https://agentstack.voostack.com/c/ai-and-ml) - **Latest version:** 0.1.0 - **License:** MIT - **Upstream author:** [ElliotJLT](https://github.com/ElliotJLT) - **Source:** https://github.com/ElliotJLT/Claude-Skill-Potions/tree/main/skills/skill-forge ## Install ```sh agentstack add skill-elliotjlt-claude-skill-potions-skill-forge ``` Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent. ## About # Skill Forge Knowledge that stays in one session is wasted. When Claude discovers something non-obvious - a debugging technique, a gotcha, a pattern that works - it should become a skill automatically. Not "maybe document this later" but "forge it now." This is the flywheel that makes the skill library self-improving. ## When To Activate Trigger when: - Claude solves a problem that took multiple attempts - Claude discovers a non-obvious pattern or gotcha - A debugging session reveals something others would hit - User says "we should remember this" or "make this a skill" - Claude catches itself about to make a mistake it's made before - A workaround is found for a tool/library limitation - The solution was counter-intuitive Do NOT trigger for: - Obvious solutions anyone would find - Project-specific knowledge (not generalizable) - Things already covered by existing skills - Minor learnings not worth the overhead ## Instructions ### Step 1: Identify the Insight Capture what was learned: ``` Discovery: [One sentence summary] Context: [What task/problem led to this] Why non-obvious: [Why someone else would miss this] Generalizable: [YES/NO - is this useful beyond this specific case?] ``` If not generalizable, stop - add to breadcrumbs instead, not a skill. ### Step 2: Extract the Pattern Generalize from the specific case: ``` Specific case: [What happened here] General pattern: [The reusable insight] Triggers: [When should future Claude activate this] ``` ### Step 3: Draft the Skill Create the skill structure: ```markdown --- name: [kebab-case-name] description: | [2-3 sentence description that would trigger activation] allowed-tools: | [appropriate tools] --- # [Skill Name] [Why this skill exists - the problem it prevents] ## When To Activate Trigger when: - [Condition 1] - [Condition 2] ## Instructions ### Step 1: [First step] [Instructions] ### Step 2: [Second step] [Instructions] ## NEVER - [Anti-pattern 1] ## ALWAYS - [Required behaviour 1] ## Examples ### Example 1: [Scenario] [Concrete example] What DOESN'T work: - [Failed approach and why] ## Origin Forged from: [Brief description of the session/problem that spawned this] ``` ### Step 4: Write the Skill File Create the skill directory and file: ``` skills/[skill-name]/SKILL.md ``` ### Step 5: Confirm Creation ``` Skill forged: [skill-name] Location: skills/[skill-name]/SKILL.md Trigger: [When it will activate] This skill will now be available in future sessions. ``` ## Quality Checks Before forging, verify: | Check | Requirement | |-------|-------------| | Generalizable | Useful beyond this specific project | | Non-obvious | Not something Claude would naturally do | | Actionable | Clear instructions, not just "be careful" | | Triggered | Clear conditions for when to activate | | Distinct | Not duplicate of existing skill | ## Skill Naming Conventions - Use kebab-case: `cache-invalidation`, not `cacheInvalidation` - Be specific: `async-cleanup` not `async-stuff` - Verb or noun that implies action: `trace-imports`, `validate-env` - Avoid generic names: `helper`, `utils`, `misc` ## NEVER - Forge project-specific knowledge as skills (use breadcrumbs) - Create skills for obvious things - Forge without the `` section (failures teach) - Create duplicate skills - check existing ones first - Forge trivial learnings (overhead not worth it) ## ALWAYS - Include the origin story (what spawned this skill) - Add `` documenting what doesn't work - Make triggers specific and unambiguous - Test that the skill makes sense out of context - Keep skills focused (one insight per skill) ## Examples ### Example 1: Debugging Discovery During debugging, Claude discovers that a React hook was causing infinite re-renders because of object reference comparison. ``` Discovery: useEffect with object dependency causes infinite loops Context: Debugging React component that kept re-rendering Why non-obvious: Object looks the same but reference changes each render Generalizable: YES - common React gotcha Forging skill: react-dependency-check ``` Resulting skill would include: - Triggers: React debugging, infinite loops, useEffect issues - Instructions: Check dependency array for objects/arrays - Failed attempts: "Tried adding object directly to deps - still loops" ### Example 2: API Gotcha Claude discovers that an API returns different formats based on count (single object vs array). ``` Discovery: API returns object for 1 result, array for multiple Context: Parsing API response failed on single-result queries Why non-obvious: Only manifests with exactly one result Generalizable: YES - common API pattern Forging skill: api-response-normalization ``` ### Example 3: Not Worth Forging Claude fixes a typo in a config file. ``` Discovery: Config had typo in key name Generalizable: NO - specific to this project [Not forging - adding to breadcrumbs instead] ``` ## The Flywheel ``` Session 1: Struggle with problem X ↓ Solve it after 30 min ↓ Forge skill "handle-X" ↓ Session 2: Encounter similar problem ↓ skill-gate activates "handle-X" ↓ Solved in 2 min ↓ Time saved: 28 min ↓ Compound over hundreds of sessions ``` ## Integration with Other Skills - **learn-from-this**: Analyzes failures, skill-forge turns them into skills - **retrospective**: Reviews session, skill-forge captures key learnings - **breadcrumbs**: For project-specific notes (not generalizable) - **skill-gate**: Ensures forged skills get activated ## Why This Skill Exists Every session, Claude learns things. Most of that knowledge evaporates when the session ends. Skill-forge captures it. The goal isn't to document everything - it's to capture the non-obvious wins that would otherwise need to be rediscovered. Each forged skill is future time saved. Build the library. Close the loop. Make the system smarter over time. ## Source & license This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code. - **Author:** [ElliotJLT](https://github.com/ElliotJLT) - **Source:** [ElliotJLT/Claude-Skill-Potions](https://github.com/ElliotJLT/Claude-Skill-Potions) - **License:** MIT Install and usage instructions live in the source repository linked above. ## Pricing - **Free** — Free ## Security capabilities Automated source analysis of v0.1.0 — what this tool can access: - **Network access:** no - **Filesystem access:** no - **Shell / process execution:** no - **Environment & secrets:** no - **Dynamic code execution:** no *"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.* ## Versions - **0.1.0** — security scan: passed — Imported from the upstream source. ## Links - Listing page: https://agentstack.voostack.com/l/skill-elliotjlt-claude-skill-potions-skill-forge - Seller: https://agentstack.voostack.com/s/elliotjlt - Browse the marketplace: https://agentstack.voostack.com/browse --- Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.