Skip to content
Skills Library
Programming · Automation

fast-commit

/fast-commit

Commit only the changes that belong to the current task - pick the right staged, unstaged and untracked files (or hunks), leave everything else untouched, write a message in the project's format and run a targeted pre-commit check. Use only when the user asks to commit ("commit this task", "commit just my change, not the other files", "write the commit message but don't commit"). Never pushes, amends or rewrites history.

Licence
MIT
Last repository change
27.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 27.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Commit only the changes that belong to the current task - pick the right staged, unstaged and untracked files (or hunks), leave everything else untouched, write a message in the project's format and run a targeted pre-commit check. Use only when the user asks to commit ("commit this task", "commit just my change, not the other files", "write the commit message but don't commit"). Never pushes, amends or rewrites history.

Triggers from the description

commit this taskcommit just my change, not the other fileswrite the commit message but don
Original author description

Commit only the changes that belong to the current task - pick the right staged, unstaged and untracked files (or hunks), leave everything else untouched, write a message in the project's format and run a targeted pre-commit check. Use only when the user asks to commit ("commit this task", "commit just my change, not the other files", "write the commit message but don't commit"). Never pushes, amends or rewrites history.

How it works

  1. Goal
  2. Identify the task's changes
  3. Mixed files
  4. Commit message
  5. Before committing
  6. Safety
  7. Report
  8. Speed limits
  9. Communication
  10. Example requests
Original SKILL.md headings · 130 lines, 922 words
SKILL.md preview
---
name: fast-commit
description: Commit only the changes that belong to the current task - pick the right staged, unstaged and untracked files (or hunks), leave everything else untouched, write a message in the project's format and run a targeted pre-commit check. Use only when the user asks to commit ("commit this task", "commit just my change, not the other files", "write the commit message but don't commit"). Never pushes, amends or rewrites history.
---

# Fast Commit

## Goal

When the user explicitly asks for a commit, identify what "this task" changed, leave unrelated work alone, write a
message that follows the project's rules, run the targeted check and create the commit.

## Identify the task's changes

Prefer the task context of a previous fast skill in this conversation (goal, changed files, checks). Without it, work in
two passes and read contents only for candidates.

Pass 1, names only:

- `git status --short`
- `git diff --name-only`
- `git diff --cached --name-only`
- `git ls-files --others --exclude-standard`

Pass 2, candidates only:

- `git diff -- <candidate>`
- `git diff --cached -- <candidate>`

Decide ownership from the conversation's goal, the files actually edited in this task, the diff itself, related tests
and the project's rules. Include only what you can confirm belongs to the task:

- something already staged but unrelated must come out of the commit;
- unstaged changes that clearly belong to the task may be added;
- untracked files created by this task may be added;
- if ownership is unclear, stop and list the candidates. Never guess.

Never use `git add -A`, `git add .`, `git commit -a` or anything else that sweeps the whole working tree. Stage whole
files by exact path. When the project or user prefers it, `git commit -m "<msg>" -- <paths>` commits exactly those paths
regardless of what else is staged.

## Mixed files

If one file holds both this task's changes and someone else's:

1. stage only this task's hunks (`git add -p` is interactive; prefer applying a filtered patch with
   `git apply --cached` when the host cannot drive interactive prompts);
2. continue only if the split is reliable;
3. otherwise stop, name the file and the conflicting ranges, and let the user sort it out.

Never overwrite, revert, stash, reset or clean the user's unrelated changes.

## Commit message

1. Read the project's `AGENTS.md`, `CLAUDE.md`, `CONTRIBUTING`, commit-msg hooks and the last ~10 commits.
2. Write an outcome-focused subject from the actual diff.
3. Precedence: the user's explicit format and language, then the project's rules and recent style. With no convention,
   use Conventional Commits (`<type>: <summary>`) in the language of the conversation, for example:

   ```text
   fix: keep the top menu open after resize
   feat: show row actions based on container width
   test: add regression test for the review fix
   ```

