Codebase Audit Reveals Hidden Tech Debt

Day 102. Less theory. More breaking things. Yesterday I talked about DAGs and snapshots. Today I actually felt them. Went full practical. Here's what hit me: Error 1: Detached HEAD Checked out an old commit to inspect something. Forgot to create a branch. Made changes. Committed. Then switched branches and watched those commits disappear into the void. The graph doesn't lie. Floating commits with no branch pointing to them just... drift. Error 2: Merge conflict on main Two branches touched the same file. Git couldn't decide whose version wins. The <<<<<<< markers showed up and I actually read them this time instead of panicking. Resolved it manually. Committed the merge. Moved on. Error 3: reset --hard on the wrong branch Yeah. I typed the command on the branch I didn't mean to. Work gone. No staged changes. No warning. Lesson? git reflog saves lives. Every commit still lives in there for 30 days even after a hard reset. Error 4: Pushed to the wrong remote branch Force of habit. Wrong branch name. Had to git push origin --delete and clean it up. Not glamorous. But this is what sharpening actually looks like. Day 102. Still here. #Git #DevOps #100DaysOfCode #LearningInPublic #Infracodebase

⚠️ “We can’t build this feature… the codebase is too messy.” If your team has ever said this, you’re already paying the price of technical debt. But here’s the truth 👇 You don’t need to slow down development to fix it. In fact, we did the opposite. Using GitLab, we embedded technical debt into our daily workflow—not as a side task, but as part of how we build. What changed for us: ✔️ Turned “invisible debt” into prioritized work with Issue Boards ✔️ Stopped new debt using code quality gates & automated checks ✔️ Used Value Stream Analytics to uncover real bottlenecks The impact after 6 months: - 35% faster cycle time - Feature delivery didn’t slow down—it improved - Happier developers (less time fighting legacy code) Want the full breakdown + practical framework? Check out the complete blog here: https://lnkd.in/gUHjNJMf Canarys | Nagaraj Bhairaji | Shashank SN | Saran Dhandapani

8 signs your codebase is slowly dying: 1. Nobody knows what half the services do.   "Ask Mike." Mike left in 2022.   His Confluence page: last updated 4 years ago. 2. Every feature has its own "temporary" config flag.   73 feature flags. 51 of them are always true.   Nobody dares to remove them. 3. Test suite takes 47 minutes.   Developers run tests "later".   Later never comes before the merge. 4. The staging environment is "mostly" like production.   Missing 3 environment variables. Different database version.   Different file storage provider.   "It works on staging" means nothing. 5. There's a utils.py / helpers.go file.   4,200 lines. No clear responsibility.   Contains everything from email sending to PDF generation. 6. Local setup guide is 6 pages long.   Step 14: "If you get error X, try Y. If that doesn't work, ask someone."   Last updated when Node.js 12 was current. 7. Hotfixes on top of hotfixes.   // temporary fix - DO NOT REMOVE   Comment is 4 years old.   Original author: Unknown. 8. "We'll refactor it after the release."   Release shipped. New features planned.   Refactor ticket: still in the backlog. Priority: Medium. Technical debt doesn't announce itself. It accumulates silently until the system stops moving. How many of these does your codebase have? 👇 #SoftwareEngineering #TechnicalDebt #Backend #CleanCode #Programming

Pain of working on a messy codebase: • no clear structure • no naming consistency • logic scattered everywhere • fixing one bug creates another • fear of touching existing code You spend more time understanding than building. That’s when you realize: Good code is not just about working code. It’s about maintainable code. Have you worked on a codebase like this? #DeveloperLife #TechDebt #SoftwareEngineering

You needed code from another feature branch. But the PR was still under review. Do you wait, or hack your way around it? You might branch off from the PR'd branch. Inherit the code you need… and the rest of the untested code. You ask for a follow-up. They say it can be done the next morning. You've felt that frustration. Everything you need is there… but out of reach. Most delays aren't caused by bad estimates. They're caused by not knowing your tools. What can helped you: checkout the feature branch under review. Copy the hash of the commit you needed. Go back to your feature branch. And run: git cherry-pick <hash> That's it. No need to manually copy the code. No need to inherit untested code. No need to rush your co-dev. No need to wait. Just one simple command.

I don't have a problem with legacy code. But my definition of legacy code is - any code that's been merged into the main branch (and/or deployed). As soon as it's there you and other devs have to deal with it, take it into account, maintain it, refactor it, remove it and replace it. It becomes a source of both - features and bugs. So if I wanna say: "I hate legacy code" I might as well say "I hate code". #softwaredevelopment #legacy

Stacked pull requests are not a Git flex. They’re an attention management tool for exhausted reviewers. Every team says they want better code review workflow. Then someone opens a “small” pull request that quietly contains a refactor, a schema change, three test rewrites, and one innocent little config tweak that will absolutely ruin Friday. That’s the real value of stacked pull requests. Not prettier history. Not some elite workflow cosplay. Just smaller units of thought, which means better pull request review and fewer moments where the reviewer’s brain gives up halfway through diff number 47. Most review bottlenecks are not caused by laziness. They’re caused by overloaded working memory. When one PR asks a human to validate architecture, naming, data flow, and edge cases all at once, approval becomes theater. GitHub putting first-class support behind stacked PRs matters because developer productivity is usually limited by review bandwidth, not by how fast we can open another branch. Smaller diffs do not make teams smarter. They just make judgment possible again. Are stacked pull requests already changing how your team reviews code, or are giant PRs still your local definition of optimism? #StackedPRs #CodeReview #PullRequests #DeveloperProductivity #EngineeringManagement #DevTools #SoftwareEngineering

Hello, I’ve been revisiting the Conventional Commits standard and it’s surprisingly powerful. It helps you: - Make commit messages clear and consistent - Automate changelogs and versioning - Understand changes instantly (feat, fix, breaking change…) Simple habit, real impact. If you’re not using it yet, it’s worth a look: https://lnkd.in/dKxMqKNb #git #softwareengineering

𝗧𝗵𝗲 𝘄𝗼𝗿𝘀𝘁 𝗰𝗼𝗱𝗲 𝗶𝗻 𝗮 𝘀𝘆𝘀𝘁𝗲𝗺 𝗶𝘀 𝗿𝗮𝗿𝗲𝗹𝘆 𝗯𝗿𝗼𝗸𝗲𝗻. It’s the code that “works.” Every mature codebase has it.  • Written 3 – 5 years ago  • Not optimized  • Not clean  • Not documented  • But somehow… still running fine And nobody touches it. Not because developers are lazy — but because everyone knows: 👉 touching it has unknown consequences 👉 understanding it takes time no one budgets for 👉 rewriting it has no immediate business value So it stays. Wrapped in fear. Protected by deadlines. Ignored until something forces attention. The uncomfortable truth: 𝗕𝗮𝗱 𝗰𝗼𝗱𝗲 𝗱𝗼𝗲𝘀𝗻’𝘁 𝗴𝗲𝘁 𝗳𝗶𝘅𝗲𝗱 𝗯𝗲𝗰𝗮𝘂𝘀𝗲 𝗶𝘁’𝘀 𝗯𝗮𝗱. 𝗜𝘁 𝗴𝗲𝘁𝘀 𝗳𝗶𝘅𝗲𝗱 𝘄𝗵𝗲𝗻 𝗶𝘁 𝗯𝗲𝗰𝗼𝗺𝗲𝘀 𝗲𝘅𝗽𝗲𝗻𝘀𝗶𝘃𝗲. Until then, it survives. Not because it’s good engineering — but because it’s “good enough” for the system to keep moving. Which is why I’ve started looking at legacy code differently: Instead of asking “Why is this so messy?” should ask: What constraints led to this? What risk does it carry today? When is it actually worth touching? Because blindly “cleaning” working code can be worse than leaving it alone. And ignoring it forever is worse than both. 𝗧𝗵𝗲 𝗿𝗲𝗮𝗹 𝘀𝗸𝗶𝗹𝗹 𝗶𝘀𝗻’𝘁 𝘄𝗿𝗶𝘁𝗶𝗻𝗴 𝗰𝗹𝗲𝗮𝗻 𝗰𝗼𝗱𝗲. 𝗜𝘁’𝘀 𝗸𝗻𝗼𝘄𝗶𝗻𝗴 𝘄𝗵𝗲𝗻 𝗺𝗲𝘀𝘀𝘆 𝗰𝗼𝗱𝗲 𝗱𝗲𝘀𝗲𝗿𝘃𝗲𝘀 𝗮𝘁𝘁𝗲𝗻𝘁𝗶𝗼𝗻. #softwareengineering #legacycode #engineering #building