How to do a real code review: levels 1 to 7

There are some common biases and misconceptions about code reviews. Sean Goedecke’s latest article goes straight to the point, sharing five practical tips for what really matters: - Don’t just review the diff, understand the system - Keep comments few and meaningful - Don’t review with a “how would I write it?” mindset - Only block when it really shouldn’t merge - Approve by default, block only for serious issues Clear and actionable — a recommended read 👉 Article link: https://lnkd.in/dTsbzSuf

Code review is not about making the code better. It’s about making the product better. A quick story. The code looked clean. Tests passed. CI was green. During review, a reviewer asked one question: “What happens if the webhook retries?” Nobody had thought about duplicate events. That single comment stopped a release. We fixed the flow, added an idempotency key, and avoided multiple charges to real customers. Product saved. Reputation intact. That’s the point.  Reviews save customers, not just lines of code. Here’s a practical playbook for reviews that actually protect the product. For the author • Keep PRs small. Small PRs get reviewed faster and have fewer surprises. • Self-review first. Run tests, lint, and a quick smoke locally. Don’t waste reviewers’ time. • Write a short summary. Explain intent, edge cases, and rollback plan. • Tag only relevant reviewers. Too many cooks slow the ship. • Link to design notes, tickets, and relevant docs. Context is gold. • Add automated tests and explain what you did not cover and why. For the reviewer • Acknowledge within 24 hours. Even a quick “I’ll review by X” keeps momentum. • Scan for product impact first. Ask: could this break billing, data, or UX? • Focus on intent over style. Prefer patterns used by the team, not personal preferences. • Use a checklist: correctness, security, performance, observability, rollback. • Give actionable feedback. Point to examples or tests that would help. • Keep tone constructive. Critique the code, not the person. • Approve when it’s safe. Minor nits can be fixed later. Process tips that scale • Automate checks. Use CI for unit tests, static analysis, security scans, and linting. Let the machine catch noise. • Gate merges on green CI and at least one approval. • Reserve a daily calendar slot for reviews to avoid context switching. • Document common review patterns and keep a living checklist. • Use feature flags and canary releases for risky changes. Roll forward, not blind. • Maintain runbooks for incidents and rollbacks. Ship with a plan. • Practice blameless postmortems when things go wrong. Using AI sensibly • AI tools like GitHub Copilot or Amazon Q can speed drafts, suggest tests, and summarize diffs. • Treat AI output like a first draft. Verify logic, correctness, and product impact. • Don’t rely on AI for design decisions or security-sensitive code. When a review works well, you reduce bugs, speed delivery, and protect customers. When it goes wrong, it’s usually process, not people.  Fix the process. #coding #tips #tech #programming #softwareengineering #softwaredevelopment

You Don't Own the Code You Don't Understand It's never been easier to write code. You can prompt a language model with a vague idea and get back scaffolding, schemas, endpoints, even whole layers of infrastructure. With good tools and a decent command of syntax, you can build something that looks finished in record time. The shape is there. It runs. The test passes. The deploy goes green. And yet, if you don't understand it, you don't own it. You're borrowing someone else's idea of what the code should be. In the best case, it's a good guess. In the worst case, it's a trap you won't see until it's live and under pressure. Understanding isn't about being able to explain every line. It's about knowing what holds weight. What breaks under load. What assumptions were baked into that clever bit of logic. It's about being able to change the thing without introducing a new failure path. To improve it without making it worse. That only comes from proximity. From reading. From debugging. From living with the system long enough to feel where it's brittle, and where it's strangely resilient. Generated code can help you start. But only lived experience turns code into something you can safely maintain, evolve, or trust in a crunch. The This is especially true in systems that have aged. Code written years ago isn't just code, it's memory. It remembers decisions the team no longer talks about. It remembers what didn't work. It remembers the fire drills and the workarounds and the compromises no one was proud of but everyone agreed to at the time. When you bulldoze that kind of code without studying it, you're erasing history, not refactoring. That doesn't mean you can't change it. It means you must read it first. Debug it. Observe it under load. Ask what it does when the input is wrong, or when the network is slow, or when the customer does something no one expected. And if you don't know what it does in those cases, then you don't own it yet. There's no shame in not knowing. But there's risk in pretending you do. Ownership isn't about authorship. It’s about responsibility. It's about being able to say, "If this breaks, I can explain why," and actually mean it. So by all means, generate the boilerplate. Let the models help. But don't confuse velocity with understanding. And don't confuse output with ownership. Read the code. Ask the dumb questions. Trace the data. Watch the logs. Until the system starts to feel a little less foreign. A little less dangerous. A little more like something you could build or rebuild, if you had to. That's when you know you own it. #DevLore #StackScrolls #CodeOwnership #SoftwareCraft Hi, I write for engineers who care about the deeper craft, system design, team resilience, and the kind of wisdom you usually learn the hard way. If this one struck a chord, feel free to follow or share it.

