Skip to main content
skill CX Codex

git-setup — Claude Code skill: audit and configure Git

git-setup audits Git configuration with a single command, finds gaps, and proposes safe fixes for identity, editor, diff and merge tooling.

MIT ★ 1,627 updated 2026-10-25

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add microsoft/hve-core --skill git-setup -a claude-code
Open on GitHub

What git-setup does

The skill runs git config --list --show-origin, parses current user.name, user.email, core.editor, diff.tool and merge.tool values, and displays a status table. When a setting is missing, it proposes grouped commands and applies each group only after explicit confirmation. Commit signing help (GPG or SSH) and safe.directory fixes activate only on request or when Git reports an ownership error.

Inside: command templates for identity setup, enabling SSH signing with an existing key, generating a new GPG or SSH key, and binding VS Code as the editor and diff and merge tool. SSH signing requires Git 2.34 or later. After applying changes, the skill shows a before and after table and a final status line.

What it helps with

  • check whether user.name and user.email are set in all scopes
  • find a missing core.editor or diff.tool and propose VS Code
  • enable commit signing with an SSH or GPG key
  • add the repository path to safe.directory after an unsafe-repository error
  • show current Git configuration with a single command, no extra lookups

Example prompts for the agent

  • Check my Git configuration and show what is missing
  • Set up user.name and user.email in global scope
  • Enable commit signing with SSH key ~/.ssh/id_ed25519.pub

How to install git-setup

1Skills CLI (Vercel)

npx skills add microsoft/hve-core --skill git-setup -a claude-code

2Manually: put the files in place

~/.claude/skills/git-setup/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/git-setup/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about git-setup

How to install git-setup in Claude Code?

Run npx skills add microsoft/hve-core --skill git-setup -a claude-code. The skill will appear in ~/.claude/skills/git-setup/SKILL.md.

What does git-setup do?

It audits Git configuration with git config --list --show-origin, finds gaps in identity, editor and diff and merge tooling, proposes fixes, and applies them only after confirmation.

Does SSH signing need a specific Git version?

Yes, SSH commit signing works with Git 2.34 or later. For older versions, the skill will propose GPG instead.

Source text

SKILL.md · MIT
---
name: git-setup
description: 'Audit Git configuration with one read-only baseline command, then propose confirmed, non-destructive fixes for identity, editor, and diff and merge tooling, with signing and safe.directory help only on request. Use when setting up or checking Git on a workstation.'
license: MIT
user-invocable: true
disable-model-invocation: true
---

# Git Setup

## Goal

Help the user configure Git consistently for everyday work (`add`, `commit`, `fetch`, `pull`, `push`) without overwriting preferred settings. Verify current values before suggesting changes, and never modify configuration without explicit confirmation.

Scope:

* Identity: `user.name` and `user.email` are set.
* Editing, diff, and merge tooling is configured when currently unset.
* Commit signing (GPG or SSH) help happens only when the user asks for it or reports a signing error.
* A `safe.directory` entry is proposed only when the user reports a Git ownership or unsafe-repository error.
* Existing customizations stay intact; never downgrade or remove settings.

## Flow

1. Audit the current configuration with exactly one command: `git config --list --show-origin`. It captures values and their source files. Run no other lookup, `gpg`, or `ssh-keygen` command during the audit.
2. Report gaps and desirable improvements from that output.
3. Propose minimal remediation commands, grouped logically.
4. Ask for confirmation per group before applying it, and apply only confirmed groups.
5. Verify applied settings with single `git config --get <key>` reads and show a before and after summary.
6. Summarize applied changes and remaining optional improvements.

## Detection

Classify each area from the baseline output only, in this order:

1. Identity: parse `user.name` and `user.email` and note each scope from its origin path. Mark a value missing when no scope sets it.
2. Commit signing (passive scan): parse `commit.gpgSign`, `gpg.format`, and `user.signingkey`, and classify the result for display only:
   * Disabled: `commit.gpgSign` is false or unset.
   * Configured candidate: signing is true and both `gpg.format` and `user.signingkey` are present.
   * Incomplete: signing is true but `gpg.format` or `user.signingkey` is missing.
   * Not configured: all three are unset.
