Skip to content
Skills Library
Programming · Automation

akm-commit

/akm-commit

Commit after each logical step of AKM work. Use when finishing a logical step (a status change or a Next checkpoint) in a repository where git_commits is true.

Repository
akmctl ↗
Licence
MIT
Last repository change
09.11.2026

Assessment and security

90/ 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.
Content25 / 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 09.11.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 after each logical step of AKM work. Use when finishing a logical step (a status change or a Next checkpoint) in a repository where git_commits is true.

Original author description

Commit after each logical step of AKM work. Use when finishing a logical step (a status change or a Next checkpoint) in a repository where git_commits is true.

How it works

  1. First step: is it on, and is this a git repository?
  2. When to commit
  3. How
  4. Check
  5. Never
Original SKILL.md headings · 38 lines, 481 words
SKILL.md preview
---
name: akm-commit
description: Commit after each logical step of AKM work. Use when finishing a logical step (a status change or a Next checkpoint) in a repository where git_commits is true.
---

# AKM commits

The repository's `AGENTS.md` wins over this skill where they disagree.

## First step: is it on, and is this a git repository?

1. Read `git_commits` from `docs/.layout`: `akmctl config git-commits`, or without the tool `grep '^git_commits: true' docs/.layout`. If it is not `true`, STOP: do not commit. The maintainer commits.
2. Check `git rev-parse --is-inside-work-tree` prints `true`. If it does not, STOP: do not commit and do not run `git init` yourself. Tell the maintainer this is not a git repository, so commits are off; offer to run `git init` and then `akmctl config git-commits on` if they want that, or `akmctl config git-commits off` to turn the option off and remove this skill.

## When to commit

One commit per logical step:

- a status change: claim, block, unblock, close;
- each `## Next` checkpoint (the work is in a state a cold agent could resume from).

`## Log` lines do not get a commit of their own: batch them into the next commit.

## How

1. Run `akmctl check`; fix errors first.
2. Stage ONLY by path: the work item, the roadmap, the ADR index and the code files this step changed. Never `git add -A` or `git add .`.
3. Leave unrelated dirty files alone: do not stage, stash, revert or commit them.
4. Message: for a status change, use the `commit.message` the command returned, as given: `<id>(<step>): <detail>`, a blank line, then the trailers `AKM-Step` and `AKM-Item`. Pass the whole message to one `git commit -F -` (a heredoc on stdin), never one `-m` per line: git reads trailers only from the last paragraph. Stage `commit.paths` and the code the step changed. You may put a body between the subject and the trailers and add other trailers (attribution) directly after them, with no blank line between; do not change the subject or the two `AKM-` trailers. `new`, `claim`, `release`, `close` and a `set` that changes `status` return one (`--format json`, or the block the command prints). For a `## Next` checkpoint, which returns none, write `<id>: <what happened>`.
5. Follow the repository's `AGENTS.md` on attribution lines.

## Check

`akmctl check` is what catches a loop in `parent` or `blocked_by` that was written by hand; run it before each commit (step 1 above), as a git pre-commit hook or in CI.

Before a push, `akmctl commits --range origin/main..HEAD` checks that each step commit's subject, trailers and diff agree (rules CM1 to CM3), checks that the `AKM-` trailers sit in the last paragraph where git reads them (CM5), and flags a commit with no step that changes an item's status or claim (CM4). Fix a failing commit with a new commit; do not rewrite history.

## Never

- Push, tag, amend, rebase or rewrite history.
- Use `--no-verify`. If a hook fails, fix the cause and make a new commit; the failed one did not happen.

Versions

The database has no other skills named akm-commit.

Database snapshot: 13.11.2026 · package version 877be8075398 (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

  • 90akm
    Use the akmctl tool to read and change AKM records (work items, ADRs, roadmap). Use whenever a task touches the work or ADR folders or the roadmap, or the user mentions akmctl.
  • 100git-commit
    Create git commits with conventional commit message analysis, safe staging, and logical grouping. Trigger: when the user asks to commit changes, create a git commit, or mentions /commit.
  • 100dx-step
    Execute the next pending step in implement.md — implement, test, review, commit, update status. Use to go one step at a time ('next step').
  • 100commit
    Create a well-formed git commit for this repository (Conventional Commits, English, no emojis) after running the project checks. Use when the user asks to commit, "haz un commit", "commitea", or after finishing a logical unit of work they want saved.
  • 100commit
    Create a git commit after completing a task. Use this skill after finishing a logical unit of work to commit changes with a detailed conventional commit message. Always confirms with user before applying the commit. Never pushes to remote. Triggers include: "commit this",…
  • 100commit
    How and when to make git commits. Use proactively — commit at topic close (one logical topic = one commit), then pause for the user's review before starting the next topic, UNLESS the user has opted into commit-as-you-go. Also use whenever explicitly committing or saving…

Feedback and reports

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