Working directory state in Git - Step-by-Step Execution

Process Flow - Working directory state

Start: Git repo initialized

↓

Working directory files

↓

Modify/Add/Delete files

↓

Working directory state changes

↓

Check status with 'git status'

↓

See which files are modified, staged, or untracked

↓

Decide to stage or discard changes

↓

End: Working directory reflects current file changes

This flow shows how files in the working directory change and how git tracks their state before committing.

Execution Sample

Git

git status
# Shows current state of working directory and staging area

This command displays which files are modified, staged, or untracked in the working directory.

Process Table

Step	Action	Working Directory State	Git Status Output Summary
1	Initialize repo with 'git init'	Empty directory with .git folder	On branch main No commits yet nothing to commit (create/copy files and use "git add" to track)
2	Create file 'file1.txt'	file1.txt created, untracked	Untracked files: (use "git add <file>..." to include in what will be committed) file1.txt
3	Run 'git status'	file1.txt untracked	Untracked files: (use "git add <file>..." to include in what will be committed) file1.txt
4	Add file1.txt with 'git add file1.txt'	file1.txt staged	Changes to be committed: (use "git restore --staged <file>..." to unstage) new file: file1.txt
5	Modify file1.txt	file1.txt modified but staged version unchanged	Changes to be committed: (use "git restore --staged <file>..." to unstage) new file: file1.txt Changes not staged for commit: (use "git add <file>..." to update what will be committed) (use "git restore <file>..." to discard changes in working directory) modified: file1.txt
6	Run 'git status'	file1.txt staged and modified	Changes to be committed: (use "git restore --staged <file>..." to unstage) new file: file1.txt Changes not staged for commit: (use "git add <file>..." to update what will be committed) (use "git restore <file>..." to discard changes in working directory) modified: file1.txt
7	Delete file1.txt	file1.txt deleted from working directory	Changes to be committed: (use "git restore --staged <file>..." to unstage) new file: file1.txt Changes not staged for commit: (use "git add/rm <file>..." to update what will be committed) (use "git restore <file>..." to discard changes in working directory) deleted: file1.txt
8	Run 'git status'	file1.txt staged and deleted in working directory	Changes to be committed: (use "git restore --staged <file>..." to unstage) new file: file1.txt Changes not staged for commit: (use "git add/rm <file>..." to update what will be committed) (use "git restore <file>..." to discard changes in working directory) deleted: file1.txt
9	Exit	Working directory reflects current file changes	Execution stops: user ends checking working directory state

💡 User finishes checking working directory state with 'git status' commands

Status Tracker

Variable	Start	After 2	After 4	After 5	After 7	Final
file1.txt state	Does not exist	Untracked (created)	Staged (added)	Modified (unstaged changes)	Deleted (unstaged)	Deleted (unstaged)

Key Moments - 3 Insights

Why does 'git status' show a file both under 'Changes to be committed' and 'Changes not staged for commit'?

Because the file was staged earlier but then modified again without staging the new changes. See steps 5 and 6 in the execution_table where file1.txt is staged but also modified afterward.

What does it mean when a file is 'untracked' in the working directory?

It means the file exists in the directory but git is not tracking it yet. This is shown in step 2 and 3 where file1.txt is created but not added to staging.

Why does deleting a file show up as 'Changes not staged for commit'?

Because the file was deleted from the working directory but git has not yet staged that deletion. See steps 7 and 8 where file1.txt is deleted but the deletion is unstaged.

Visual Quiz - 3 Questions

Look at the execution_table at step 4. What is the state of file1.txt?

A Untracked

B Staged for commit

C Modified but unstaged

D Deleted

💡 Hint

Check the 'Working Directory State' and 'Git Status Output Summary' columns at step 4.

At which step does 'git status' show file1.txt as both staged and modified?

A Step 3

B Step 7

C Step 5

D Step 2

💡 Hint

Look for the step where the status output lists both 'Changes to be committed' and 'Changes not staged for commit'.

If you delete a file but do not stage the deletion, how does 'git status' show it?

A As a deletion not staged for commit

B As a staged deletion

C As a new untracked file

D As unchanged

💡 Hint

Refer to steps 7 and 8 in the execution_table for how deletions appear before staging.

Concept Snapshot

Working directory state shows current file changes in your project folder.
Use 'git status' to see untracked, modified, and staged files.
Files start untracked, then you 'git add' to stage them.
Modifying staged files shows them as modified but unstaged.
Deleting files without staging shows as unstaged deletions.
Always check 'git status' before committing.

