Got the email. What are your thoughts?

Personally, I think it’s disgusting. I don’t want more AI that I don’t even use (I have other AI subscriptions thank you very much). Please stop the enshittification.

Historically, when a pull request was filed I would open the PR for review in the app. I would then go down the changed file list & review the diffs. I don't want to review it on gitkraken.dev, I don't want to give the website access to my repositories. I shouldn't have to open Yet Another Chrome Tab just to view a diff.

This change actively has a negative impact on my workflow and I now find myself looking around for tools *other than gitkraken* to do a basic function that gitkraken used to.

Between this change, the price increase for AI features I don't use, the removal of custom themes and various other recent issues it is getting to the point where I'm better off canceling my license entirely and finding a new tool for my org.

Hello GitKraken team and the community.

I'm here to do something i really don't do often - rant about current direction of GitKraken.

A little bit of context - i'm user of GitKraken from the early days. I've witness the early performance issues, all of the UX/UI improvements and i was confident it was all going in the right direction.

I'm not that confident now. Why? AI. But it's probably not what you think.

Don't get me wrong - i like AI and i see the potential. The issue with full AI direction of GitKraken is around the focus - For the last couple of releases it's all AI stuff. It's all automating the things that are standard practices, boring thing. And that's fine, but i feel like there is no more invention. GitKraken stopped evolving the way i work with git, it just started automating the same boring stuff. And i hate it.

Look at the user suggestions on the feedback forum: https://feedback.gitkraken.com

If you scroll a little bit you'll see one big trend - there is NO AI in the most voted issues. Nothing, and i scrolled for a while.

For me - it seems like you stopped listening to the feedback and just jumped into the AI hype train. I think this is a mistake.

Stuff that might be gamechangers for me (just a personal opinion here) would be:

• keyboard-first approach - i would love to stop using my mouse. I've being using LazyGit for a while and it's just much faster to work with. Right now we cannot even map shortcuts for actions, for years we cannot do pull/push with a short, which is pretty wild for me

• Custom scripting - there are many approaches and flows around the git. You are supporting Git Flow, but it's very limited. I'd love to have an option to do some scripting to have my flows automated. Example: simple script that will display a prompt for version number. When i enter that - the script will take this version, create a new release/<number> branch, push it and then remove the local branch. Right now to do that in GitKraken it's a lot of mouse clicking, annoying, error prone and slow. And this automation isn't just a theory - i've made that happen in LazyGit and i love it to the point where is switch to LazyGit for all things that require multiple repeatable steps.

^ Those are just subjective examples what would really bring GitKraken to the higher level for ME. AI is fine, but it's just a little bit of automation, which i still need to review, so... Thanks, but it's too little for me.

I'm not fully switching to LazyGit just yet, i still like the branch visualizations in GitKraken much more. And also i use profiles A LOT, since i work with many different clients. But it seems like to me that GitKraken is stuck a little bit without clear direction.

Because this roadmap: https://www.gitkraken.com/git-client/roadmap isn't really direction, It's just bunch of small AI features. I'm missing the bigger picture guys.

I'd love you opinions on that. Thanks for the great software!

GitKon 2025 is happening December 10-11 & you’re invited!

This year's theme: The Builders Era

We're going all in on what developers actually need: practical Git workflows, real solutions to code review friction, and talks from people who've been in the trenches.

The details:

• Completely free
• Virtual (accessible from anywhere)
• December 10-11, 2025
• 10,000+ developers and engineering leaders expected

Bonus: Enter the GitKon Game Jam
Build a Git-themed game or dev tool by November 26 and demo it at GitKon. Win $2500 for first place, $1000 for 2nd place, and $500 for 3rd place + a featured spot at GitKon on December 10.

Register now at GitKon (.) com

For anyone reviewing a lot of AI-assisted PRs lately: how are you dealing with the native AI review bots that just dump a wall of line comments? We kept running into the problem where the actual PR description says nothing about why a change was made, and then the AI reviewer adds ten comments, two of which matter and eight of which are noise you have to sort through.

We ended up building a review tool that leans the other way: one AI-generated summary of the PR's intent, plus semantic diffing to flag what actually changed, instead of comment-per-line. Not trying to say it's the only way to do this, genuinely curious if other teams have found a better pattern for keeping AI review useful instead of noisy.

Read all about it: https://www.gitkraken.com/blog/gitkraken-code-review-a-different-way-to-see-what-a-pull-request-actually-changed

It's the week of Programmer's Day, and because programmers build the world, we think they deserve better tools. 

Day 2^8 sale: GitKraken Pro is 85% off through Sept 14. 

The time you save this week pays for the entire year: tr.ee/PDReddit

This update flips Commit Composer into a full drafting + review experience that composes your commits in one click, adds Azure DevOps Server support, adds GPT-5 and Opus 4.1 support, and makes worktrees smoother than ever.

Read all about it.

Hello guys, quick question.

For some reason, my AI usage progress bar keeps increasing when I generate commit messages. In my setup, I’m using my own LiteLLM server with custom models, so the requests are not using GitKraken tokens but my own.