This especially: " Code written years ago isn't just code, it's memory. It remembers decisions the team no longer talks about. It remembers what didn't work. It remembers the fire drills and the workarounds and the compromises no one was proud of but everyone agreed to at the time. When you bulldoze that kind of code without studying it, you're erasing history, not refactoring." Sometimes there's a reason for the code being written "weird"

You Don’t Cut Code, Right? It happened years ago in a small meeting room on a quiet Friday afternoon. A release had failed the previous night and the air was heavy with fatigue and frustration. Developers stared at error logs, testers sat silently, and the client’s tone on the call grew colder by the minute. We had gone through every possible reason, yet no one spoke anymore. Then a young engineer, barely a year into his career, looked up and said softly, “You don’t cut code, right?” It was not arrogance. It was curiosity mixed with innocence. But it stayed with me long after the meeting ended. Because behind that question lived a deeper thought, one that many never voice, that those who no longer code have somehow stepped away from creation. I looked at him and smiled, but my mind travelled back to where it all began. I could see the old cubicle, the humming CPU, the cold coffee beside me, and the glow of the monitor at two in the morning. I remembered the sound of keys tapping like a rhythm of purpose, the tiny thrill when the code compiled, the quiet satisfaction of creation. Those nights taught me not only logic but humility. Failure back then was not a red mark on a dashboard, it was a lesson in patience, perseverance, and pride. With time, the screen changed but the spirit did not. I stopped writing lines of code, yet I never stopped building. The compiler became conversation, the syntax became trust, and the architecture moved from systems to people. I began to see that the hardest bugs are not in codebases, they are in cultures. The broken dependencies are not between functions, they are between teams. Leadership in technology is not distance from creation, it is creation of a different kind. It is debugging silence, integrating differences, and refactoring confusion into clarity. Every great product is half engineering and half empathy. You cannot design scalable software without designing stable relationships. You cannot write clean logic without building clean intent. The code that truly drives an organization is not what runs on servers but what runs between people. So when someone asks again, “You don’t cut code, right?” I smile. Because I still do, every single day. I cut through noise when teams lose direction. I cut through doubt when people forget their strength. I cut through fear when innovation slows down. Every conversation that restores belief is a commit. Every idea that turns into action is a deployment. Every person who grows under your guidance is a new release of potential. The language has changed, but the purpose has not. What I once built with logic, I now build with people. And when it works, it does something no code ever could, it creates meaning. I don’t just write about technology; I write about the humanity and relations that powers it - the human engineering . Because in the end, every system begins and ends with people. Take it easy until next time ! #LeadershipInTech #BeyondTheCode

