Why I avoid the word "just" at work

Go (Golang) Basic - Error What Happens When Things Go Wrong? We've learned to write functions, create structs, and use pointers. Our code works perfectly... in a perfect world. But in the real world, things go wrong: a file might not exist, a network connection might fail, or a user might provide invalid input. Many languages handle these situations with "exceptions" using try-catch blocks. Go takes a fundamentally different and more explicit approach. In Go, errors are values. An error is not a special event that stops your program; it's just another value that a function can return, like a string or an int. This philosophy forces you to consciously handle potential failures, leading to more robust and predictable code. error Type: Go's Built-in Contract At its core, Go's error is a built-in interface. It's a very simple contract: any type that wants to be considered an error must have a single method called Error() that returns a string. type error interface { Error() string } You don't usually need https://lnkd.in/geJa6Hc2

A few agents I'm actually using day to day in Claude Code: * A code reviewer agent that pretends it's "way more senior" than whoever wrote the code itself (usually also Claude). * A code review comment addresser agent to use the gh cli, find code review comments, and address them. * A debugger agent that is an expert on the scientific method. This one is probably the most helpful, it forms hypotheses for what could be causing issues, then systematically debugs by verifying or falsifying those. Without this framework Claude can get itself into loops and use a TON of context debugging tests or client-server interactions. * Then lots of one-off ones for repetitive tasks that can be invoked in subtrees with "claude -p". I haven't really had any slash-commands that make their way into my workflow.

For me, clean code isn't about fancy patterns—it's about writing for the next person. It’s code that your teammate (or future you) can understand in seconds, not hours. Here’s what that looks like in practice: 1. **Name things clearly:** `customerId` is instantly better than `cId` or `temp`. 2. **Write small functions:** A function should do one thing only, and do it well. 3. **Keep it simple:** Favor straightforward solutions over clever, complex ones. 4. **Minimize comments:** The code itself should explain *what* it's doing. 5. **Use comments wisely:** Explain *why* you did something unusual, not the *what*. 6. **Stay consistent:** Follow your team's naming and style conventions. 7. **Avoid deep nesting:** Too many `if/else` levels make logic hard to follow. 8. **Remove dead code:** Delete commented-out blocks and unused functions. 9. **Replace mystery numbers.** Use clear names like `MAX_USERS = 100` instead of just the number `100`. 10. **Remember:** You will write code once, but it will be read hundreds of times. Make that read a pleasant experience.

The developer who taught you DRY lied to you, stop doing it Here is why 👇 Everyone treats "Don't Repeat Yourself" like it's sacred But premature abstraction has killed more codebases than copy-paste ever will I used to be a DRY zealot, for example I once built a beautiful abstraction for three similar functions Six months later it had 50 conditional branches and my team would avoid it Now I follow WET: Write Everything Thrice (twice isn’t enough) Duplicate once? Ship it Duplicate twice? Still fine Three times? Maybe abstract. Maybe not Because similar looking code isn't the same code, or meant for the same purpose That login form and signup form will diverge Forcing them into one component creates a frankenstein that serves neither Being verbose is a feature not a bug, create two components, maybe three, as it's easier to fix and test only the login from vs. everywhere that component is use Your job isn't writing less code It's writing code people can change without breaking prod at 3am Be atomic. Be verbose. Be obvious. WET > DRY!

The 3 Laws of Writing Readable Code One of the easiest ways to spot an inexperienced developer is deeply nested logic. You know the type: multiple layers of if statements where, by the time you reach the core logic, your brain is juggling half a dozen conditions just to make sense of it. Readable code is not just about making the compiler happy. It is about reducing cognitive load for the person reading it. Over time, I have found that three simple laws consistently separate clean, maintainable code from the rest. --- 1. Avoid Deep Nesting Every extra indentation level increases mental effort. By inverting your conditionals and handling failure cases early, you flatten the structure. This lets readers move through your code in a straight line, discarding earlier checks as they go. --- 2. Avoid Code Duplication Duplicate logic is a silent productivity killer. When the same behavior is copied across files, every change becomes a scavenger hunt. Extract shared logic into reusable functions so a single update propagates everywhere. Your future self will thank you. --- 3. Use Meaningful Names Code should tell a story, not hide one. Meaningful names make your intent obvious. A reader should be able to understand what your code does without immediately digging into how it does it. Clear naming turns debugging into reading, not deciphering.

