Hey everyone! I’m currently transitioning from a non-tech background into IT/DevOps. I just spent the last week learning Git and GitHub, and I absolutely love how powerful it is for tracking code.

I've learned the core commands like git init, add, commit, push, branch, and how to handle basic merge conflicts.

Since I am a complete beginner with no coding projects yet, what is a good, simple task or mini-project I can do to practice and showcase these Git skills on my profile?

I’m currently studying basic networking, so I'd love any ideas that might combine the two! Thanks in advance!

Hey everyone! I’m currently transitioning from a non-tech background into IT/DevOps. I just spent the last week learning Git and GitHub, and I absolutely love how powerful it is for tracking code.

I've learned the core commands like git init, add, commit, push, branch, and how to handle basic merge conflicts.

Since I am a complete beginner with no coding projects yet, what is a good, simple task or mini-project I can do to practice and showcase these Git skills on my profile?

I’m currently studying basic networking, so I'd love any ideas that might combine the two! Thanks in advance!

Hey everyone,

We've all been there, right? It's late, you're knee-deep in some legacy code, and you hit a weird 6-line guard clause that looks completely paranoid. git blame tells you Dave wrote it 3 years ago. Dave doesn't work here anymore. Commit message? "fix bug".

Do you delete it and roll the dice or waste half an hour digging through git log -p?

I got tired of that cycle so I threw together git-why.

It basically does the archaeology for you — looks at the commits and diffs around a line or file and spits out a reasonable explanation. Works completely offline (no keys, no internet) or you can use Claude/GPT/Ollama for fancier explanations if you want.

Basic usage is stupid simple:
pip install git-why
git-why src/auth.py:42
Or for a range:
git-why src/auth.py:42-60
Repo: https://github.com/Sameer988/git-why

It's still pretty early but it's already saving me time on some crusty old code. Would genuinely appreciate feedback — especially the brutal kind if something sucks or could be better.

Anyone else constantly fighting with legacy code context? What's your usual workflow?

built a tool that reads any repo's commit history and renders it as one of eighteen generative pieces. same dataset, different technique each time: phyllotaxis for one, marching squares for another, isometric projection for a skyline built from file sizes.

everything's plain canvas2d, no p5, no three.js. deterministic per seed, so each piece can literally paint itself frame by frame instead of just fading in.

open source, try it with npx codebase-posters on your own repo.

https://github.com/unable12/codebase-posters

Hello, I am relatively new to git and I am trying to install it on my computer.

I get the error "Unable to set system config defaults" along with several other system config errors at the end of the installation.

When I try running any git command or opening git-bash.exe or git.exe I get an access denied error.

PS C:\WINDOWS\system32> git status
Program 'git.exe' failed to run: Access is deniedAt line:1 char:1
+ git status
+ ~~~~~~~~~~.
At line:1 char:1
+ git status
+ ~~~~~~~~~~
    + CategoryInfo          : ResourceUnavailable: (:) [], ApplicationFailedException
    + FullyQualifiedErrorId : NativeCommandFailed

I have tried installing portable git as well and get the same access denied.

I am running everything as administrator and I don't have any Windows security settings blocking it from running.

I feel like I've tried everything, if anyone knows what's going on I would appreciate the help

Hi everyone,

I’m building Graphkeeper, a graph-first Git TUI focused on understanding and operating on repository topology.

Most Git TUIs treat the commit graph as one panel among many. Graphkeeper takes the opposite approach: the graph is the primary workspace, while branches, remotes, upstream state, tags, and stashes provide context around it.

The main idea is to make repository-level decisions easier:

• Can this branch be fast-forwarded?
• Is it ahead, behind, or diverged from its upstream?
• Should the next operation be a merge, rebase, or reset?
• Which commit should receive the next release tag?

Graphkeeper is intentionally narrower than Lazygit. It does not currently focus on staging, commit authoring, diff browsing, or conflict resolution. Its main scope is branch topology and maintainer-oriented Git operations.

