Git Workflows

verification-loop is a Claude Code verification workflow for checking builds, types, lint, tests, security, and diffs after code changes. This verification-loop skill is useful before PRs and after refactors when you want a structured post-change guide instead of a generic prompt.

terminal-ops is an evidence-first repo execution skill for terminal work. Use it to run commands, inspect git state, debug CI or builds, and make narrow fixes with proof of what changed and what was verified. This terminal-ops guide helps reduce guesswork for Code Editing and repo operations.

tdd-workflow is a test-first workflow skill for new features, bug fixes, and refactors. It enforces TDD with 80%+ coverage across unit, integration, and E2E tests, plus explicit checkpoints and edge-case validation. Use the tdd-workflow skill when you need a practical guide for Test Automation and more predictable code changes.

The git-workflow skill helps you choose and apply a Git workflow for branching, merges, commits, conflict handling, tags, and releases. Use it to turn team constraints into a practical policy for GitHub Flow, trunk-based development, or GitFlow, with clear guidance for onboarding and day-to-day collaboration.

using-git-worktrees helps create isolated Git worktrees for new branch work with directory selection, ignore checks, and safer parallel workflows without touching your current checkout.

requesting-code-review is a lightweight workflow for dispatching the superpowers:code-reviewer subagent with a clean git diff, requirements, and change summary so reviews happen at the right time and produce actionable, severity-ranked feedback before merge.

receiving-code-review helps you verify PR feedback before editing code. Use it to restate review comments, check them against the codebase, ask for clarification on unclear items, and push back when suggestions do not fit.

The finishing-a-development-branch skill helps close a Git branch safely after implementation is done. It verifies tests, checks the base branch, then presents four clear options: merge locally, push for a Pull Request, keep the branch, or discard the work.

land-and-deploy is a workflow skill for merging a ready PR, waiting for CI and deployment, and verifying production health with canary checks. Use this land-and-deploy skill when you need a reliable handoff from merge to ship, especially for teams that already use /ship or similar release steps.

setup-pre-commit helps you add Husky pre-commit hooks with lint-staged, Prettier, and optional typecheck/test runs. Use this setup-pre-commit guide when your repo needs a fast, repeatable pre-commit safety net and you want to preserve existing config while adding the right scripts for the current package manager.

git-guardrails-claude-code adds a PreToolUse hook to block dangerous git commands before Claude Code runs them. Install it to prevent destructive pushes, hard resets, forced cleans, and branch deletes, with scoped control for this project or all projects. Useful when you need git-guardrails-claude-code for Access Control boundaries in Claude Code.

request-refactor-plan helps turn a vague refactor request into a detailed plan with tiny commits, repo verification, scope boundaries, test coverage review, and a GitHub issue. Use it for refactoring RFCs, incremental change plans, and safer implementation prep.

The changelog-automation skill helps teams design changelog workflows with Keep a Changelog, SemVer, release notes, and Conventional Commits. Use it to plan install context, define usage inputs, and improve release-note consistency for Technical Writing and developer documentation.

git-advanced-workflows helps with advanced Git tasks like interactive rebase, cherry-pick, bisect, worktrees, and reflog recovery. Use it to clean branch history, move fixes between branches, debug regressions, and recover safely from mistakes in complex Git workflows.

monorepo-management helps plan and improve JS/TS monorepos with pnpm workspaces, Turborepo, and Nx. Use it for project setup, migrations, CI and build optimization, shared package strategy, and dependency management across multi-package repos.

workflow-patterns is a Conductor-style process skill for task execution with TDD, plan.md status tracking, verification checkpoints, and disciplined commit handling.

The parallel-feature-development skill helps teams split one feature into clear ownership groups, define shared contracts early, and choose safer merge patterns for multi-agent Git workflows. Use it to plan file ownership, dependency-aware integration, and lower-conflict parallel implementation.

incremental-implementation helps you ship changes in thin, testable slices for multi-file edits, refactors, and new features. Use this incremental-implementation skill when a task is too large to finish safely in one pass. It works well for code editing, because each step stays working, reviewable, and easier to verify.

git-workflow-and-versioning helps developers and agents manage code changes with safer commits, short-lived branches, and reversible history. Use it for git-workflow-and-versioning usage when you need a practical guide for trunk-based workflows, reviewable changes, and conflict-prone work.

setup-pre-commit helps add Husky pre-commit hooks with lint-staged and Prettier, detects the package manager, creates .husky/pre-commit and .lintstagedrc, and only adds typecheck or test commands when those scripts already exist.

git-guardrails-claude-code adds a Claude Code PreToolUse hook that blocks dangerous Git commands like push, reset --hard, clean -f, branch -D, checkout ., and restore . before execution. It supports project or global install, manual hook setup, executable script permissions, and behavior testing with the bundled shell script.

commit-work helps turn messy Git changes into clean, reviewable commits. It guides diff inspection, patch staging, commit splitting, staged diff review, and clear Conventional Commit messages for safer Git workflows.

existing-repo helps agents analyze an existing codebase, detect stack and conventions, and add guardrails without breaking local patterns. Use this existing-repo skill for Git Workflows, first-time repo work, maintenance, and setup changes where understand-before-modifying matters most.

darwin-skill helps improve SKILL.md files with a repeatable loop: evaluate, revise, test, then keep or revert changes. Built for Skill Authoring, it combines rubric scoring with prompt-based validation and supports visual result outputs from repo templates and assets.