I spent 40% of my coding time just searching for answers. Here's how I fixed that. Let me paint you a picture of my typical debugging session last month:9:47 AM — Hit an error with async/await in Node.js A Stack Overflow post from 2018 3 different approaches (express-rate-limit, rate-limiter-flexible, custom middleware) Read the error message carefully (sounds obvious, but I used to skip this) Check if it's a typo/syntax issue (50% of the time it is lol) If still stuck after 5 minutes: Ask ONE targeted question Get answer + sources, verify it makes sense Implement and move onBefore: Error → Google → 10 tabs → 30 minutes later → maybe solved Error → Quick check → Targeted question → 3 minutes → solved Download Comet → sign in → ask one question → Pro unlocks https://lnkd.in/gtBdcAiq Stop researching like I'm writing a dissertation Get the answer, verify it, implement it, move on Accept that "good enough to move forward" beats "perfect understanding before proceeding" To My Fellow DevsIf you find yourself with 20+ tabs open, reading conflicting advice from 2019-202 https://lnkd.in/gaerR9t7

I spent 40% of my coding time just searching for answers. Here's how I fixed that. Let me paint you a picture of my typical debugging session last month:9:47 AM — Hit an error with async/await in Node.js A Stack Overflow post from 2018 3 different approaches (express-rate-limit, rate-limiter-flexible, custom middleware) Read the error message carefully (sounds obvious, but I used to skip this) Check if it's a typo/syntax issue (50% of the time it is lol) If still stuck after 5 minutes: Ask ONE targeted question Get answer + sources, verify it makes sense Implement and move onBefore: Error → Google → 10 tabs → 30 minutes later → maybe solved Error → Quick check → Targeted question → 3 minutes → solved Download Comet → sign in → ask one question → Pro unlocks https://lnkd.in/gtBdcAiq Stop researching like I'm writing a dissertation Get the answer, verify it, implement it, move on Accept that "good enough to move forward" beats "perfect understanding before proceeding" To My Fellow DevsIf you find yourself with 20+ tabs open, reading conflicting advice from 2019-202 https://lnkd.in/gaerR9t7

There are only two hard things in computer science: cache invalidation and naming things… and off-by-one errors😂 What’s an Off-By-One Error? It’s when you loop or count and end up one step short or one step too far. for (int i = 0; i <= list.size(); i++) { process(list.get(i)); } If the list has 5 items, i eventually becomes 5 and list.get(5) crashes with an IndexOutOfBoundsException. How can you keep this bug away? Here are simple, time-tested ways developers (me included) can use to avoid it: >> Half-Open Ranges Use the [start, end) style - start is included, end is excluded. Then length = end - start and empty ranges are obvious. >> Zero-One-Many Tests From Kent Beck’s testing playbook: always test with 0 items, 1 item, and many items—especially the maximum size. >> Static Analysis & Linters SonarQube, Clang analyzer, and most modern IDEs can flag suspicious conditions like < vs <= before code even runs. >> Clear Naming & Reviews Names like endExclusive or maxIndex make intent obvious. In code reviews, keep a checklist item: “Check loop and range boundaries.” Takeaway :- Off-by-one errors look tiny but cause big headaches. Spot the boundaries early, test them hard, and they’ll stop sneaking into production. #softwareengineerig #backenddevelopment #java

SDD, yes—but what if I don't have a spec for my legacy code? The idea of Spec-Driven Development (SDD) is compelling: describe what the system should do, and the code follows—almost magically. That may work well for clean-slate, greenfield projects. But what if you're dealing with an existing codebase? Underspecification—or worse, wrong specification—is the challenge I’ve seen in most legacy software. We ran an experiment to test whether we could infer workable, high-level specifications from existing systems. Setup: 1️⃣ Assisted extraction of per-service specs from a dozen microservices 2️⃣ Compilation into a system-level knowledge base That was enough to interactively validate the knowledge by chatting with the LLM System: 💬 "Summarize the business logic of component A" 💬 "What is the concept of <domain specific terminology>?" 💬 "How is X calculated?" Findings: 💡 The model correctly recognized most domain concepts and dependencies. 💡 Cross-service interactions and business logic subtleties were not sufficiently recognized. 💡 Asking for a visual representation revealed the root of misunderstanding. The most surprising result, however, was that the system pinpointed flaws and contradictions present in the code. The parts that are hard to explain human-to-human were highlighted with astonishing accuracy by the model when asked about inconsistencies ... ... almost like a new team member asking annoying questions. #SDD #SpecDrivenDevelopment

Unspoken truths about working on legacy code:-- – You fix a spelling mistake...and now the build won’t pass. Turns out that typo was part of a very fragile if-condition. – The API returns 17 fields. You only need 2. You touch one, and now something on the billing page is broken. Somehow. – The logic is nested five layers deep. The else block is doing the actual work. You stare at it like it’s a riddle. – You see a comment that says // temporary fix, will clean up later. It’s from 2017. The original author is now a Director/ VP. – You open one file. That file imports 9 other files. Two are unused. One is recursive. One calls itself in a setTimeout. You close your laptop. – QA raises a bug and asks, “Why is this button blue now?” You didn’t touch the button. You didn’t touch the style. It just… changed. On its own. – You think about refactoring. Then you remember prod has been stable for 6 months. You quietly back away.