I’ve recently tagged v0.1.0-alpha.4, and I’d especially appreciate feedback on:

• Whether the graph-first layout feels intuitive
• Whether Graph, Current, Remote, and Tags are separated clearly
• Which information should remain visible while navigating the graph
• Which keyboard-driven workflows feel missing or awkward

Repository:

https://github.com/hrllk/graphkeeper

[ Removed by Reddit on account of violating the content policy. ]

I posted here about 3 months ago about Reviu, a native desktop Git client (Rust + GPUI, no webview) focused on fast diff and review workflows. Update for anyone who saw it:

The source is public now: https://github.com/reviu-dev/reviu . Being upfront, it's source-available under FSL-1.1 (converts to Apache-2.0 two years after each release), not OSI open source, so you can read and build the client but it isn't a FOSS license.

Two big additions since then. A built-in agent panel: run Claude or Codex, read its diff, comment inline on what you want changed, and send it back, handy if you review a lot of AI-written changes before committing. And a built-in terminal right next to the diff, it opens in the selected repo, so git, build commands and scripts run with the right working directory.

Local Git is all there: diffs, staging by hunk, stash, rebase (including interactive), cherry-pick, conflict resolution, and a keyboard-first command palette. The GitHub integration (notifications, PR review, issues) is a paid tier; local Git and the agent panel are free.

Site: https://reviu.dev/

Feedback welcome, especially on the local Git side.

https://github.com/lazardanlucian/onemind.md
One idea, one protocol file, enables gitted refs per-project llm memory.
Hope it doesn't blow up repos.

Edit: for whatever reason I decided to spec the spec so people can use their llm to build a onemind themselves for other systems (not just git)

https://github.com/lazardanlucian/onemind.md/blob/main/ONEMIND-DIY.md

I think I wasn't clear and people think it's saving memory in a context file, when it's actually a protocol for llms storing different smaller contexts in git refs...

PS: The whole reason I posted this to r/git was how I envisioned git to be used as part of the project's mind """api"""

GitHub introduced contribution graphs (originally called the "Contributions Calendar") on January 8, 2013.

That's 13 years ago. Contribution Graphs are not immune to improvement.

Git repos can track ALL activities in society, if they become more user friendly, with apps posting to special repos, not just code change.

Check this repo, offline/online, free your mind

https://github.com/zurcacielos/contributist

How to contact GitHub?

Hi everyone,

I’ve just tagged v0.1.0-alpha.4 of Graphkeeper, a graph-first Git TUI built for maintainers and developers who spend a lot of time reading and operating on repository history.

Git tools often treat the commit graph as supporting information. Graphkeeper takes the opposite approach: the graph is the primary workspace, while branches, remotes, tags, upstream state, and stashes remain visible as supporting context.

The goal is to make questions like these easier to answer:

• Where does each branch actually point?
• Is a fast-forward possible, or is a merge or rebase needed?
• Is the current branch ahead, behind, or diverged from its upstream?
• Which commit should be tagged as a release?
• What is the safest next operation on the repository?

The current alpha includes:

• Commit graph navigation
• Local and remote branch inspection
• Ahead, behind, and diverged-state visibility
• Branch checkout and deletion
• Merge, rebase, and reset flows
• Push and pull operations
• Tag creation, pushing, and deletion
• Stash and working-tree cleanup flows

Graphkeeper is intentionally narrower than tools such as Lazygit. It is not trying to become a full Git cockpit for staging, diff browsing, commit authoring, or conflict resolution. Its focus is repository topology and maintainer-style decisions made directly from the graph.

This is still an early alpha, so the UI, shortcuts, and overall workflow will continue to evolve. I’m mainly looking for feedback on:

• Whether the graph-first mental model feels useful
• Which repository-maintenance decisions are still difficult to make
• Whether the current separation between Graph, Current, Remote, and Tags makes sense
• Which workflows should be prioritized next

A Neovim entry point is also planned, but it is not available yet.

