18 Rules of Software Engineering for Success

People think coding agents are only for writing code. “They’re just advanced autocomplete.” Coding agents help with planning, debugging, testing, refactoring, and even coordinating full feature workflows. How are coding agents changing your workflow beyond coding?

I don’t think “senior code” is the most abstract, layered, or pattern heavy code in the room. I think it’s the code that creates the fewest surprises. In practice, that usually means: • boundaries are obvious • trade offs are named • failure modes are predictable • common changes feel local, not global You can often feel this in a pull request. Not because the code is flashy. Because it lowers cognitive load for the next person reading, debugging, or extending it. That’s one of the markers I respect most in mature engineering: not cleverness, but calmness. Readability is not just style. It’s a scaling decision. #CodeQuality #SeniorEngineering #SoftwareCraftsmanship #Maintainability #EngineeringCulture

“True development shows its value in unit tests.” We often celebrate writing code. But the real confidence doesn’t come from writing it — it comes from testing it. A feature isn’t complete when it compiles. It’s complete when it survives edge cases, failures, and unexpected inputs. Unit tests do more than catch bugs: • They validate your logic • They document expected behavior • They give you the confidence to refactor without fear Code that isn’t tested is just an assumption. Tested code is something you can trust. Next time your code works on the first run… ask yourself — “Will it still work when it’s tested?” #DataEngineering

𝗧𝗵𝗲 𝘄𝗼𝗿𝘀𝘁 𝗰𝗼𝗱𝗲 𝗶𝗻 𝗮 𝘀𝘆𝘀𝘁𝗲𝗺 𝗶𝘀 𝗿𝗮𝗿𝗲𝗹𝘆 𝗯𝗿𝗼𝗸𝗲𝗻. 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

513: Clear commit messages are vital for efficient code reviews. They guide reviewers, ensuring focus on specific changes and streamlining the entire process. #CodeReview #SoftwareDevelopment #DeveloperTips #BestPractices

We recently shipped a bug to production. Claude’s “Routines” is what changed what happened next. The bug wasn’t surprising. We were moving fast. Close to the customer. Constant pressure to deliver. So we skipped a code review. Hah, Big deal! Teams under constant pressure do that all the time. They just don't say it publicly. It felt like the right trade at the time(Like it always does). Until it wasn’t. Hours lost debugging. Frustration across the team. And the same line we’ve all said before. "A code review would have caught this". That’s the pattern. We believe in code reviews. But under pressure, belief doesn’t matter. Execution wins. Practices lose. So I stopped relying on “we should”. And set up Claude’s “Routines”. Every day at 1 PM, it reviews the last 24 hours of commits. No reminders. No follow-ups. It just happens. Is it as good as a deep human review? Not always. But it catches high-risk issues early. The kind that turn into real problems later. And that’s been enough to change the outcome. Fewer “we should have caught this” moments. Less firefighting. We don’t skip best practices because we’re careless. We skip them because we’re human. So the fix isn’t more discipline. It’s building systems that don’t let things slip. Loving Claude "Routines".

The Code Was Never the Hard Part The code usually comes later. The hard part is: • understanding unclear requirements • handling edge cases nobody mentioned • balancing speed vs maintainability • making decisions with incomplete information Typing code is often the easiest step. The real skill is turning messy ideas into clear systems. That’s why two developers can get the same task and produce very different outcomes. The difference is rarely syntax. It’s how clearly they think before building. What part of development feels hardest to you — coding, clarity, or decisions? #DeveloperLife #SoftwareEngineering #ProblemSolving #ProgrammingThoughts

Working with coding agents keeps making the same thing obvious: code is only part of the change. I wrote my first ever blog post about why code diff is the wrong diff. https://lnkd.in/dtZ6ZBPR

One thing I’ve started noticing over time: There’s a difference between code that works and code that is ready for production. Working code solves the immediate problem. But production-ready code considers things like: 👉 What happens if a dependency fails? 👉 How does this behave under load? 👉 Are edge cases handled properly? These aren’t always obvious at first. But they’re usually what matter when the code runs in real systems. Still learning, but trying to think a bit beyond just making things work. #softwareengineering #learning #systems

Refactoring: The art of making code beautiful without breaking it. Not a luxury. A necessity. Clean code is fast code. Fast code wins. #Refactoring #SoftwareDevelopment #Engineering #CodeQuality #TechnicalDebt