CtrlK
BlogDocsLog inGet started
Tessl Logo
SkillPublic

git-workflow-and-versioning

Structures git workflow practices. Use when making any code change. Use when committing, branching, resolving conflicts, splitting uncommitted work in a messy working tree into clean atomic commits, opening or reviewing a pull request (PR), pushing to a remote, or when you need to organize work across multiple parallel streams. Use when cutting a release, choosing a semantic version bump, tagging, or writing a changelog. Use when asked to write a commit message or a changelog entry for a change, or to split a change into commits, even when the diff is pasted inline and the message seems easy to write from it.

Quality

90%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide
SecuritybySnyk

Passed

No findings from the security scan

SKILL.md
Quality
Evals
Security

Quality

Content

81%Weight 40%Scale 1-5

Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.

A highly actionable, well-structured skill: concrete commands, worked examples, explicit validation checkpoints, and verification checklists make the workflows unambiguous and safe to execute. Its main costs are token weight — re-explaining git basics Claude already knows and packing everything into one long file that loads on every code change.

Suggestions

Trim or remove the 'Using Git for Debugging' section — git bisect, git blame, and git log --grep are standard knowledge Claude already has; if kept at all, reduce it to the one non-obvious point (e.g., bisect midpoints with your test as the predicate).

Move secondary material (the Common Rationalizations table, the lint-staged/husky config, and the detailed changelog examples) into a reference file linked from SKILL.md, keeping the always-loaded body to the core commit/branch/release discipline.

Cut the ASCII diagrams that restate simple ideas (the branch tree and save-point flowchart) in favor of their one-line prose summaries, which already carry the same instruction.

DimensionReasoningScore

Conciseness

The body is mostly efficient, directive guidance, but the "Using Git for Debugging" section re-teaches standard commands Claude already knows (`git bisect`, `git blame`, `git log --grep`), and the conventional-commit type list plus several ASCII diagrams restate familiar material. This fits the 3 anchor ('mostly efficient but includes some unnecessary explanation or could be tightened') better than 4, where over-explanation would be only a minor, trimmable instance.

3 / 5

Actionability

Guidance is fully executable throughout: exact pre-commit commands including the secrets scan `git diff --staged -i -G'password|secret|api_key|token' --name-only`, a copy-paste lint-staged config, `git tag -a v1.4.0 -m "Release 1.4.0"`, a concrete changelog markdown template, and worked commit-message examples. This matches the 5 anchor ('copy-paste ready code or commands; specific examples cover the common cases').

5 / 5

Workflow Clarity

Multi-step processes are clearly sequenced with explicit validation and feedback loops: "Implement slice → Test → Verify → Commit", the Save Point Pattern (test fails → revert to last commit → investigate), the ordered five-step pre-commit hygiene sequence, and closing checklists for every commit and every release. This matches the 5 anchor including error-recovery loops, and the destructive-operation cap does not apply because validation steps are present.

5 / 5

Progressive Disclosure

The single file is well-organized with clearly labeled sections and clearly signaled one-level cross-skill pointers (e.g., "See the splitting strategies in `code-review-and-quality`"). It fits the 4 anchor ('good structure; most content appropriately placed; minor organization gaps'): no bundle files exist, but at ~350 lines and an always-on trigger, material like the git-debugging basics and the rationalizations table could be offloaded to reference files to keep the overview lean.

4 / 5

Total

17

/

20

Passed

Description

96%Weight 40%Scale 1-5

Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.

A strong description: it states the skill's function, then exhaustively lists concrete capabilities and explicit, natural-language trigger scenarios spanning commit discipline, branching, PRs, releases, and versioning. Its only weakness is the overly broad "Use when making any code change" claim, which invites triggering alongside every other coding skill.

DimensionReasoningScore

Specificity

The description enumerates many concrete actions — committing, branching, "resolving conflicts", "splitting uncommitted work in a messy working tree into clean atomic commits", "opening or reviewing a pull request (PR)", pushing, "cutting a release, choosing a semantic version bump, tagging, or writing a changelog" — giving comprehensive coverage of the git-workflow domain. It exceeds the 4 anchor ('several specific actions; minor gaps') because the action list spans commits through releases with no meaningful gap.

5 / 5

Completeness

It explicitly answers both parts: the what ("Structures git workflow practices") and an exceptionally explicit when via multiple "Use when..." clauses with concrete triggers (committing, branching, PRs, releases, semver, changelogs, splitting changes). The 'when' is far more specific than the 4 anchor's example ('Use when working with PDF files'), matching the 5 anchor's 'concrete trigger phrases'.

5 / 5

Trigger Term Quality

Natural user phrasing is comprehensively covered with synonyms — "commit", "commit message", "branch", "conflict", "pull request (PR)", "push", "release", "semantic version bump", "tag", "changelog" — including the pasted-diff case ("even when the diff is pasted inline"). Only marginal terms like "merge" are absent, fitting the 5 anchor's comprehensive synonym coverage rather than the 4 anchor's 'a few natural terms missing'.

5 / 5

Distinctiveness Conflict Risk

The niche (git workflow discipline and versioning) is distinct with clearly owned triggers like "choosing a semantic version bump" and "splitting uncommitted work into clean atomic commits". However, "Use when making any code change" claims the skill for virtually all coding work, creating overlap risk with many other code-related skills — more than the 5 anchor's 'minimal conflict risk', but the domain itself is clear enough to sit above the 3 anchor.

4 / 5

Total

19

/

20

Passed

Validation

100%

Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.

Validation — 16 / 16 Passed

Validation for skill structure

No warnings or errors.

Repository

addyosmani/agent-skills

Path

skills/git-workflow-and-versioning/SKILL.md

Reviewed

Table of Contents

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.