do-commit

Run quality gates, cleanup, documentation checks, and self-review before committing code.

4|1|Updated Dec 30, 2025
One-click install
npx skills add https://github.com/lushly-dev/afd --skill do-commit
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: do-commit
Source: https://github.com/lushly-dev/afd/tree/main/.claude/skills/do-commit
Command: npx skills add https://github.com/lushly-dev/afd --skill do-commit

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill automates the process of preparing code changes for commit, ensuring code quality, cleaning up unnecessary files, and verifying documentation before finalizing the commit.

Core Features & Use Cases

  • Automated Quality Checks: Runs linters, tests, type checkers, and build processes to catch errors early.
  • Cleanup: Removes temporary files and artifacts that should not be committed.
  • Documentation Verification: Checks for staleness in documentation like CHANGELOG.md and README.md.
  • Self-Review: Scans for common issues like debug statements, commented-out code, and secrets.
  • Use Case: Before merging a new feature, use the full mode to ensure all tests pass, temporary files are removed, documentation is updated, and the code is clean and ready for review.

Quick Start

Run the do-commit skill in quick mode to perform automated checks and commit your changes.

Frequently Asked Questions about do-commit

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

FAQPage Schema
How do I automate code quality checks before a git commit?▼

Automating code quality checks before a git commit involves running linters, tests, and type checkers to catch errors early. This process verifies that code adheres to project standards and ensures changes are production-ready before finalizing the commit.

What is the best way to clean up temporary files before committing code?▼

Cleaning up temporary files before committing code removes artifacts and unnecessary files that should not be included in version control. This ensures the repository stays clean and prevents accidental commits of transient build outputs.

How do I check for stale documentation and debug statements in my code changes?▼

Checking for stale documentation and debug statements involves scanning changes for issues like commented-out code, secrets, and outdated CHANGELOG.md or README.md files. This self-review process ensures documentation is updated and the code is clean before review.

Can I run a quick git commit without the full test and build suite?▼

You can run a quick commit mode to perform automated checks and commit changes without executing the full test and build suite. This provides a faster workflow when you need to finalize minor changes while still maintaining basic quality gates.

How do I generate a commit message after passing code quality gates?▼

Generating a commit message after passing quality gates delegates the message creation to a dedicated write-commits skill. This happens automatically once all temporary files are cleaned, documentation is verified, and self-review checks are complete.

Why should I use a quality gate process for git commits instead of committing directly?▼

Using a quality gate process for git commits prevents errors by running linters, type checkers, and self-review scans before finalizing changes. This ensures code adheres to project standards, catches debug statements, and verifies documentation is not stale.