DEV Community: Parthiv

30 Git Commands Every Developer Uses Regularly (With Practical Examples)

Parthiv — Thu, 06 Aug 2026 05:57:50 +0000

Git is one of those tools you'll use almost every day, whether you're building applications, collaborating with a team, or managing deployment pipelines. While there are hundreds of Git commands available, only a handful become part of your daily workflow.

This guide covers 30 practical Git commands that every developer, DevOps engineer, and software engineer should know. Instead of memorizing them, focus on understanding when to use each one.

1. Initialize a Repository

git init

Creates a new Git repository in your current project folder so version control can begin.

2. Clone an Existing Repository

git clone <repository-url>

Downloads an existing Git repository from GitHub or another Git provider to your local machine.

3. Check Repository Status

git status

Shows modified, staged, and untracked files so you always know the current state of your project.

4. Stage Specific Files

git add <filename>

Adds selected files to the staging area before creating a commit.

To stage everything:

git add .

5. Commit Your Changes

git commit -m "Describe your changes"

Saves the staged changes as a new snapshot in the repository with a meaningful commit message.

6. Upload Changes

git push

Pushes your local commits to the remote repository.

7. Download Latest Changes

git pull

Fetches updates from the remote repository and merges them into your current branch.

8. View Commit History

git log

Displays the project's commit history along with author information and timestamps.

9. List All Branches

git branch

Shows every local branch available in your repository.

10. Create a New Branch

git checkout -b feature/login

Creates a new branch and immediately switches to it.

11. Switch Between Branches

git checkout main

Moves your working directory to another branch.

12. Merge Another Branch

git merge feature/login

Combines changes from another branch into your current branch.

13. View Remote Repositories

git remote -v

Displays the configured remote repositories and their URLs.

14. Add a Remote Repository

git remote add origin <repository-url>

Connects your local repository to a remote Git server.

15. Remove a Remote

git remote remove origin

Deletes a configured remote repository.

16. Compare Changes

git diff

Shows the differences between your working directory, staged files, and commits.

17. Fetch Without Merging

git fetch

Downloads the latest commits from the remote repository without changing your current branch.

18. Save Work Temporarily

git stash

Temporarily stores uncommitted changes so you can switch tasks without committing unfinished work.

Restore them later:

git stash pop

19. Unstage a File

git reset <filename>

Removes a file from the staging area while keeping your local modifications.

20. Delete a Tracked File

git rm <filename>

Deletes a file and stages that deletion for the next commit.

21. Configure Git Identity

git config --global user.name "Your Name"
git config --global user.email "you@example.com"

Sets the default identity used for all your commits.

22. Create a Version Tag

git tag v1.0.0

Creates a tag that marks an important release or milestone.

Push tags using:

git push --tags

23. Delete a Branch

git branch -d feature/login

Removes a branch that has already been merged.

24. Rebase a Branch

git rebase main

Moves your branch on top of another branch to maintain a cleaner project history.

25. Abort a Merge Conflict

git merge --abort

Cancels an ongoing merge and restores the repository to its previous state.

26. Apply a Single Commit

git cherry-pick <commit-hash>

Copies a specific commit from another branch without merging the entire branch.

27. Remove Stale Remote Branches

git fetch --prune

Deletes local references to remote branches that no longer exist.

28. Clean Untracked Files

git clean -df

Removes untracked files and folders from your working directory.

Use this carefully because deleted files cannot be recovered through Git.

29. Initialize Git Submodules

git submodule update --init --recursive

Downloads and initializes all project submodules.

This is commonly required after cloning repositories that depend on external projects.

30. Clone with Submodules

git clone --recurse-submodules <repository-url>

Clones the repository and automatically downloads all associated submodules in one step.

Final Thoughts

Learning Git isn't about memorizing every available command. It's about becoming comfortable with the commands you'll use repeatedly throughout development.

If you can confidently work with branching, committing, merging, fetching, rebasing, and resolving conflicts, you'll be prepared for most real world Git workflows.

Which Git command do you use the most? Share it in the comments, and if you think I missed one that deserves a place in this list, I'd love to hear your suggestions.

Happy coding! 🚀

I Replaced My Coding Assistant with Kimi K3 for a Week. Here's What Every Developer Should Know

Parthiv — Tue, 28 Jul 2026 04:58:46 +0000

Artificial Intelligence models are improving so quickly that it's difficult to know which ones deserve your attention.

One week it's GPT.

The next it's Claude.

Then Gemini launches another update.

Now there's Kimi K3, an open source model that's generating serious discussion across the developer community.

Instead of repeating benchmark charts, I wanted to answer a more practical question.

If you're actually building software, should you spend time learning Kimi K3?

After exploring its architecture, API, coding capabilities, and developer ecosystem, here's what I found.

Why Developers Are Talking About Kimi K3

Most AI model launches sound similar.

Better benchmarks
Faster inference
Lower cost

Kimi K3 is interesting for a different reason.

It combines several characteristics that rarely appear together in one model.

Open weights
Extremely long context window
Competitive coding capabilities
Modern Mixture of Experts (MoE) architecture
Production ready API
Native developer workflows

