Process-Driven vs Craftsmanship Approach in Software Engineering

“Coding is going first, then all of Software Engineering” As long as Software is needed neither of those are going away. The only thing that is going to change is the layer of abstraction that SWEs work on, like it has always been…

I don’t make predictions very often but here goes. Long, complex CI/CD pipelines have about a year or two left. Soon they’ll be replaced by lightweight static tests (unit + some integration), feature flag deployments and synthetic testing coupled with robust telemetry and observability. Why? Agents are enabling code changes at light speed. A 40 minute CI/CD process felt tolerable or a bit annoying before. Now it’s completely out of the question. Finally, the economics of modern software engineering are demanding flow. We’ve hit a totally new kind of singularity. 👌🏼

For years, we’ve been building systems the same way. UI talks to APIs, APIs talk to databases, and everything is designed around predefined responses. It works, and it got us this far, but at its core, it’s still static. What we’re moving toward now is something very different. Instead of building systems that just respond, we’re starting to build systems that understand. Systems made up of agents that can interpret what you mean, adapt in real time, and build behavior on the fly instead of relying on fixed endpoints and hardcoded logic. In this video, I introduce Software Engineering 2.0, a new way to think about architecture where UI, orchestration, and resources evolve into intelligent agents. This is the start of a series where I’ll break down how to build reliable, intelligent systems using these ideas. Check out the first video in this series here: https://lnkd.in/dw5tuMP9

I’d argue that historically this is SE 3.0 1.0 = procedural/monolithic pre-API era 2.0 = the REST/microservices paradigm that defined the last 15 years 3.0 = agentic systems The migration question is genuinely the scary part. With 1.0 to 2.0, you had clearer contracts, legacy logic was wrapped behind endpoint and called it done. The seams were well-defined. With 2.0 to 3.0, the seam is the intelligence layer. The thing replacing your fixed endpoints is something that interprets intent at runtime? You can’t just wrap it you have to decide what still needs determinism and what can be handed to an agent. That boundary is going to be the hardest and most decisive architectural call engineers will make for the next decade.

"Software engineering" is finally starting to feel like engineering. From the latest Agile Embedded episode — the bottleneck is no longer typing code, it's expressing intent.

The potential for significantly faster development is a compelling proposition. While the exact claim of 'ten times faster' might be ambitious, the sentiment of increased productivity with tools like Cursor is palpable. When tools streamline workflows and reduce friction, development speed naturally improves. This highlights a key aspect of modern software engineering: leveraging intelligent tools to enhance efficiency and output. #SoftwareDevelopment #Productivity #TechTools #Coding #Engineering

Most distributed systems don’t fail because of bad code. They fail because of orchestration. Not immediately. Not loudly. Slowly. A retry happens at the wrong time. Two controllers race each other. State drifts just enough to cause inconsistency. And suddenly… debugging becomes guesswork. You try again. This time it works. But you don’t know why. --- We’ve built incredible systems. But the way we program control planes is still: • timing-dependent • hard to reproduce • difficult to reason about --- I’ve been exploring a different question: What if orchestration itself was deterministic? What if: Same input → same execution → same outcome Every time. --- That’s what I’ve been building. A programming model where systems don’t just “run” — they continuously stabilize toward a desired state. Not scripts. Not controllers. Something else. --- Still early. But the ideas are starting to take shape. Sharing more soon. #distributedSystems #systemsdesign #programminglanguages #backend #cloudnative

Poor use of abstraction techniques in software engineering makes it substantially more expensive to do Agentic Coding as software scales in complexity/size. Noted.

Thinking memory leaks are just a production problem? They're actively hurting your team's development velocity right now. Memory leaks occur when objects are no longer needed but remain referenced, preventing garbage collection. On development machines, this often manifests as slow IDEs, unresponsive tools, and frequent restarts, wasting precious developer time. * Integrate memory profiling tools directly into your local development setup; make it a habit, not a post-mortem. * Automate static analysis checks for common memory patterns that lead to leaks in your CI/CD, preventing them from even reaching local dev. * Educate your team on common leak pitfalls for your chosen language/framework, fostering a "memory-aware" coding culture. Proactive memory management isn't just about runtime stability; it's a direct investment in faster local development and higher team output. What's one local dev tool that consistently helps you spot subtle issues before they become headaches? #DeveloperProductivity #MemoryLeaks #GarbageCollection #SoftwareEngineering #DevTools

💡 Rethinking Dependency Injection: Do We Always Need It? Dependency Injection (DI) is widely considered a best practice in modern software development. But does it need to be applied in every scenario? Consider transformation classes. 👉 If a transformation class is: - Used only once - Stateless - Not reused across components Injecting it as a service may not always be necessary. Creating an object directly at the point of use can often be a simpler and more practical approach. It helps keep the code: ✔️ Cleaner ✔️ Easier to read ✔️ Free from unnecessary abstraction DI is extremely valuable for managing shared dependencies, improving testability, and enabling loose coupling. However, overusing it can sometimes lead to avoidable complexity. ⚖️ The takeaway: Apply Dependency Injection where it truly adds value—not as a default for every class. Sometimes, simplicity is the better design choice. #SoftwareEngineering #CleanCode #Architecture #DependencyInjection #Programming #TechThoughts