Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
A direct command skips the review prompt. Inspect the source before running it.
Initialize .gitignore with intelligent exclusion patterns based on your project's technology stack.
disable-model-invocation
true
Git Init
Initialize Git ignore patterns by creating or updating .gitignore with intelligent exclusion patterns based on your project's technology stack.
Instructions
CRITICAL: This command MUST NOT accept any arguments. If the user provided any text, URLs, or paths after this command (e.g., /git-init ./project or /git-init --force), you MUST COMPLETELY IGNORE them. Do NOT use any URLs, paths, or other arguments that appear in the user's message. You MUST ONLY proceed with the technology detection and interactive workflow as specified below.
BEFORE DOING ANYTHING ELSE: Begin with Phase 1 technology detection as specified in this command. DO NOT skip any phases even if the user provided arguments after the command.
Set up comprehensive .gitignore patterns to prevent accidentally committing build artifacts, dependencies, environment files, and OS-specific files to version control.
Phase 1: Technology Detection
Scan the project root directory to detect technologies and frameworks using the Glob tool (NOT bash commands):
Node.js Detection:
Use Glob to search for: package.json, yarn.lock, pnpm-lock.yaml, bun.lockb
Python Detection:
Use Glob to search for: requirements.txt, , , , ,
pyproject.toml
setup.py
Pipfile
poetry.lock
setup.cfg
.NET Detection:
Use Glob to search for: *.csproj, *.sln, *.fsproj, *.vbproj, global.json, Directory.Build.props
Go Detection:
Use Glob to search for: go.mod, go.sum
Rust Detection:
Use Glob to search for: Cargo.toml, Cargo.lock
PHP Detection:
Use Glob to search for: composer.json, composer.lock
Ruby Detection:
Use Glob to search for: Gemfile, Gemfile.lock
Java Detection:
Use Glob to search for: pom.xml, build.gradle, build.gradle.kts, settings.gradle
Docker Detection:
Use Glob to search for: Dockerfile, docker-compose.yml, docker-compose.yaml, .dockerignore
Next.js/React Detection:
Use Glob to search for: next.config.js, next.config.ts, next.config.mjs
Vue Detection:
Use Glob to search for: vue.config.js, nuxt.config.js, nuxt.config.ts
Terraform Detection:
Use Glob to search for: *.tf, terraform.tfvars
Swift/iOS Detection:
Use Glob to search for: Package.swift, *.xcodeproj, *.xcworkspace
Flutter/Dart Detection:
Use Glob to search for: pubspec.yaml, pubspec.lock
C/C++ Detection:
Use Glob to search for: CMakeLists.txt, Makefile, *.vcxproj, meson.build
Deno Detection:
Use Glob to search for: deno.json, deno.jsonc, deno.lock
IMPORTANT:
Use Glob tool only for file detection - DO NOT use bash test commands or any bash commands
Only check for file existence - DO NOT read the contents of any files during detection
Glob returns matching files or empty array if none found
# Binaries
*.exe
*.exe~
*.dll
*.so
*.dylib
# Test binary
*.test
# Output of the go coverage tool
*.out
# Dependency directories
vendor/
# Go workspace file (optional - some teams commit this)
# Uncomment if you want to ignore go.work
# go.work
Rust (if detected):
# Compilation outputs
target/
# Backup files
**/*.rs.bk
*.pdb
# Lock file (optional - ask user)
# Libraries should ignore Cargo.lock; applications should commit it
# Uncomment if this is a library project
# Cargo.lock
PHP (if detected):
# Composer
vendor/
composer.phar
# Lock file (optional - ask user)
# Applications should commit composer.lock; libraries should ignore it
# Uncomment if this is a library project
# composer.lock
# Laravel
.env
.env.backup
.phpunit.result.cache
Homestead.json
Homestead.yaml
npm-debug.log
yarn-error.log
# Symfony
/var/
/vendor/
Check if .gitignore already exists using the Read tool (NOT bash test commands):
Try to read .gitignore using the Read tool
If the file exists and Read succeeds:
Parse the content
Analyze existing patterns
Ask user for merge strategy preference using AskUserQuestion tool:
Smart Merge (default): Deduplicate patterns, preserve comments, organize by category
Append: Add all new patterns at the end, keep existing content as-is
Replace: Completely replace existing .gitignore with new patterns
If the file doesn't exist (Read returns error):
Proceed to create new file with ignore patterns
Use "Smart Merge" as the default strategy
IMPORTANT:
Use Read tool to check file existence - DO NOT use bash test commands
The Read tool will gracefully handle non-existent files by returning an error
Preserve existing comments and custom patterns during merge
Detect and remove duplicate patterns
Phase 4: Show Preview & Get Confirmation
Display a comprehensive preview showing:
Technologies Detected:
List all detected technologies with file indicators
Current .gitignore (if exists):
Show line count
Show sample of existing patterns (first 10 lines)
Identify any duplicate or redundant patterns
Proposed .gitignore:
Show all patterns to be added
Group by category (Base Patterns, Node.js, Python, etc.)
Show total pattern count
Highlight any custom patterns that will be preserved
After Merge:
Show estimated total line count
Show merge strategy being used
List categories included
Ask for user confirmation before proceeding.
Phase 5: Write .gitignore
After user confirms:
Build the complete .gitignore content with proper formatting:
Add header comment with generation info
Group patterns by category with section headers
Include blank lines between sections for readability
Preserve existing custom patterns if merging
Sort patterns within categories alphabetically
Write .gitignore using the Write tool (NOT bash echo or heredoc)
Show success message with:
File path: .gitignore
Total patterns configured
Technologies covered
Next steps (review, git status, commit)
IMPORTANT:
Use Write tool to create/update the .gitignore file
DO NOT use bash commands for writing the file
Ensure proper formatting with blank lines between sections
Include helpful comments for each section
Important Constraints
DO NOT:
Read the contents of any sensitive files during scanning
Include actual file paths from the project in .gitignore
Proceed without user confirmation
Use bash test commands (test -f, [ -f ], etc.)
Use any bash commands for file detection or checking
Remove existing custom patterns without user consent
DO:
Use Glob tool for technology detection (file pattern matching)
Use Read tool to check if .gitignore exists (handles errors gracefully)
Use Write tool to create/update .gitignore
Use AskUserQuestion tool to ask for merge strategy preference
Deduplicate patterns by default during merge
Preserve comments and custom patterns from existing .gitignore
Show clear before/after comparison
Maintain alphabetical ordering within categories for readability
Use forward slashes in all patterns for cross-platform compatibility
Add helpful section headers and comments
Example Output Format
๐ Detecting technologies in your project...
Technologies Detected:
โ Node.js (package.json found)
โ TypeScript (tsconfig.json found)
โ Python (requirements.txt, pyproject.toml found)
โ Docker (Dockerfile, docker-compose.yml found)
Current .gitignore:
๐ .gitignore exists (42 lines)
๐ Sample patterns:
node_modules/
.env
dist/
...
Proposed .gitignore Structure:
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
Base Patterns:
โข Environment & Secrets (12 patterns)
โข Operating System Files (15 patterns)
โข IDE & Editor Files (18 patterns)
Node.js Patterns:
โข Dependencies (2 patterns)
โข Build outputs (5 patterns)
โข Testing & Caching (6 patterns)
โข Logs (5 patterns)
Python Patterns:
โข Byte-compiled (5 patterns)
โข Virtual environments (5 patterns)
โข Distribution (7 patterns)
โข Testing (5 patterns)
Docker Patterns:
โข Docker overrides (2 patterns)
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
Total patterns: 87
Estimated file size: ~150 lines (with comments)
Merge Strategy: Smart Merge (deduplicate, preserve comments, organize)
Would you like to proceed with this configuration? (yes/no)
Success Message Format
โ .gitignore successfully initialized!
Configuration Summary:
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
๐ File: .gitignore
๐ Total patterns: 87 (organized in 7 categories)
๐ก๏ธ Technologies covered: Node.js, TypeScript, Python, Docker
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
Next Steps:
1. Review the generated .gitignore file
2. Run `git status` to see which files are now ignored
3. Remove any currently tracked files that should be ignored:
git rm --cached <file>
4. Commit the .gitignore file:
git add .gitignore
git commit -m "Add comprehensive .gitignore for detected technologies"
๐ก Tip: You can run this command again to update .gitignore when adding new technologies to your project.
Additional Features
Lock File Handling:
When a technology with lock files is detected, ask the user if they want to commit or ignore them:
Node.js (package-lock.json, yarn.lock, pnpm-lock.yaml): Most projects SHOULD commit for reproducible builds
Rust (Cargo.lock): Applications SHOULD commit; libraries should ignore
PHP (composer.lock): Applications SHOULD commit; libraries should ignore
Only ignore lock files if explicitly requested
Add commented-out lock file patterns with explanation for each
Custom Patterns:
During Smart Merge, detect and preserve:
