Git 2.54 Released with New Features

One feature that truly stands out is config-based hooks. This is something many of us have been waiting for. 🔹 Why it matters: - Enables centralized management of hooks, removing the need to duplicate scripts across repositories. - Promotes reusability and consistency in enforcing quality gates (linting, tests, commit checks). - Simplifies onboarding by ensuring every developer follows the same standards out of the box. Reduces maintenance overhead and eliminates drift between repos 🔹 Impact on engineering teams: - Stronger governance without friction. - Improved code quality at scale. - Easier adoption of standardized workflows across microservices and mono-repos.

Git 2.54 is out, and it brings a new experimental command: git history. The main goal is to simplify history rewriting to polish your commits. We usually rely on interactive rebase for this, which can sometimes get pretty complex. Among the first available options, reword lets you directly edit the message of any chosen commit. No more excuses for writing terrible commit messages! 😊 git history reword <SHA-1> Another option, split, allows you to break down non-atomic commits. As we know, these can cause headaches down the line when reusing history. The interface is quite similar to git add -p (partial staging): git history split <SHA-1> Find out more here: https://lnkd.in/eJ2QjadF

The open source Git project just released Git 2.54. Here is GitHub’s look at some of the most interesting features and changes introduced since last time.

"We obsess over making code last. Maybe we should obsess over making it leave gracefully." This dev makes the case for designing for reversibility through modularity. { author: Ros Sopheak • Adam - The Developer } https://lnkd.in/eu_8WYr5 

Stop writing code that's hard to kill. We obsess over making code last. Maybe we should obsess over making it leave gracefully. "Write code that is easy to delete, not easy to extend." Most features get cut. Most "reusable" utilities become traps. The code that survives isn't the code that was built to last — it's the code that was built to change. A few signs you're doing it right: • A feature dies in one PR, not twenty files • Boundaries are clear, not leaky • Your module is blissfully ignorant of the rest of the system • You can turn it off with a flag, not a funeral The easiest code to delete is the code you never write. But the next best thing? Code that says "I was here" quietly enough that no one minds sweeping you away. I wrote the blog and it's shared by DEV Community here! #softwareengineering #coding #programming #codequality

Shipped my first Ruby gem this weekend Docsmith: https://lnkd.in/gbSubxRw  It adds snapshot versioning, format-aware diffs, and inline comments to any ActiveRecord model. Zero system dependencies.  But here's the honest story of how it got built.  My first design had branching, merging, conflict resolution — the works. Looked impressive on paper. Turned out I was building Git for documents when all  anyone needs is "save this version, show me what changed, let me leave a note." I stripped all of it out and shipped what actually mattered. The other honest thing: I built this with Claude Code using the superpowers plugin. Vibe-coding with human intervention. I planned it, made architecture decisions, tons of tweaks,  course-corrected when things got too complex. The AI was a collaborator, not an autocomplete. Two weekends, 210 passing tests, published to RubyGems.  If you're curious about the planning and implementation process — including the over-engineered version that didn't make it — it's all in the repo under  docs/superpowers.  Rails devs: gem install docsmith. Feedback welcome. GitHub: https://lnkd.in/gDZECtuk #ruby #rubyonrails

New version of git is out: 2.54 -- notable new commands: `git history reword <commit>` and `git history split <commit>` which are specialized interactive rebase shortcuts. Better git hooks: .git/hooks/ can now reference external hooks instead of just contain shell scripts. I look forward to renewing my lefthook-nix setup for installing hooks more natively. https://lnkd.in/eAbMUze4

Most teams running both Codex and Claude Code don't pick a winner. They run both, on different tasks, because each is genuinely better at something specific. The pattern that holds up in production is hierarchical: Claude Code plans and reviews, Codex executes. When you nest two harnesses in a driver/worker topology, your gains stack rather than average out. #aiforbusiness #agenticcoding #softwaredevelopment

A friend ranted last week about his popular Claude Code plugin: "Every over-engineered subsystem got there the same way. Ship a feature → hit a failure → add a compensator → compensator grows helpers → new devs build on top of the helpers, never the core." He's right. I've written that code. So have you. So I built a Claude Code skill: /de-engineer. It audits one subsystem for band-aids and proposes the simpler design that should have shipped. Tested it on Nous Research's Hermes, OpenClaw, and EvoMap's Evolver. Three different teams, three different languages. Same band-aid patterns in all three. The skill is 94 lines. No test harness, no SDK, no web UI. A skill called "de-engineer" that over-engineers itself is a meme, not a tool. https://lnkd.in/gHpAUwkB

“An open source toolkit that allows you to focus on product scenarios and predictable outcomes instead of vibe coding every piece from scratch.” https://lnkd.in/g-yd6nrK