Full Transcript

The working directory state in git reflects the current condition of files in your project folder. When you create a new file, it is untracked until you add it to staging with 'git add'. If you modify a staged file, git shows it as both staged and modified. Deleting a file without staging the deletion shows it as unstaged deletion. The 'git status' command helps you see these states clearly so you know what will be committed or needs attention.

Practice

1. What does the git status command show you about your working directory?

easy

A. It shows which files are new, modified, or staged for commit.

B. It deletes all untracked files from the directory.

C. It permanently commits all changes to the repository.

D. It resets the repository to the last commit.

Solution

1. Step 1: Understand the purpose of git status

   This command checks the current state of the working directory and staging area.

2. Step 2: Identify what git status reports

   It lists new files, modified files, and files staged for commit, helping you track changes.

3. Final Answer:

   It shows which files are new, modified, or staged for commit. -> Option A

4. Quick Check:

   Working directory changes = git status output [OK]

Hint: Remember: git status shows current file changes and staging [OK]

Common Mistakes:

• Confusing git status with git commit
• Thinking git status deletes files
• Assuming git status changes files automatically

2. Which of the following commands correctly stages a file named app.js for commit?

easy

A. git commit app.js

B. git status app.js

C. git add app.js

D. git push app.js

Solution

1. Step 1: Identify the command to stage files

   The git add command is used to add files to the staging area.

2. Step 2: Confirm the correct syntax for staging a specific file

   Using git add app.js stages the file named app.js for the next commit.

3. Final Answer:

   git add app.js -> Option C

4. Quick Check:

   Stage files = git add [OK]

Hint: Use git add to stage files before committing [OK]

Common Mistakes:

• Using git commit to stage files
• Trying to use git status to stage
• Using git push before commit

3. Given the following sequence of commands, what will git status show about index.html?

echo 'Hello' > index.html
git add index.html
echo 'World' >> index.html
git status

medium

A. index.html is staged and has unstaged changes.

B. index.html is deleted.

C. index.html is untracked.

D. index.html is staged and unchanged.

Solution

1. Step 1: Analyze the commands on index.html

   First, 'Hello' is written and the file is staged with git add. Then 'World' is appended, modifying the file after staging.

2. Step 2: Understand git status output

   Git will show index.html as staged (with 'Hello') but also as modified (unstaged changes with 'World').

3. Final Answer:

   index.html is staged and has unstaged changes. -> Option A

4. Quick Check:

   Modified after staging = staged + unstaged changes [OK]

Hint: Changes after git add show as unstaged modifications [OK]

Common Mistakes:

• Assuming staging updates automatically after file change
• Thinking file is untracked after git add
• Confusing staged with committed

4. You ran git add README.md but git status still shows README.md under 'Changes not staged for commit'. What is the likely cause?

medium

A. README.md is ignored by .gitignore.

B. You modified README.md after running git add.

C. You committed README.md already.

D. README.md is deleted from the working directory.

Solution

1. Step 1: Understand git add and file modification

   Running git add stages the current file state. If the file changes after, those changes are unstaged.

2. Step 2: Interpret git status showing unstaged changes

   If README.md appears under 'Changes not staged for commit', it means it was modified after staging.

3. Final Answer:

   You modified README.md after running git add. -> Option B

4. Quick Check:

   Modify after add = unstaged changes shown [OK]

Hint: Modify after git add causes unstaged changes [OK]

Common Mistakes:

• Assuming git add stages future changes automatically
• Thinking .gitignore affects already tracked files
• Confusing committed files with staged files

5. You want to prepare a commit but accidentally staged a large file secret.txt. How can you remove it from the staging area without deleting the file from your working directory?

hard

A. git checkout secret.txt

B. git rm secret.txt

C. git clean secret.txt

D. git reset secret.txt

Solution

1. Step 1: Understand the difference between unstaging and deleting

   To remove a file from staging but keep it in the working directory, you must unstage it.

2. Step 2: Identify the correct command to unstage a file

   git reset secret.txt removes the file from the staging area without deleting it from disk.

3. Final Answer:

   git reset secret.txt -> Option D

4. Quick Check:

   Unstage file = git reset filename [OK]

Hint: Use git reset to unstage files without deleting [OK]

Common Mistakes:

• Using git rm deletes the file from disk
• Using git checkout resets file content, not staging
• Using git clean deletes untracked files