3. Editor and tools: parse `core.editor`, `diff.tool`, and `merge.tool`, and mark each missing value as a gap.
4. Safe directory: note whether any `safe.directory` entry includes the current repository path.
5. Line endings: parse `core.autocrlf` and `core.eol`, and flag them only when both are unset and the user mentions cross-platform needs.

## Proposals

* Build a remediation group for each identity or editor and tooling gap, with the rationale, exact commands, and expected effect.
* Build a signing group only when the user asks about signing, wants to enable or disable it, or reports a signing verification error.
* Build a safe-directory group only when the user reports an unsafe-repository error from Git.
* Offer line-ending settings only when the user mentions cross-platform concerns.
* Write each command on its own line, directly runnable and human-auditable, with no chaining through `&&`, `;`, pipes, or subshells. Idempotent commands are acceptable when the user confirms them.
* When one specific value needs clarification later, propose a single follow-up `git config --get <key>` after user confirmation rather than a batch.
* Propose, but do not run, `gpg --list-secret-keys` only when signing is enabled or the user wants to enable signing and is unsure which keys exist.
* Propose key generation only when the user opts into signing and the configuration shows no usable key.
* Never push, fetch, pull, or alter remotes, and never show secrets or private key content. Redact the email only when the user asks for privacy.

## Command Templates

Adapt these after the user confirms the group; do not emit a template that no current gap or request needs.

Identity:

```bash
git config --global user.name "<user-name>"
git config --global user.email "<user-email>"
```

Disable misconfigured signing for now:

```bash
git config --global commit.gpgSign false
```

Trust a repository path after an unsafe-repository error:

```bash
git config --global --add safe.directory "<repo-path>"
```

Enable SSH signing with an existing key (Git 2.34 or later):

```bash
git config --global gpg.format ssh
git config --global user.signingkey "~/.ssh/id_ed25519.pub"
git config --global commit.gpgSign true
```

Generate and configure a GPG signing key:

```bash
gpg --full-generate-key
gpg --list-secret-keys --keyid-format=long
gpg --armor --export <KEY_ID> > public-gpg-key.asc
git config --global gpg.format openpgp
git config --global user.signingkey <KEY_ID>
git config --global commit.gpgSign true
```

Generate and configure an SSH signing key:

```bash
# Linux and macOS
ssh-keygen -t ed25519 -C "<user-email>" -f ~/.ssh/id_ed25519
eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519

# Windows PowerShell with the built-in OpenSSH agent
ssh-keygen -t ed25519 -C "<user-email>" -f $HOME/.ssh/id_ed25519
Start-SSHAgent
ssh-add $HOME/.ssh/id_ed25519

# Both platforms
git config --global gpg.format ssh
git config --global user.signingkey ~/.ssh/id_ed25519.pub
git config --global commit.gpgSign true
```

Use VS Code as the editor, diff tool, and merge tool when those values are unset:

```bash
git config --global core.editor "code --wait --new-window"
git config --global diff.tool code
git config --global difftool.code.cmd 'code -n --wait --diff "$LOCAL" "$REMOTE"'
git config --global merge.tool code
git config --global mergetool.code.cmd 'code -n --wait --merge "$REMOTE" "$LOCAL" "$BASE" "$MERGED"'
git config --global mergetool.code.trustexitcode true
git config --global mergetool.keepbackup false
```

## Interaction

* Show the audit table before any proposal.
* After the audit, ask only about identity, editor, and tooling gaps. Raise signing or safe-directory topics only when the user mentioned them or an error makes them relevant.
* Ask one confirmation per group, for example `Apply identity fixes? (yes/no)`. Treat only an explicit yes, in any letter case, as approval; any other answer declines the group.
* When an email does not match a corporate domain pattern the user supplied, warn without changing it.
* When every setting is already correct, state `No changes needed` and skip proposals except for topics the user asked about.

## Output Format

1. An audit section with a summary table that has at least the columns Setting, Value, Scope, and Status, using ✅ for satisfactory values and ❌ for missing or inconsistent values. A Notes column is optional.
2. Short notes below the table for ❌ rows only.
3. For each proposed group, an explanation, a fenced `bash` block, and a confirmation question.
4. After changes, a summary of successes and remaining warnings with a before and after table.
5. A final status line: `Git setup complete.` or `Git setup partial; user declined some changes.`

Example audit table:

