Skip to main content

Initializing Repositories: Starting Your Git Journey

Every Git project starts with initialization. Here's how to create your first repository and start tracking changes.

🎯 The Big Picture​

Initializing a repository is like setting up a time machine for your project. Once initialized, Git tracks every change. Forever.

Creating a New Repository​

Basic Initialization​

# Create a project directory
mkdir my-project
cd my-project

# Initialize Git repository
git init

# Output: Initialized empty Git repository in /path/to/my-project/.git

What happens?

  • Git creates a .git folder
  • Sets up the repository structure
  • You're on the default branch (usually main or master)

Initialize in Current Directory​

# If you're already in your project directory
git init

# Git initializes in the current directory

Initialize with Branch Name​

# Initialize with a specific default branch name
git init -b main

# Or set it globally first
git config --global init.defaultBranch main
git init

After Initialization​

Check Repository Status​

git status

# Output:
# On branch main
# No commits yet
# nothing to commit (create/copy files and use "git add" to track)

Make Your First Commit​

# Create a file
echo "# My Project" > README.md

# Stage it
git add README.md

# Commit it
git commit -m "Initial commit"

# Now you have a repository with history!

Repository Structure After Init​

my-project/
├── .git/                 # Git database (hidden)
│   ├── HEAD             # Points to current branch
│   ├── config           # Repository config
│   ├── objects/         # Git objects storage
│   ├── refs/            # Branch and tag references
│   └── ...
├── README.md            # Your project files
└── ...

Common Initialization Scenarios​

Scenario 1: New Project from Scratch​

# Create and initialize
mkdir new-project
cd new-project
git init

# Add initial files
echo "# New Project" > README.md
git add README.md
git commit -m "Initial commit"

Scenario 2: Existing Project (Not Yet in Git)​

# You have a project folder with files
cd existing-project

# Initialize
git init

# Add all existing files
git add .

# Commit
git commit -m "Initial commit: existing project"

Scenario 3: Clone Instead of Init​

# If the project already exists on GitHub/GitLab
git clone https://github.com/user/repo.git

# This initializes AND downloads the project

Initialization Options​

Bare Repository​

# Create a bare repository (no working directory)
git init --bare my-project.git

# Used for server repositories
# No working files, just the Git database

Shared Repository​

# Initialize with shared permissions
git init --shared=group

# Useful for team repositories

Template Repository​

# Initialize using a template
git init --template=/path/to/template

# Uses template's hooks and config

Post-Initialization Setup​

1. Set Default Branch​

# If not set globally
git config init.defaultBranch main

# Or rename existing branch
git branch -M main

2. Create .gitignore​

# Create .gitignore file
cat > .gitignore << EOF
# Dependencies
node_modules/
vendor/

# Build outputs
dist/
build/

# Environment files
.env
.env.local

# IDE files
.idea/
.vscode/
*.swp
EOF

# Commit it
git add .gitignore
git commit -m "Add .gitignore"

3. Add Remote (If Needed)​

# After creating repo on GitHub/GitLab
git remote add origin https://github.com/user/repo.git

# Verify
git remote -v

My Take: Start Simple​

I used to overthink initialization. I'd set up complex configurations. I'd create elaborate folder structures.

Then I realized: Just git init and start working.

You can always add configuration later. Start simple. Add complexity as needed.

Memory Tip: The Empty Box Analogy​

Think of git init like getting an empty filing cabinet:

  • Before init: Just a folder with files
  • After init: A folder with files + a filing system (.git)
  • First commit: Your first file in the filing cabinet

Once you make that first commit, you have history.

Common Mistakes​

Mistake 1: Initializing in Wrong Directory​

# Don't do this
cd ~
git init  # Makes your home directory a repository!

Fix: Always cd into your project directory first.

Mistake 2: Nested Repositories​

# Don't do this
git init parent
cd parent
git init child  # Repository inside repository!

Fix: One repository per project. Not nested.

Mistake 3: Not Making Initial Commit​

# Don't do this
git init
# ... work for days without committing ...
# Then wonder why git status shows nothing

Fix: Make an initial commit right away. Even if it's just a README.

Hands-On: Initialize Your First Repository​

Let's do this for real. Follow along:

# Create a project directory
mkdir my-git-project
cd my-git-project

# Initialize Git
git init

# You should see: Initialized empty Git repository...

What just happened?

  • Git created a .git folder (hidden)
  • Your directory is now a Git repository
  • You're ready to start tracking files

Try it yourself:

  1. Create a repository using the commands above
  2. Check git status - see what Git tells you
  3. Create a README file and add it
  4. Make your first commit

Create a screenshot: Take a screenshot of your terminal showing git init and git status output.

Key Takeaways​

  1. git init creates a repository - It sets up the .git folder
  2. Initialize in project directory - Not parent directories
  3. Make an initial commit - Even if it's just a README
  4. Set up .gitignore early - Before committing unwanted files
  5. Start simple - Add complexity as needed

What's Next?​

Now that you can initialize repositories, let's learn about making commits. Next: Making Commits.

Or practice with: Hands-On Exercises.

Remember: Initialization is just the start. The real work is in the commits.