That combination makes it attractive for developers who want more control than proprietary AI models typically provide.

What Makes Kimi K3 Different?

Most articles immediately jump into parameter counts.

That's not the first thing developers should care about.

Instead, ask yourself one simple question.

Can this model actually solve the problems I face every day?

For most software engineers, those problems include:

Understanding massive repositories
Debugging production issues
Generating new features
Reviewing pull requests
Analysing documentation
Writing unit tests
Refactoring legacy applications

These are the kinds of long running engineering tasks Kimi K3 is designed to handle.

Rather than focusing only on isolated benchmark questions, it targets real developer workflows involving large codebases and extended reasoning sessions.

A Developer's First Impression

Imagine opening a repository containing:

600+ source files
Architecture documents
API specifications
Database schema
Deployment scripts
CI/CD configuration
Internal documentation

With many language models, you end up splitting the repository into smaller chunks and repeatedly providing context.

Kimi K3 approaches this differently.

Its massive context window allows much larger portions of a project to be analysed together, reducing context switching and repeated prompting. That capability comes from its long context design and hybrid attention architecture.

For developers working on enterprise software, that's a meaningful productivity improvement.

Who Should Actually Use Kimi K3?

Not every developer needs another AI model.

However, Kimi K3 is worth exploring if you regularly work on any of the following.

Large Backend Applications

Projects built with:

Python
Java
Go
Node.js
Rust

Large applications often contain hundreds or even thousands of interconnected files.

Understanding relationships across those files is where long context models become valuable.

Enterprise Software

If you're building systems such as:

ERP platforms
CRM solutions
Healthcare software
FinTech products
Logistics platforms
Manufacturing software

there's a good chance your application contains years of accumulated business logic.

Models capable of analysing much larger codebases at once can often provide more useful answers than those limited to smaller contexts.

AI Agent Development

Kimi K3 is also interesting if you're building:

AI agents
Coding assistants
Automation workflows
Document analysis systems
Knowledge assistants
Customer support applications

Its combination of open weights and long context makes it attractive for developers building production AI applications.

What Can You Actually Build?

Here are a few practical ideas beyond simple chatbots.

1. Repository Assistant

Upload an entire project and ask questions like:

Where is authentication implemented?
Which endpoints still use the old middleware?
Which services generate customer invoices?
Which files should I update for multi tenant support?

Instead of searching manually, the model becomes your project navigator.

2. Documentation Generator

Most teams postpone documentation because it's time consuming.

Kimi K3 can analyse an entire repository and generate:

Architecture documentation
API references
Onboarding guides
Developer documentation
Dependency explanations

That saves hours of manual work.

3. AI Code Reviewer

Build an internal reviewer that checks for:

Security issues
Performance bottlenecks
Naming inconsistencies
Architecture violations
Duplicate code
Missing error handling

before code reaches a human reviewer.

4. Internal Knowledge Assistant

Large organisations often maintain thousands of pages of documentation.

Instead of employees searching across multiple systems, an AI assistant powered by Kimi K3 can answer questions using a much larger understanding of internal knowledge.

Why Open Weight Models Matter

One of the biggest reasons developers are excited isn't simply benchmark performance.

It's ownership.

With open weight models, organisations have significantly more flexibility.

They can potentially:

Deploy on private infrastructure
Fine tune for company specific tasks
Reduce vendor lock in
Experiment with new research
Build custom inference pipelines
Maintain greater control over sensitive data

For businesses operating in regulated industries, those capabilities can be just as important as raw model performance. The reference article also highlights open weights as one of Kimi K3's defining advantages.

Is Kimi K3 Perfect?

Not quite.

Like every language model, it has trade offs.

Developers should still evaluate:

Response speed
Infrastructure requirements
API pricing
Production reliability
Compatibility with existing workflows

Choosing an AI model isn't about selecting the one with the highest benchmark score.

It's about selecting the one that fits your team's workflow.

Final Thoughts

Kimi K3 isn't simply another large language model entering an already crowded market.

It represents another step toward open models becoming genuinely competitive with proprietary alternatives.

Whether you're building AI agents, maintaining enterprise software, or experimenting with developer tools, Kimi K3 is worth exploring because it combines long context, strong coding capabilities, and the flexibility that comes with open weights.

This article only scratches the surface.

In the next part, I'll walk through building a real application with the Kimi K3 API, including project setup, authentication, API integration, prompt engineering, and production best practices.

I'd Love Your Feedback

The AI ecosystem is evolving incredibly fast, and Kimi K3 is one of the most interesting open weight releases I've looked at recently. Rather than focusing only on benchmark numbers, I wanted to create a practical guide that helps developers decide whether it's worth trying in real projects.

Have you experimented with Kimi K3 yet?

What are you planning to build with it?
How does it compare with GPT or Claude in your experience?
What challenges have you run into?

Share your thoughts or questions in the comments. I'll reply to as many as I can, and your feedback may shape the next article in this series.

If you enjoy practical AI engineering content focused on real world development, consider following my profile for more hands on guides.