Introduction

Git does not commit directly from the working tree. It commits the staged snapshot in the index. That is why committing specific lines from a file really means staging only the hunks or edited patch fragments you want, then creating the commit from that staged subset.

Start with Interactive Staging

The standard tool is git add -p:

git add -p path/to/file

Git shows one hunk at a time and asks what to do. The common responses are:

• 'y to stage the hunk'
• 'n to leave it unstaged'
• 's to split the hunk into smaller pieces'
• 'e to manually edit the patch'

This is usually enough when the changes are already separated into reasonably clean hunks.

Split Hunks When Git Groups Too Much Together

If Git shows one large hunk that mixes unrelated edits, try s first. Git will split the hunk when it can:

git add -p path/to/file
# then type s

That is the easiest way to get closer to “specific lines” without editing the patch manually.

Edit the Patch When You Need Exact Lines

When splitting is not enough, use e to edit the patch text directly. Git opens a patch buffer where you can remove lines from the staged hunk while keeping the lines you want to include.

This is powerful, but it requires care because the edited patch still has to be valid. If you remove context incorrectly, Git may reject it.

Verify the Staged Snapshot Before Committing

After interactive staging, inspect what will actually be committed:

git diff --staged

This step matters. It confirms that only the intended lines are in the index and avoids surprises in the final commit.

Then commit normally:

git commit -m "Commit only the selected lines"

Keep the Working Tree Intact

One of the best parts of this workflow is that unstaged lines remain in your working tree. You are not forced to throw away or stash the rest of the file just to make a focused commit.

That makes partial commits useful when:

• one file contains unrelated fixes
• you want a small reviewable commit
• you discovered cleanup work mixed with the main change

Small Commits Still Need Coherent Meaning

Partial staging is most useful when the selected lines still form a coherent change. If the chosen lines only make sense together with unstaged edits, split the code differently before committing.

Common Pitfalls

• Thinking Git commits directly from the file instead of from the staged index.
• Skipping git diff --staged and committing more than intended.
• Relying on interactive staging when the file is too tangled and should really be split or cleaned up first.
• Editing the patch manually without understanding that the patch still has to remain valid.
• Using partial commits to hide messy work instead of improving the change structure when possible.

Interactive Staging Is a Review Tool Too

Running through hunks one by one often reveals that a file contains more unrelated edits than expected. That makes partial staging useful not only for commit construction but also for checking whether the change set is structured well.

Summary

• To commit specific lines, stage only those lines with git add -p.
• Use s to split hunks and e to edit a patch manually when necessary.
• Review the staged result with git diff --staged before committing.
• Git commits the index, not the entire working tree.
• Partial commits are powerful, but they work best when the file changes are still logically understandable.