```markdown
| Setting        | Value                    | Scope  | Status | Notes                            |
|----------------|--------------------------|--------|--------|----------------------------------|
| user.name      | Jane Doe                 | global | ✅      |                                  |
| user.email     | (missing)                | -      | ❌      | required for commits             |
| core.editor    | code --wait --new-window | global | ✅      |                                  |
| diff.tool      | (unset)                  | -      | ❌      | optional convenience             |
| merge.tool     | (unset)                  | -      | ❌      | improves merges                  |
| commit.gpgSign | true                     | global | ✅      | signing active                   |
| safe.directory | (not listed)             | -      | ✅      | not required (no unsafe warning) |
```

## Success Criteria

* Every critical gap (identity and the chosen editor and tooling) is fixed, or the user declined it with clear notice.
* No existing unrelated setting was unset or deleted, and no remote was touched.
* The summary gives clear guidance for remaining optional improvements: line endings, safe directory, and deferred signing.

© microsoft · MIT · microsoft/hve-core

Similar skills

All skills for Git and GitHub →
re0-git LilMGenius re0-git is a Claude Code skill for editing commit messages to match a repository’s style. Run it manually after deciding to commit, to reorder a late change or remove a rejected commit. CX Codex +1 1,500installs GitHub SSH Setup for Students (Existing Repository, Clone & Push Ready) senoldak GitHub SSH Setup for Students (Existing Repository, Clone & Push Ready) is a prompt for ChatGPT, Claude.ai, and Claude Code that guides beginners through SSH setup and clones an existing repository without HTTPS, tokens, or passwords. GP ChatGPT ★ 178,201repo stars glab-gpg-key vince-winkintel glab-gpg-key — a skill for Claude Code that manages GPG keys on GitLab. Automates adding, listing, and deleting keys when setting up commit signing or verifying commit signatures. CX Codex +1 118installs clawdbot-backup sundial-org clawdbot-backup — a skill for Claude Code, Codex, Cursor, Copilot, and Gemini CLI that handles backup and restore of ClawdBot configuration. Runs when you ask the agent to archive your setup before migrating to a new machine. CX Codex +1 231installs ce-setup EveryInc ce-setup — a Claude Code skill that inspects Compound Engineering tools, fixes repository configuration, scaffolds packs, and refreshes code standards. Runs during setup or as a scheduled CI job. CX Codex +1 3,600installs vscode-workspace-setup patricio0312rev vscode-workspace-setup writes a .vscode folder into the repo: shared editor settings, extension recommendations, build tasks and debug configs. Useful when formatting and lint drift between teammates. CX Codex +1 313installs

From the same set148

The whole set →
Backlog Grooming Backlog Grooming reviews selected open GitHub issues against repository evidence and returns a maintainer report without changing those issues. CX Codex +1 ★ 1,627repo stars git-commit git-commit walks through confirming which paths to stage, then makes one local Conventional Commit, or just drafts a commit message for changes already staged. CX Codex +1 ★ 1,627repo stars ux-coaching ux-coaching guides UX practitioners through problem framing, design critique, and stakeholder advocacy by asking questions instead of giving ready-made answers. CX Codex +1 ★ 1,627repo stars RAI Reviewer The RAI Reviewer subagent coordinates codebase assessments against responsible AI frameworks and produces a consolidated report. Use it for audits, change reviews, or plan analysis. CX Codex +1 ★ 1,627repo stars feasibility Structures and validates durable data and ML feasibility studies using constrained YAML and UUID-tracked provenance. CX Codex +1 ★ 1,627repo stars GitHub Backlog Executor The GitHub Backlog Executor subagent applies a prepared set of operations to GitHub issues and sub-issues in one confirmed repository. Use it to carry out backlog changes through GitHub. CX Codex +1 ★ 1,627repo stars backlog-plan backlog-plan plans backlog work in Azure DevOps, GitHub, and Jira without modifying remote trackers. Generates local plan files for sprints, triage, and task handoffs. CX Codex +1 ★ 1,627repo stars review-artifacts review-artifacts is a Claude Code rule that stores code review results in a defined folder layout. It applies to files under .copilot-tracking/reviews/code-reviews/. CX Codex +1 ★ 1,627repo stars

Project sponsors

Companies that keep this analytics open