The Documentation Zone Imagine, if you will, a world not unlike our own... You're scrolling through LinkedIn at 2 AM, debugging production for the third night in a row. The code works. The docs say something else entirely. The Confluence page was last updated in 2019. The README is a lie. Now imagine something different. Imagine a world where your documentation IS the programming. Not "living documentation." Not "docs as code." The actual inverse. You open the README. You write in plain English: "When a user submits a form, validate the email, check if they exist in the database, and send a welcome email if they're new." You save the file. The system reads it. Understands it. Compiles it. Deploys it. It just... works. Imagine a world where production is never out of sync with knowledge. Because they're the same thing. The documentation is the system. Change the docs, change the behavior. Instantly. Atomically. Your README is your codebase. Your architecture diagrams are executable. Your flowcharts literally flow. That Pull Request review? You're reading English. Actual English. "Should we rate limit at 100 requests per minute or 1000?" Not buried in config. Right there in the docs. Change the number, change the system. Imagine a world where Python has no problem running from a README. No more # TODO: Update this docstring. No more comments that lie about what the function does. No more "the code is the documentation" cope. Because the documentation became the code. You write: "Calculate the Fibonacci sequence up to n." The system generates the optimal implementation for your context. Memoized if you need speed. Recursive if you need elegance. Iterative if you need memory efficiency. You don't choose. The documentation layer chooses. Based on your production metrics. Your usage patterns. Your constraints. In this world, there are no more "senior engineers who understand the legacy system." Because the system documents itself. Completely. Accurately. Always. That job security you had from being the only one who understood the ancient message queue? Gone. That tribal knowledge about why the cache invalidation works the way it does? Unnecessary. Everyone can read the docs. Because the docs are the truth. The whole truth. The executable truth. We're building this world right now. Large language models that read specifications and write code. Formal verification systems that prove docs match implementation. No-code platforms where natural language becomes logic. The question isn't if documentation becomes executable. Now Imagine, that's where I've been living.

What the SOLID Principles Really Mean (And Why Most Get Them Wrong) ? “Ever heard someone say, ‘Just follow SOLID!’ — and then watched the codebase become less maintainable?” We’ve all been there. A new dev joins the team, starts refactoring everything in the name of “clean code,” and suddenly, you’ve got interfaces for interfaces, and inheritance hierarchies that look like a family tree on steroids. The intention? Good. The execution? Painful. Turning Point (Insight or Realization) That’s when we realized — SOLID isn’t a rulebook. It’s a mindset. It’s not about memorizing five fancy acronyms — it’s about understanding how your code should behave when it grows. Solution Introduction (Your Approach) We went back to basics. We stripped away the jargon and focused on what each principle really means in real-world development — not in theory. Comparison Section (Old Way vs New Way) Old Way — Apply SOLID blindly and over-engineer everything. New Way — Use SOLID as a guide, not a gospel, to write code that actually scales with clarity. Framework or Core Principles (5-Part Breakdown) ⚙️ S — Single Responsibility Principle Each class should have one reason to change. Keep it focused, not overloaded. ⚙️ O — Open/Closed Principle Code should be open for extension, closed for modification. Add new features without breaking old ones. ⚙️ L — Liskov Substitution Principle Subclasses should behave like their parents. If swapping them breaks the system — something’s wrong. ⚙️ I — Interface Segregation Principle Don’t force classes to depend on methods they don’t use. Keep interfaces lean and purpose-driven. ⚙️ D — Dependency Inversion Principle Depend on abstractions, not concrete classes. It makes your code flexible, testable, and future-ready. The Outcome (Results or Metrics) ✅ Cleaner, modular codebases that scale smoothly ✅ Faster debugging and onboarding for new developers ✅ Easier unit testing through decoupled components ✅ Code that evolves — not explodes — with new features “SOLID isn’t about writing more code — it’s about writing smarter code.” If your “SOLID” code feels complex, maybe it’s time to simplify. Because the best design isn’t the most abstract — it’s the most understandable. #SOLIDPrinciples #CleanCode #SoftwareDesign #SoftwareArchitecture #CodeQuality #ObjectOrientedDesign #Refactoring #EngineeringExcellence #DeveloperExperience #ModernDevelopment #TechLeadership #CodingBestPractices

At 3 Billion Technologies, we don’t treat SOLID as a checklist — we treat it as a design mindset: Write code that is easy to change, easy to test, and easy to evolve. Because scalability isn’t about adding more code — it’s about writing code that grows without breaking. Simple > Clever. Understandable > Over-engineered.

