Script and automate repetitive tasks and workflows.
Convert an existing project to a Turborepo monorepo. Use when the user wants to set up a monorepo, convert to Turborepo, or restructure a project with multiple apps/packages. Handles moving existing files, configuring workspaces, and preserving Git history.
Understanding viya-app project structure and where to find things. Use when exploring the codebase, finding files, or understanding how the app is organized.
Automatically updates CLAUDE.md and related documentation when new features, configurations, or best practices are discovered during development sessions
Use when you want to pause the semantic search file watcher to stop automatic reindexing
Periodically upgrade npm dependencies and GitHub Actions to keep project current and secure
Scaffold and install codex-ui-kit assets and optional prompts in a repo. Use when adding codex-ui-kit to a project.
Identifies files over 300 lines and decomposes them into smaller modules while preserving functionality exactly. Use when user says "streamline", "decompose files", "refactor large files", or wants to break down oversized source files.
REQUIRED workflow for all code changes. MUST load FIRST before planning or implementing features, bugs, refactoring, tests, PRs. Covers full cycle from exploration to pull request. Skip only for: one-off scripts, explanations outside project context.
Load when user says "archive project", "archive [project-name]", "move to archived". Moves completed projects to 05-archived/ folder for clean project list.
Edit changelog using git commit history. Use when the agent needs to edit the changelog.
Find inline Zod schemas and move them to validations/ directory
Provides patterns for file structure, module boundaries, naming conventions, directory organization, and import/export patterns. Use when organizing code, creating new projects, restructuring codebases, establishing module boundaries, or reviewing project architecture.
Specifies bugs, upgrades, refactors, and behavioral changes as explicit deltas against existing feature specifications, preserving original intent while defining what changes, what remains unchanged, and how correctness is verified.
This skill should be used when improving existing Claude Code skills. Triggers include "improve this skill", "skill feels shallow", "upgrade skill", or when self-evaluating skill quality. Codifies the self-eval -> research -> rewrite -> validate -> artifact pattern.
Maintains parity between development and production environments by validating scripts, proxies, and project structure.
Use when creating CLAUDE.md files or .claude/ directories - detects project type, generates appropriate templates, and scaffolds Claude configuration with commands and hooks
Self-improving meta-skill that learns from user corrections and updates the TARGET PROJECT's skill files. Only runs when user explicitly says "reflect". Commits all skill updates to Git.
Use when organizing messy folders (Downloads, Desktop, Documents), finding duplicate files, cleaning up old files, restructuring project directories, separating work from personal files, or automating file cleanup tasks. Triggers on cluttered folders, file chaos, storage cleanup, or directory restructuring needs.
Safe refactoring of Jupyter notebook code into Python modules
Generate the required feature plan file skeleton and enforce section outputs + Touched YES/NO gates.
Maintains project context through progressive disclosure and enforced documentation. This skill should be used when starting work on a new project to initialize context documentation, or continuously during development to maintain up-to-date project structure and coding conventions. Triggers on project initialization, file modifications, or when the agent needs to understand project architecture.
Write self-documenting code that explains itself through clear structure and naming, add minimal helpful comments to explain large sections of code logic, and avoid comments about changes or fixes that won't be relevant in the future. Use this skill when deciding whether to add comments to code, writing comments for complex logic sections, ensuring code is self-explanatory through good naming, refactoring code to reduce the need for comments, or reviewing existing comments for relevance and clarity. This skill applies when working on any code files where you need to balance code clarity with appropriate documentation.
