When we ran `git status` inside of our repository in our previous lesson , we were told that there is nothing to commit, and that we should make files and add them. So let's do that!

## Create Files with `echo`

The `echo` command can be used to write text into new files.

The following commands will create new files for `git-help.txt`, `git-init.txt`, and `git-status.txt`:

```markdown
echo "#git-help" > git-help.txt
echo "#git-init" > git-init.txt
echo "#git-status" > git-status.txt
```

Running `ls` will show us the files have been created.

## Check the File Status

Running `git status` shows that there are untracked files:

```markdown
$ git status

On branch main
No commits yet
Untracked files:
(use "git add <file>..." to include in what will be committed)
git-help.txt
git-init.txt
git-status.txt
nothing added to commit but untracked files present (use "git add" to track)
```

In order to track the files, we first need to add them.

## Add Files

We can add the files with the `git add` command along with a filename.

Let's add `git-help.txt` first:

```
git add githelp.txt
```

Running `git status` again, we have an additional section called "changes to be committed.":

```tsx
$ git status

On branch main
No commits yet
Changes to be committed:
  (use "git rm --cached <file>..." to unstage)
        new file:   git-help.txt

Untracked files:
  (use "git add <file>..." to include in what will be committed)
        git-init.txt
        git-status.txt
```

Note that the `git-help.txt` changes aren't committed yet but staged for commit.

## Stage the Rest of the Files

The remaining files can be individually with `git add`.

However, using the shortcut `git add .` will add everything that hasn't been added to the index.

After adding the rest of the files, running `git status` one last time will show that everything has been moved into our index and staged for commit.

Learn the basics of working with Git like tracking files, understanding the status, and staging changes for commit.

Git Tracking and Staging Files

[00:00] When we ran git status inside of our repository, we were told that there is nothing to commit, and that we should make files and add them. So let's do that. Let's echo a githelp heading into a githelp.txt file and repeat that for init and status.

[00:20] Typing ls we should see three files. Let's run git status again. We have a new category now for untracked files. We can add them with the git add subcommand. Let's do that with a file name like it's suggesting here. git add githelp.txt. Run git status again. Now we have an additional

[00:39] section, changes to be committed. Note that these aren't committed yet, but they're staged for commit. If we want to stage the rest of these files, we can do them individually with git add, but we can use the dot shortcut to add everything that hasn't been added to the index. Finally,

[00:56] run git status one last time to see that everything has been moved into our index and staged for commit.

Ever found yourself in the midst of a Git nightmare, like accidentally pushing your work-in-progress branch straight to production? It happens to the best of us.

But mastering Git isn't just about memorizing commands and executing them robotically. It's about understanding the underlying principles, developing best practices, and learning from both successes and failures. It's about transforming Git from a tool you use to a skill you wield with confidence.

Whether you're a coding newbie just starting to explore version control or a seasoned developer looking to refine your Git skills, this tutorial is the perfect git roadmap for you.

## What to expect:

**Foundation Building:** Lay the groundwork for Git control with essential concepts and techniques, from repositories and branches to commits and merges.

**Command Chronicles:** Explore vital Git commands such as `git help` and `git pull` to equip yourself with the skills and confidence needed to navigate Git effectively.


Chantastic

In this tutorial, you'll elevate your Git skills, learning from mistakes and unearthing lesser-known tricks that will help you in your everyday life as a developer.

Intro to Git Fundamentals

Improve your daily Git usage by learning essential help commands, including tutorials and subcommand instructions for a smoother workflow.

Git Help Options

Learn how to use the git init command to create and initialize new git repositories, and explore the hidden .git directory.

Creating a Git Repository with `git init`

Learn how to use git status command to view repository information, track and commit changes, and understand the importance of the .git directory.

Git Status and the Hidden .git Directory

Learn how to manage the staging area before creating a commit by utilizing the git reset command to exclude files and changes.

Using `git reset` to Refine Your Staging Area

Learn how to configure Git with your user information so it shows up in your commits.

Setting Up Git Configuration for Commits

Learn how to manage your code with git by committing changes, staging files, and checking the status of your working tree.

Understanding Git Commit, Add, and Status

Discover how to inspect and navigate through git commit history using `git show` and various arguments, such as commit SHA and aliases.

Inspecting Commit History with `git show`

Learn how to efficiently add, reset, and amend git commit messages with a step-by-step exercise on staging and committing changes.

Interactive Git Staging

Learn how to customize the git log output to display concise and relevant commit information. We'll be using different flags and config settings to achieve the perfect git commit overview.

Optimizing Git Log Output for Better Workflow

Learn how to synchronize local and remote repositories on GitHub, along with understanding the usage of git remote, git branch, and git push commands for seamless collaboration.

Syncing Local and Remote Git Repositories with GitHub

Learn how to use Git push to sync your local commits to a remote repository, ensuring your code stays up-to-date across platforms.

Syncing Local Commits with Remote Repository

Learn the importance of syncing your remote commits to your local repository using Git and how to do it by running the git pull command.

Syncing Remote Commits to Local Repository

Learn about the two underlying commands of Git Pull, Git Fetch and Git Merge, and how they are used to update your local and remote branches.

Keeping Branches Updated

Learn how to create, switch, and merge branches in Git, and see how to sync them with your remote repository in GitHub for effective collaboration.

Branch Management and Syncing with Git and GitHub

Take a moment to feel proud of completing this Git course and get ready to explore more tutorials and workshops on Epic web!

Git Fundamentals

Git Fundamentals

Transcript

Git Tracking and Staging Files

Create Files with `echo`

Transcript

Git Fundamentals

Git Fundamentals

Transcript

Create Files with echo

Transcript

Create Files with `echo`