Best skills for: Git automation
Git automation can drastically speed up your workflow, but it requires smart AI skills that understand branching, commit conventions, and conflict resolution. The most effective skills for this use-case are those that chain multiple Git commands reliably and enforce quality gates before pushing. For instance, a skill that uses agent interaction (like Willy Agent Interaction) can automate routine tasks such as staging, committing, and pushing without manual intervention, while a skill focused on a definition of done (e.g., Definition of Done — Platform) ensures every commit meets your team's standards. The risk with over-automation is creating a messy git history or introducing errors that are hard to revert. Look for skills that run in dry-run mode first, that support interactive confirmation for destructive operations, and that can parse your existing git log to suggest consistent messages. The right choice will boost your team's velocity without sacrificing control over the codebase.
24 skills selected
Skill Creator
Development
A meta-skill that guides the creation of new AI coding skills for your portfolio website. It collects skill details like name, purpose, and trigger phrases, then generates a complete SKILL.md file with instructions and templates. Use this when you need to add a custom skill to your project's skill set.
Git - Version Control
Development
Provides expert guidance for Git version control operations including commits, branches, merging, rebasing, conflict resolution, and Git workflows. Useful when working with Git repositories, version control, or collaborative development.
Browser Automation with agent-browser
Development
CLI tool for browser automation using agent-browser. Enables navigating web pages, filling forms, clicking buttons, taking screenshots, extracting data, and testing web apps. Useful for any task requiring programmatic interaction with a website.
uni CLI - Universal Interface
Development
Universal CLI that wraps 25+ services into a single interface. Supports multi-command execution, natural language queries, saved flows, plugins, configuration, aliases, and history. Use for general uni questions or to orchestrate multiple services without switching tools.
Conventional Git commits
Development
Creates conventional commits explaining why changes were made, using the type(scope): description format. Helps enforce a consistent commit style and automates the process of writing meaningful commit messages, especially when staging and saving changes.
Start a drift session
Development
Record the current git SHA and session metadata (ticket ID, planned work) to `.drift/config.json` to begin tracking how code drifts from plan. Automatically initialises the `.drift/` directory and fetches Jira ticket details for planned work if no text is provided.
GitHub Issue Labeler
Development
Analyze unlabeled GitHub issues and generate label recommendations. Review suggestions in a UI, then submit approved labels in batch via gh CLI. Helps triage large volumes of issues consistently without manual reading.
Structured Code Review
Development
Performs a systematic code review across five quality dimensions: correctness, security, style, architecture, and testing. It parses targets like staged changes, commits, ranges, or PRs, reads the full files, and produces a structured verdict with findings by severity. Best used as a gate before merging, after subagent work, or when a second opinion is needed.
Skill Metadata Synchronization
DevOps
Syncs skill metadata (scope and auto_invoke) to the Auto-invoke sections of AGENTS.md files. Helps keep invocation tables up-to-date after creating or modifying skills, preventing manual maintenance.
Production Bash Scripting
Development
Provides best practices for writing production-quality Bash scripts, enforcing safety flags (set -euo pipefail), modern syntax ([[ ]], $( ), (( ))), and mandatory ShellCheck compliance. Helps prevent silent failures and data corruption by ensuring scripts are robust and maintainable. Use this skill when creating or modifying any .sh file, shell script, or pre-commit hook.
SDD Commit & PR Guidelines
Development
This skill guides the creation of structured commit messages following Conventional Commits and provides a pull request template. It helps maintain consistent project history and clear documentation of changes. Use it when committing code or creating PRs to ensure all changes are properly described.
Pre-commit Quality Workflow
Development
Pre-commit quality workflow that runs tests, linters, formatters, and type checks before creating atomic commits with conventional commit messages. Automatically detects project type (TypeScript/Python), extracts issue references from conversation history, and suggests appropriate commit scopes.
Claude Code Skill Creator
Development
Generates custom Claude Code skills by creating the folder structure and skill.md file. Helps automate repetitive tasks or add custom slash commands with optional helper scripts and API key handling.
Create Pull Request
Development
This skill creates a pull request from the current branch after running code quality checks (lint, typecheck, tests). It analyzes changes, drafts a comprehensive PR description, and creates the PR as a draft. Use it when your changes are ready for review after committing.
Commit code with optional checking
Development
Analyzes current changes, optionally runs checks (lint, build, test) before committing. Creates a new feature branch if on main, stages relevant files, and writes a conventional commit message. Useful when you want to ensure code quality before committing or need to quickly commit changes to a new branch.
Git Commit Guidelines
Development
Git commit guidelines adhering to Conventional Commits with allowed types (feat, fix, refactor, etc.) and `<type>: <lowercase imperative description>` format. Helps structure commit messages, review staged and unstaged changes for logical splitting into separate commits, and decide between creating a new commit or amending the previous one.
Workflow Creator
Development
Creates multi-agent orchestration workflows for complex tasks requiring coordination across multiple agents and phases. Suitable for automating enterprise processes, operational procedures, and custom orchestration patterns. Ensures workflows are properly registered in the router configuration and agent archetype references.
PR Description Generator
Development
Generates thorough pull request descriptions by analyzing git diffs, commit history, and related files. Helps when creating or updating PRs, especially to produce reviewer-friendly summaries, change lists, and testing notes.
Code Review Orchestrator
Development
Orchestrates specialized subagents to perform a comprehensive code review and produce a markdown report. Works in PR mode (with --pr) or on the current branch, analyzing changes and invoking reviewers for Go, architecture, conventions, Bubble Tea, and documentation.
Convert Tasks to GitHub Issues
Development
Converts tasks from a tasks.md file into GitHub issues with labels and dependencies. Helps when exporting work items to GitHub, setting up project boards, or assigning tasks to team members.
Claude Code Skill Creator
Development
This skill helps create, edit, and manage Claude Code skills, including designing skill structures, writing SKILL.md files, organizing supporting files, and setting up automation hooks. It assists when building custom automation workflows or converting sub-agents to the skill format.
Checkout Git Branch with Conventional Naming
Development
Creates and checks out a new git branch with conventional naming (type/description). Use it to start working on a feature, fix, or task while following naming conventions.
Complete GitHub Integration
Development
This skill provides complete GitHub API integration for managing repositories, issues, pull requests, Actions workflows, and security alerts. It helps automate Git workflows directly from the AI coding assistant. Use it when you need to interact with GitHub programmatically without switching contexts.
Formatted conventional commit
Development
Creates Git commits following the conventional commits specification, using proper types (feat, fix, refactor, etc.) and formatting the message with an optional scope and body. Helps maintain a clear and standardized commit history across a project.
How to choose
- How are these skills selected?
- Each skill is curated and verified by the Skills Guides editorial team. We run a security and quality review on every entry, so only verified skills appear in this selection.
- What do the security ratings mean?
- We label skills Safe, Caution or Risky based on our security analysis — checking for prompt-injection risks, requested permissions and other red flags. The rating gives you an at-a-glance sense of how much trust a skill warrants.
- How do I install a skill?
- Open any skill page and follow its install instructions for your tool — Claude Code, Cursor or Copilot. Each skill lists the exact steps so you can get it running in a couple of minutes.