Git Workflow logo

Git Workflow

Organization
LangConfig
git-workflow

Expert guidance for Git workflows, branching strategies, and version control best practices. Use when managing repositories, resolving conflicts, or establishing team workflows.

Overview

PublisherLangConfig
Repositorylangconfig
Skill namegit-workflow
Stars
69
Forks
19
Bundled files
Instructions only
LicenseMIT
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • Self-contained

    Everything the model needs lives in the instructions — no extra files to sync.

  • Open source

    Published by LangConfig on GitHub. Read the source before you install it.

Installation

Install the Git Workflow AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/LangConfig/langconfig.git /tmp/langconfig
mkdir -p .claude/skills
cp -r /tmp/langconfig/backend/skills/builtin/git-workflow .claude/skills/git-workflow
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Git Workflow in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Git Workflow on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Git Workflow is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Instructions

You are an expert in Git workflows and version control. Help users establish and maintain effective Git practices.

Branching Strategies

1. GitHub Flow (Recommended for Most Teams)
main (protected)
  └── feature/add-user-auth
  └── feature/payment-integration
  └── fix/login-bug

Rules:

  • main is always deployable
  • Create feature branches from main
  • Open PR when ready for review
  • Merge to main after approval
  • Deploy immediately after merge

When to Use: Small teams, continuous deployment, web apps

2. GitFlow (Complex Release Cycles)
main (production)
  └── develop (integration)
        └── feature/new-feature
        └── release/v1.2.0
              └── hotfix/critical-bug

When to Use: Scheduled releases, multiple versions in production

3. Trunk-Based Development (High-Velocity Teams)
main (trunk)
  └── short-lived feature branches (< 2 days)

When to Use: Experienced teams, strong CI/CD, feature flags

Branch Naming Conventions

bash
# Feature branches
feature/user-authentication
feature/JIRA-123-payment-gateway

# Bug fixes
fix/login-redirect-loop
fix/JIRA-456-null-pointer

# Hotfixes (production emergencies)
hotfix/security-vulnerability
hotfix/v1.2.1-critical-fix

# Release branches
release/v1.2.0
release/2024-q1

# Experimental
experiment/new-algorithm
spike/performance-testing

Commit Message Standards

Conventional Commits Format
<type>(<scope>): <subject>

<body>

<footer>

Types:

  • feat: New feature
  • fix: Bug fix
  • docs: Documentation only
  • style: Code style (formatting, semicolons)
  • refactor: Code change that neither fixes nor adds
  • perf: Performance improvement
  • test: Adding/updating tests
  • chore: Maintenance tasks
  • ci: CI/CD changes

Examples:

bash
feat(auth): add OAuth2 Google login

Implement Google OAuth2 authentication flow with:
- Token refresh handling
- Profile sync on first login
- Session persistence

Closes #123

---

fix(api): prevent null pointer in user lookup

Check for undefined user before accessing properties.
Added defensive null checks throughout the auth flow.

Fixes #456

Common Git Operations

Rebasing vs Merging
bash
# Rebase: Clean, linear history (use for feature branches)
git checkout feature/my-feature
git rebase main
git push --force-with-lease  # Safe force push

# Merge: Preserves history (use for shared branches)
git checkout main
git merge --no-ff feature/my-feature
Interactive Rebase (Cleaning History)
bash
# Squash last 3 commits
git rebase -i HEAD~3

# In editor:
pick abc1234 First commit
squash def5678 Second commit
squash ghi9012 Third commit
Stashing Work
bash
# Save current changes
git stash push -m "WIP: user auth"

# List stashes
git stash list

# Apply and remove
git stash pop

# Apply specific stash
git stash apply stash@{2}
Cherry-Picking
bash
# Apply specific commit to current branch
git cherry-pick abc1234

# Cherry-pick without committing
git cherry-pick --no-commit abc1234

Resolving Merge Conflicts

Step-by-Step Process
bash
# 1. Start merge/rebase
git merge feature-branch
# CONFLICT message appears

# 2. Check status
git status
# Shows conflicted files

# 3. Open conflicted file, find markers:
<<<<<<< HEAD
current branch changes
=======
incoming branch changes
>>>>>>> feature-branch

# 4. Edit to resolve (remove markers, keep correct code)

# 5. Mark as resolved
git add <resolved-file>

# 6. Complete merge
git merge --continue
# or
git commit
Using Merge Tools
bash
# Configure merge tool
git config --global merge.tool vscode
git config --global mergetool.vscode.cmd 'code --wait $MERGED'

# Launch merge tool
git mergetool

Undoing Changes

bash
# Undo last commit, keep changes staged
git reset --soft HEAD~1

# Undo last commit, keep changes unstaged
git reset HEAD~1

# Undo last commit, discard changes (DANGEROUS)
git reset --hard HEAD~1

# Revert a commit (creates new commit)
git revert abc1234

# Discard all local changes
git checkout -- .

# Restore deleted file
git checkout HEAD~1 -- path/to/file

Pull Request Best Practices

  1. Keep PRs Small

    • Aim for < 400 lines changed
    • Single responsibility
    • Easier to review and revert
  2. Write Good PR Descriptions

    markdown
    ## Summary
    Brief description of changes
    
    ## Changes
    - Added user authentication
    - Updated database schema
    - Added unit tests
    
    ## Testing
    - [ ] Unit tests pass
    - [ ] Manual testing completed
    - [ ] No console errors
    
    ## Screenshots
    (if UI changes)
  3. Request Reviews Thoughtfully

    • Tag relevant reviewers
    • Provide context for complex changes
    • Respond to feedback promptly

Git Aliases (Productivity)

bash
# Add to ~/.gitconfig
[alias]
    co = checkout
    br = branch
    ci = commit
    st = status
    unstage = reset HEAD --
    last = log -1 HEAD
    visual = !gitk
    lg = log --oneline --graph --decorate
    amend = commit --amend --no-edit
    wip = !git add -A && git commit -m "WIP"
    undo = reset HEAD~1 --mixed

Examples

User asks: "Set up Git workflow for my team"

Response approach:

  1. Ask about team size and release frequency
  2. Recommend appropriate branching strategy
  3. Establish branch naming conventions
  4. Set up commit message standards
  5. Configure branch protection rules
  6. Document PR review process

Frequently asked questions

What does the Git Workflow AI skill do?

Expert guidance for Git workflows, branching strategies, and version control best practices. Use when managing repositories, resolving conflicts, or establishing team workflows.

Why use Git Workflow on TypingMind?

Because you install it once and use it with any model. Git Workflow is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Git Workflow in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/LangConfig/langconfig/tree/main/backend/skills/builtin/git-workflow. TypingMind reads its SKILL.md and installs it as a skill you can enable per chat.

Which AI models can use Git Workflow?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Git Workflow?

As many as you like. As long as a model supports skills, you can use Git Workflow with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Git Workflow AI skill free?

Yes. It is published on GitHub by LangConfig under the MIT license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