💡 10 Golden Rules to Write Clean Code Writing clean code isn’t just about syntax — it’s about clarity, intent, and long-term maintainability. Here are my 10 golden rules every developer should live by 👇 1️⃣ Avoid Magic Numbers & Strings Hard-coded literals conceal intent and can lead to silent bugs. You can use named constants or enums instead. 2️⃣ Use Meaningful, Descriptive Names Names should reveal purpose, not implementation. If a comment is needed to explain a variable, rename it. 3️⃣ Favor Early Returns Over Deep Nesting Validate and exit early. It reduces indentation, cognitive load, and complexity. 4️⃣ Avoid Long Parameter Lists Too many arguments are a code smell. Wrap related data into a single object or DTO. 5️⃣ Keep Functions Small & Focused A function should do one thing well. If it can’t be summarized in one line, split it. 6️⃣ Keep Code DRY (Don’t Repeat Yourself) Duplication multiplies bugs. Extract reusable logic instead of copy-pasting. 7️⃣ Apply the KISS Principle (Keep It Simple, Stupid) Choose simplicity over cleverness. If someone can’t understand your code quickly, it isn’t clean. 8️⃣ Prefer Composition Over Inheritance Use inheritance only for true is-a relationships. Composition offers flexibility with less coupling. 9️⃣ Comment Only When Necessary Good code explains what. Comments should explain why. If comments describe code, refactor instead. 🔟 Write Good Commit Messages Commits are part of your documentation. Describe what changed and why. Your future self will thank you. ✨ Bonus Rule: Automate Code Reviews with Tools, but Never Stop Reviewing as a Human. Clean code isn’t just enforced — it’s cultivated through care, discipline, and empathy for the next person who reads it. 💬 What’s one clean-code rule you never compromise on? #CleanCode #SoftwareEngineering #DotNet #CodingBestPractices #Developers #CodeQuality

Ever feel like your codebase is turning into a monster you barely recognize? 🧟♂️ You’re not alone. As projects grow, maintaining clean, understandable, and scalable code becomes one of the biggest challenges—and, honestly, a bit of an art form. That’s where \*\*modern code quality practices\*\* step in to save the day. Let’s break down a few game-changers that I’ve found incredibly useful lately, whether you’re working solo or in a team. ### 1. Shift Left Testing Instead of waiting for the end of a sprint or “QA phase,” move testing \*earlier\* in the development lifecycle. Unit tests, static analysis, and linting tools running automatically with every commit help catch bugs and style issues \*before\* they snowball. This means less firefighting later and more confidence in your changes. ### 2. Code Reviews 2.0 Forget tedious line-by-line critiques. Use collaborative platforms that support inline comments, suggestion modes, and even pair programming features. Bonus points if your team integrates AI-assisted code review—tools that highlight potential bugs, enforce style guides, or suggest refactorings can speed up review cycles dramatically. ### 3. Embrace Type Systems \(Even in JS/TS Land\) If you’re working with JavaScript, TypeScript isn’t just a “nice to have”—it’s becoming essential for larger apps. Statically typed code helps document intent, catch errors early, and improves editor autocomplete magic. If you’re in Python or other dynamic languages, consider gradual typing \(with tools like mypy\). ### 4. Document with Purpose Docstrings or README files shouldn’t be afterthoughts. Use them to explain \*why\* choices were made, not just \*what\* the code does. Better yet, auto-generate API docs and keep examples in sync using tools like Swagger/OpenAPI. ### 5. Automate Code Quality Metrics Set up pipelines that track code complexity, duplication, test coverage, and even “tech debt” trends. Knowing your weak spots helps prioritize refactoring and prevents the dreaded “rewrite from scratch” scenario. At the end of the day, writing good code isn’t just about getting it to work—it’s about making your future self \(and your teammates\) thankful. These practices are small investments that pay off big in maintainability, team morale, and product longevity. Got a favorite code quality habit or tool? Let’s swap tips! 👇 #CodeQuality #SoftwareEngineering #DevBestPractices #Testing #TypeScript #CodeReviews #TechTips #CleanCode