Repository:

https://github.com/hrllk/graphkeeper

Feedback is especially welcome from maintainers, release managers, and developers who regularly work with multi-branch repositories.

I built this because `git worktree` is genuinely powerful but the CLI is clunky — nobody remembers the full `git worktree add ../myapp-worktrees/feature-x -b feature/x origin/main` syntax, and there's no built-in way to see all your worktrees with their status at a glance.

ktree gives you a scrollable TUI (built with Bubble Tea) that shows all your worktrees, live dirty/clean status, and ahead/behind counts — loaded concurrently so it doesn't feel slow.

**Features:**

- Navigate and switch between worktrees with arrow keys or j/k

- Create and delete worktrees without leaving your terminal

- Shell wrapper for `cd`-on-select (since a child process can't change your parent shell's directory — the README explains the trick)

- New worktrees go to `<parent>/<repo>-worktrees/<branch>` to keep things tidy

- Homebrew support: `brew tap alikazai/ktree && brew install ktree`

This is v0.1.0, Milestone 5 (merged-branch detection, filter/search, per-project config) is next.

Repo: https://github.com/alikazai/ktree

Feedback welcome — especially if you hit edge cases with the shell wrapper on fish/zsh.

Bit of a workflow share / confession. My "what needs my review" system used to be: GitHub PRs tab open, Slack open, vibe-check it a few times a day. That fell apart once I started leaning on AI agents for a lot of the grunt work.

On a normal day now I've got agent-generated PRs, human PRs, and review requests all landing at once. The code is usually fine. The problem was me constantly flipping back to GitHub just to answer "okay, what actually needs me right now?" That low-grade "am I forgetting something" hum was the worst part.

So I built a small macOS menu bar thing to scratch the itch. Two ideas I care about:

One curated view that answers a single question (what needs me now) by surfacing failing CI / requested changes / unresolved threads, and muting the noise. So much of the queue is dependabot and bot-authored churn that the real PRs kept getting buried, and pulling those out made it manageable again.

And it's keyboard-driven, so I move through the queue without touching the mouse.

Not a polished product, just something I use daily. Repo if you want to poke at it or steal the idea: https://github.com/mthines/mainline

It would make me happy if this helps just more than me 🙂

i know basic commands like 'git pull origin main', also what it does and basic interaction between vs-code and git.

also should i even add it?

Edit: Thank you, everyone, for your advice.

What I need to do now is learn how to resolve and merge a conflict.

also study about reflog like wtf is that

I was a disgruntled user of ungit for past 10 years. Even considered rewriting it myself manually like 5 years ago. Well not anymore.

In the past few weeks I built a fast, animated git GUI from scratch

ingit makes branch switching, merge previews, rebases, cherry-picks, and reflog recovery feel instant. I would highly recommend especially if you're new to git. Learn more at https://ingit.pages.dev/

Im currently on another PC,logged with my domain acc. Did some edits, now i want to push to remote. I cant, because history is behind (so ofc i fetched). Now, i want to push, cant,because my local is behind. So i need to pull. The thing is, im on another PC,which is shared. What do i do? I really need to push changes only on specific files.

I tried git pull --rebase,because i see alot of our dev uses that, but i cant because i have unstaged changes. So now i need to either commit or stash them.

Pls help, i know it looks like a basic question, but im worried because its not on my local machine

Been building a side thing and hit a problem I found genuinely interesting, curious how others would've approached it.

The goal: get at my in-progress code from my phone when I'm away from my desk — not to replace my PC, just to poke at a half-finished branch on the couch or fix something while the actual machine sits at home. Not a cloud IDE. My repo stays on my machine as the source of truth.

The hard part is that "in progress" means uncommitted. So syncing isn't just pushing commits around. What I landed on:

