commit

Stage Git changes and create conventional commit messages with preflight checks.

Updated Mar 13, 2026
One-click install
npx skills add https://github.com/kirvin/copilot-cli-essentials --skill commit-kirvin
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: commit
Source: https://github.com/kirvin/copilot-cli-essentials/tree/main/plugins/cpe/skills/commit
Command: npx skills add https://github.com/kirvin/copilot-cli-essentials --skill commit-kirvin

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) components.

What problem does it solve?

This Skill streamlines the process of staging code changes and creating conventional commit messages, ensuring consistency and clarity in your version control history.

Core Features & Use Cases

  • Automated Staging: Intelligently stages modified files based on user intent or defaults to staging all tracked changes.
  • Preflight Checks: Integrates with preflight checks (linters, formatters) to ensure code quality before committing.
  • Conventional Commits: Enforces a structured commit message format (type, scope, subject, body) for better project readability and automated changelog generation.
  • Use Case: After making several bug fixes, you can use this Skill to automatically stage all your changes, run your linters, and generate a commit message like fix(api): resolve authentication bug with a descriptive body.

Quick Start

Use the commit skill to stage all changes and create a conventional commit message.

Frequently Asked Questions about commit

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I stage and commit code changes with conventional commit messages?

To stage and commit code changes, this skill automatically stages modified tracked files and generates conventional commit messages. It executes preflight checks for linters and formatters, then creates structured commits with type, scope, subject, and body for improved version control.

What are conventional commits and why use them for git version control?

Conventional commits enforce a structured git commit message format including type, scope, subject, and body. Using this format improves project readability, ensures consistency across version control history, and enables automated changelog generation.

Can I run linters and formatters automatically before a git commit?

Yes, you can run linters and formatters automatically before a git commit. This skill integrates preflight checks into the staging process, ensuring code quality standards are met before changes are committed to version control.

How do I stage specific files instead of all tracked modified files?

To stage specific files instead of all modified files, specify the target files when invoking the commit skill. It intelligently handles user-specified file staging while defaulting to staging all tracked changes if no files are explicitly indicated.

What is the best way to automate git staging and commit message formatting?

The best way to automate git staging and commit message formatting is using a skill that combines automatic staging of modified files with conventional commit enforcement. This triggers preflight code quality checks and generates structured commit messages automatically.

When should I not use automated conventional commits for version control?

You should not use automated conventional commits when you need manual control over git staging order or custom commit message formatting outside the type, scope, subject, and body structure, as this skill enforces that specific conventional format for all commits.