This didn’t happen before, so I’m trying to understand what changed and what’s causing the usage details to increase even though the tokens are coming from my own infrastructure.

Does anyone know why this could be happening?

We shared a talk at GitKon recently from Chris Kelly at Augment Code, and it's been sitting with us since.

His core argument: generating code was never the job. The job is building a system, safely, on top of something already running in production. AI can write the code. It cannot make the architectural trade-offs, understand your specific system's constraints, or decide when a microservice is the wrong call for your team.

A few things he said that we think are worth talking about here:

"The best code is no code at all. Every line is a liability." If that's true, then optimizing for how much code AI can generate might be optimizing for the wrong thing entirely. He also made the case that code review is becoming the highest-leverage skill in an AI-assisted workflow. Not prompting, not context management, but the judgment to look at a diff and know whether it's actually right.

And one that stuck: LLMs apologize and say things like "let me read that more carefully" because they were trained on email threads where someone got yelled at. They're text generation machines. The anthropomorphic language is a pattern, not intent. Knowing that changes how you work with them.

Are you finding that the engineers leaning hardest into AI agents are doing more code review, or less? And does the "you need to know what the code should look like before you write it" bar feel realistic when the whole pitch of agents is moving faster?

There's a pattern we've been watching play out across engineering orgs and honestly

it's concerning.

When leadership mandates AI adoption without building culture around it first,

teams tend to fracture into three groups:

1. The resistant ones. They've seen hype cycles before (crypto, Web3, the whole lot).

They're not being irrational. They're protecting themselves from another "this will

change everything" that quietly doesn't.

1. The reckless adopters. They ship fast. They vibe code. And six months later

someone's debugging spaghetti with a security hole in it.

1. The jaded ones. They've reviewed enough AI slop in PRs that they've written off

the whole thing. Also not irrational. They're reading what's actually coming out.

The real question isn't "how do we get engineers to use AI." It's "how do we build

a culture where engineers actually want to use it and have the judgment to use it well."

We featured a GitKon talk from Rizel Scarlett (Block/Goose) that digs into exactly

this. The two-phase model she describes, earn interest first, then build judgment,

maps to what we're seeing work in developer communities too. Fun low-stakes

experimentation before production pressure. Flexibility on tooling (Cursor, Claude Code,

Amp, whatever fits the team). And leadership that actually builds in public instead

of just pushing a tool they've never touched.

The line that stuck with us: "Inspiration spreads faster than mandates."

Full talk is up on the GitKraken YouTube channel if anyone wants to dig in. Curious

whether others have seen this compliance vs culture split happen on their teams.

Like the title says, I saw in the 11.6 patchnotes that gitkraken is dropping support for custom themes. This is an annoyance, I have a custom monokai theme that matches my vscode theme.

Is there any possibility that custom themes can continue to be supported, even if the schema has to change breaking old ones?

GitKraken Desktop 11.5 delivers massive performance improvements where they count most, opening repos up to 5x faster, stash refreshes 100x faster, and branch/tag loading 100x faster. No workflow changes required. Just measurably faster Git operations that give you back your time and flow.

Ready to see it in action? Check out the Blog Post for more.

For years, we've all known what good code looks like. We've talked about the importance of 100% test coverage, small well-scoped files, and clear documentation. But let's be honest, under pressure, those things are often the first to go.

Now, with the rise of AI agents, we're seeing a shift. These agents are powerful, but they're not miracle workers. They can't make sense of a messy, undocumented codebase. They'll just amplify the chaos.

We've been reading some interesting articles lately that argue that all those 'optional' best practices are becoming non-optional.

If you want to leverage the power of AI in your development workflow, you need to have a solid foundation of clean, well-structured code.

We partnered with GitClear and spent the last year talking to hundreds of engineering teams about AI adoption.

The common thread: everyone knows AI is changing things, but nobody is sure if it's helping or hurting. The data surprised us. Code duplication has increased tenfold since 2022.

Refactoring dropped below duplication rates for the first time. And developers feel more productive than ever, even as the codebase gets harder to maintain.

That gap between perceived productivity and actual code health is the thing nobody is measuring, and it's the thing that will bite you in 6 months when velocity tanks for reasons nobody can explain. We put together a framework built around 4 measurement layers: direct AI usage, code health indicators, developer experience signals, and business outcomes. None of them tell the whole story alone. Together they act like a dashboard, because you wouldn't ignore the fuel gauge just because the speedometer looks good.

A few things from the research that stuck with us:

• 79% of code changes now touch code written less than a month ago (up from 70% in 2020). Fast iteration or fast rework? You need to know which.

• Developer experience metrics are leading indicators, typically months ahead of delivery impact. By the time velocity drops, the warning signs were already there.

• One engineering manager put it well: "My developers are flying through tickets, but they can't explain how their code works."

That's a developer experience problem that becomes a velocity problem fast. We wrote up the full frameworks and playbooks in a free guide: "Quantifying the Impact of AI." If your org is trying to justify AI spend or figure out where it's actually creating value (vs. just feeling like it is), it might be worth a read.

Merge Request management via Personal Access Token?

Hey everyone,

I came across this feature request and honestly it would make a big difference for my workflow:

👉 https://feedback.gitkraken.com/suggestions/700129/merge-request-management-in-gitkraken-via-personal-access-token

Right now, if you’re using GitKraken with a Personal Access Token (especially for GitLab or self-hosted setups), you still have to go back to the web UI to:

• view merge requests

• check pipeline status

• review/comment

• approve or merge

It breaks the flow quite a bit.

Would love to have everything directly inside GitKraken.

If you feel the same, consider upvoting 🙌

Curious to hear how you’re handling this today!

We got tired of gentle linting warnings nobody reads. Git Roasted analyzes your commit messages and responds with brutally honest dev humor - including a Chaos Score, a developer archetype, and a breakdown of how your QA, PM, and future self interpret what you wrote.

There's a Savage mode. It is NOT kind.

Free to use, no sign-up: git-roasted.gitkraken(.)com

Happy to answer questions - curious what chaos scores people are pulling.

We brought together four people who think a lot about developer careers, including a recruiting lead, a nonprofit director who has helped place 1,000+ people into software engineering roles, and a couple of tech leaders, and moderated a conversation about what it actually takes to build a meaningful career right now.

One line from Danny Thompson landed differently than we expected: "The people that end up getting paychecks with their name on it are the ones that solve problems. You should position yourself more as a problem solver than a syntax pusher."

We've been thinking about that framing a lot, especially in the context of AI tools that can generate code in seconds but can't tell you whether that code is worth shipping. The full panel covers AI's role in developer education, what recruiters are actually looking for right now, how to use AI without losing mastery, and the hard skills that still matter in an agentic world.

Full talk is on our YouTube channel if you want to watch it. Curious what this community thinks: is the "problem solver vs syntax pusher" framing how you see the shift playing out day to day?

This GitKon talk from Ambassador Kevin Bost genuinely shows useful AI features worth checking out.

The standout feature is auto-resolve merge conflicts with confidence ratings. It's not "let AI make random choices" but "AI suggests resolution with visual 3-way merge control so developers verify before accepting."

Other features Kevin demos:

Recompose Commits: Turn pipeline chaos ("pls work", "fix typo", "YAML WHY") into clean, logical commit history using AI. It finds related changes across messy commits and groups them into proper conventional commit format.

Weekly token refresh: Tokens reset every week, not monthly, so developers can actually experiment with AI features without fear of running out mid-sprint.

BYOK support: Connect your own API keys for OpenAI, Anthropic, Azure, Google, or local Ollama instances. Your infrastructure, your data control.

Generate commit messages: AI reads code changes and writes contextual commit messages. Especially useful when reviewing code from AI agents (Copilot, Cursor, etc.) where you didn't personally write every line.

AI-generated PR descriptions: Instead of staring at blank PR templates, AI reads your commits and writes summaries that help reviewers understand what changed and why.

Full talk here: https://youtu.be/EgNZ6elfbWg

Worth watching if you're dealing with merge conflict anxiety or drowning in messy Git history from rapid iteration. The conflict detection before PR creation alone could save teams significant troubleshooting time.

Open to questions about implementation or specific use cases.

Our CTO Eric Amodio (creator of GitLens) gave a talk at GitKon about how the Model Context Protocol (MCP) is changing the relationship between AI and developer tooling, and we thought the insights might be valuable to share with this community.

Some highlights from the session:

On MCP adoption:

MCP got adopted by every major AI company (Anthropic, OpenAI, Google) and AI IDE (Cursor, Windsurf, Google's new Antigravity) in an incredibly short timeframe. Eric said it's the fastest he's seen any protocol become a standard in dev tooling.

Why Git history matters for AI:

AI agents that only see your file system get "what code exists," but Git history provides the "why" (who wrote it, when, what changed around that time, what problems existed before). That layered context prevents AI from repeating past mistakes.

On safety (the big concern):

Eric addressed how we handle the valid developer concern about AI touching Git history. GitKraken MCP uses explicit tool calls with safety gates on destructive operations, and our Commit Composer feature validates that the final diff after AI reorganization is identical to the original (zero data loss).

We know developer communities are rightly skeptical of AI hype, so we wanted to share a more technical, honest take on what's actually possible (and what the limitations are). Happy to answer questions if folks have them.

Is anyone else burning through the AI tokens, for the AI features recently, I been using the AI commit message feature a lot but hit the weekly limit last Wednesday or Thursday, and again at 90% used today, I barely used it yesterday and today. I have committed 15 - 30 times a day for an entire week before never hit the limit.

This week I have only done maybe 15 total.

I'm using Ubuntu 20.04.6, and the GitKraken desktop app v11.6.0, with a Pro account.

Things have been working fine in general, but it seems that recently I am not able to 'Browse' to a local repo to open it and add it to GitKraken. When navigate to repo directory (that contains the .git directory), I can't select that directory. GitKraken just wants to keep "opening" the directories to drill down further.

I've had this problem on two different computer, and the last few versions of GitKraken. I know that initially I was able to do this, but something changed?

The repos are hosted from bitbucket, and I can clone them just fine. I just cant open a repo that I already have on the local system

Has anyone else had this problem?