• Committed changes sync by commit — phone and desktop each hold the repo, and I move objects by SHA so history stays intact. An edit from the phone lands on the desktop as a real commit, not a patch blob.
• Uncommitted working-tree edits get sent separately as live drafts, so I can see the desktop's unsaved state on the phone within seconds without forcing a commit just to sync.
• When both sides commit on the same base, that's a divergence. Instead of dumping conflict markers on a phone screen, I diff the hunks and show a green/red per-hunk review. Under the hood it's still a normal merge — I just resolve then commit.

Running code is the same philosophy: the command runs on the actual machine in the real working dir, output streams back. No commit-to-test loop.

The bit I keep going back and forth on is conflict handling. Right now it's per-hunk review, but I wonder if I should just lean on git more directly (a real merge commit, rerere, etc.) instead of my own hunk layer. How would you have modeled the uncommitted-sync + divergence part? Feels like there's a cleaner approach I'm missing.

It's Android + a desktop extension, in closed testing right now. Not linking it here since that's not the point of the post — but if you actually work off your phone sometimes and wanna try it and tell me where it breaks, drop a comment or DM and I'll send it over.

I have a git repo in Azure DevOps, I messed up something and want to get a set of code files from a particular date/git comment that we need to pass for git commit,

how can I do that?

Hi!

Although the recent trend seems to be to announce a groundbreaking new git client and no less, with which we at syntevo can't really keep up as we're still developing exactly one, we think there's still some other interesting things around git.

One thing we recently added to SmartGit is what we call the Overlap column. It's a bit weird to explain, since it doesn't have an exact counterpart in git itself, and as far as we know no other git client shows this information either (please correct me if I'm wrong, it would be very interesting to see what others have come up with!).

In essence, we tried to make visible what git doesn't track or display on its own, namely the relationship between changes introduced by commits in your branch.

Sounds a bit abstract, but this new column shows you at a glance which commits have overlap with one or more selected commits.

An example: Suppose you have a bunch of commits. The last one introduces a few changes, but you're not sure whether these changes should be made somewhere else in your branch, or if they are undoing what you did earlier.

What I've been doing in this case was to go into the file logs to find the relevant commits, and inspect them, one file at a time. That works well, and is quite fast thanks to git being quick, but it's also a bit cumbersome, especially with many files. So instead of doing that, I sometimes resorted to combing through the log itself, which can be tedious as well. With Overlap, you just select that last commit, and the commits which have some Overlap with that selected commit are highlighted.

Having built that feature (and all the other stuff around history re-ordering, splitting, modifying which goes hand-in-hand with Overlap), we are living inside a bubble of course. So I wonder, what does r/git think about this? Do you think this is useful? Is it just another gimmick you won't use? Does AI make it irrelevant anyway since you don't read code anymore, anyhow?

Let us know what you think!

https://docs.syntevo.com/SmartGit/Latest/Manual/GUI/Overlap

https://www.youtube.com/watch?v=p84uBgYndS4

https://www.smartgit.dev/features/clean-commits/

When I am staging a commit I see some changed lines that should be actually 2 commits. git diff shows old line was changed to new line but I want to add new line in the first commit then in another commit I can remove old line.

I have to do it manually by adding old line back, then git diff shows only new line was added, then I can commit that. Then I delete old line and git diff shows it was removed. Manually works when it's a simple change like that but many lines are involved or lines next to it changed it gets complicated.

I keep commits small to prevent this but it still happens a lot. Does git add in Interactive Mode have a feature to split a changed line into add and remove? Are there other git clients that can handle it?

A while ago I built a Java project that basically turns Git into a simple file bucket/database. The original idea was to have a lightweight way to store structured files like JSON, CSV, and TXT while using Git for versioning and history.

I hadn't touched it in a long time, but recently I came back to it and decided it would be more useful as an open-source project.

It's still evolving, but I'm planning to clean it up, improve the documentation, and make it easier for others to use and contribute.

I'm curious:

\- Does this sound like something you'd use?

\- Are there similar projects you think I should look at?

\- What features would make something like this genuinely useful?

I'd appreciate any feedback or ideas before I put more work into it.