4. One subject line is usually enough. Add a 1–3 line body only for independent changes or verification limits worth
   recording.
5. Follow the project's policy on trailers (sign-off, issue references, co-author lines). Some projects require them and
   some forbid AI attribution: the project's rule wins over any tool default.
6. If the user asked only for a message, output it and do not commit.

## Before committing

1. Confirm the final staged diff contains only this task.
2. Run `git diff --cached --check`.
3. Run the targeted tests and lint/typecheck for the changed paths. Do not run the full suite or a full build by default.

Reuse earlier results while they still cover the staged diff; rerun only when the staged diff changed coverage, a result
went stale or the risk rose. If a check fails, stop and report; commit anyway only if the user explicitly says so, and
mark the failure in the report.

If `git add`, `git commit` or another git step fails because of the sandbox, permissions, `.git/index.lock` or the
environment:

1. stop; do not retry in a loop or work around the restriction;
2. leave the working tree as it is;
3. print copy-ready commands with exact paths (`git add <paths>`, `git diff --cached --check`, `git commit -m "..."`);
4. state clearly that no commit was created.

## Safety

- **Protected branches:** stop and ask before committing directly to the default branch (`git symbolic-ref
  refs/remotes/origin/HEAD`, usually `main` or `master`), a release branch, or any branch the project marks as
  protected, unless the user already approved committing there.
- Never `git commit --amend`, rebase or otherwise rewrite history.
- Never push, open a pull request or touch external review threads.
- Never bypass hooks (`--no-verify`).
- Stop on merge or rebase conflicts.
- If a hook modifies or creates files, stop, report the new changes and let the user confirm.
- Never `git reset`, `git clean`, a destructive `checkout`/`restore`, or `stash`.

## Report

```text
Commit: <hash> <subject>
Task files: <list>
Excluded (unrelated): <list or none>
Staged automatically: <list or none>
Checks: <what actually ran>
Left uncommitted: <list or none>
```

If nothing can be confirmed as part of the task, explain why and do not create an empty commit. On failure, keep the
working tree, explain the cause and do not bypass hooks or roll anything back.

## Speed limits

Unless the risk truly needs it or the user asks, do not: run the full suite, run a full build or package, create a
worktree, push or do any remote operation, auto-fix hook complaints, or run other heavy workflows. Run independent
checks in parallel.

## Communication

- Follow the user's language and the project's conventions; keep code, commands, paths and identifiers verbatim.
- Before committing, briefly show the files and the message.
- "Committed" never means "all tests pass" unless the full suite actually ran.
- Stop and say so immediately on unclear ownership, a protected branch or a blocking check.

## Example requests

- "Commit this small task, including its unstaged changes."
- "Figure out which changes are mine and commit only those."
- "Write the commit message but don't commit yet."

Versions

The database has no other skills named fast-commit.

Database snapshot: 13.11.2026 · package version 57e3468e604f (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100commit
    Commits the current task's changes locally — stages only owned files, writes the message in the repo's format, lets pre-commit hooks run. Use for /haechi:commit, when a unit of work is done and needs its local commit, or when the user asks to commit.
  • 100workflow-git-commit
    Create one conventional commit from an already-scoped change: stage the named files or hunks, write the message, commit, never push. Use when "commit these files" or "write a commit message". Whole tree to a PR → workflow-release-prep.
  • 100commit
    Analyze staged changes and write a conventional commit message. Use when staged changes are ready to commit or a message needs wording.
  • 100commit-staged
    This skill should be used when user asks to "commit these changes", "write commit message", "stage and commit", "create a commit", "commit staged files", or explicitly invokes "commit-staged".
  • 86commit
    Create a Git commit for the current task. Use when the user asks to commit changes.
  • 100conventional-commit
    Write a Conventional Commits message for the staged changes. Use when the user asks to commit, write a commit message, or summarize staged changes for git.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.