Spec-Driven Development: A New Approach to Software Development

I would even go further to say NL based programming is only accessible to native English speakers which is not the entire world 🌏 Spec Driven Dev is the future of software engineering. Take a look at this article by Mofi Rahman 👇

This resonates. The identity piece is real — when someone has spent decades developing intuition for how systems fail and what "good" feels like, that's not just skill, it's who they are. Telling them AI handles the typing now doesn't land, because that was never really the point. What I'd add is that pattern recognition is about to become genuinely scarce. Out-of-school engineers coming up today won't accumulate the same scar tissue that comes with learning, updating, and fixing code bases in the hundreds of thousands and millions of lines that veterans of this craft have—the lived intuition is going to concentrate in a smaller and smaller group. Your most resistant engineers may also be your most strategically valuable. Let AI do what it's genuinely great at—generating boilerplate at speed, surfacing options, and holding the syntax so you don't have to. The veteran's job is to be the judge. To know which of those options is actually right, where the generated code will break at scale, and what the right abstraction really is. That judgment can't be prompted. It has to be earned.

Code Is Worthless. Senior Developers Are Priceless. Once upon a time, code was one of the most valuable assets a company could own. It took years to build a serious codebase, and that effort created a real competitive advantage. That is no longer true in the same way. Today, with the right AI tools and a couple of strong engineers, you can build in weeks what used to take years. But that does not mean engineering matters less. It means the value has shifted. The advantage is no longer in producing code line by line. The advantage is in shaping systems: - architecture - domain logic - performance - maintainability - governance - delivery discipline I’ve been challenging myself to build software through AI-first workflows, often without manually touching the code, to understand where the real limits are. My conclusion: AI can generate a lot of code. It still takes senior engineers to turn that into software you can trust. I wrote more about it here: https://lnkd.in/dp2HXiwZ

You don’t become a great developer by coding more. You become one by thinking better. And the fastest way to upgrade your thinking… Is reading what the best engineers already figured out. Here are 10 books every serious software engineer should read: 1. The Pragmatic Programmer by Andrew Hunt, David Thomas → Teaches how to think like a professional developer. → Focus on habits, mindset, and writing adaptable code. 2. Designing Data-Intensive Applications by Martin Kleppmann → The go-to book for understanding distributed systems. → Covers scalability, reliability, and data architecture. 3. The Mythical Man-Month by Frederick P. Brooks Jr. → Classic lessons on why software projects fail. → Explains complexity, team dynamics, and planning mistakes. 4. Refactoring by Martin Fowler → A practical guide to improving existing code. → Helps you write cleaner, more maintainable systems. 5. Software Architecture: The Hard Parts by Neal Ford et al. → Breaks down real-world architectural trade-offs. → Teaches how to make better system design decisions. 6. Working Effectively with Legacy Code by Michael C. Feathers → Essential for dealing with messy, existing systems. → Focuses on safely modifying and improving old codebases. 7. Database Internals by Alex Petrov → Deep dive into how databases actually work. → Covers storage engines, indexing, and distributed systems. 8. A Philosophy of Software Design by John Ousterhout → Teaches simplicity and clarity in design. → Focuses on reducing complexity at every level. 9. Clean Code by Robert C. Martin → Foundational book on writing readable, maintainable code. → Helps you build discipline in coding practices. 10. Why Programs Fail by Andreas Zeller → Focuses on debugging and failure analysis. → Teaches systematic ways to find and fix bugs. Most developers chase new frameworks. Top engineers master fundamentals. Because tools change. Principles don’t. #SoftwareEngineering #Programming #CleanCode #AI

A bit late to Marc Brooker's latest post, but it's full of great insights, like this one: "Specifications aren’t up-front designs because you don’t need to, and probably shouldn’t, develop the entire specification upfront. Instead, specifications should be at the core of an iterative software development practice. Humans are still critical to this outer loop of software development, driven by refining and extending the specification. Perhaps most crucially, they own the internally conflicting nature of software requirements. Where conflicts and trade-offs exist, either technical or in product requirements, expertise and experience come into play." It's so easy to get caught up looking for shortcuts and trying to make things easier, that you can lose sight of the fact that almost everything in life that is worth while is iterative (and time consuming). Learning and thinking through problems are not a deficiency... https://lnkd.in/gc5dvGQ2

Day 22 of public development of https://yehthatrocks.com -- 100% vibe-coded under a strict rule of "no peeping" at the code level. I've been coding since I was a teenager in the 90's. Resisting the temptation to solve problems by looking at the code is not easy. I had a bit of help with that but that's another story. What I want to say here is that I think the rise of AI is showing us clearly now the difference between a coder and a software engineer. I always had trouble differentiating these concepts in the past, I was good at programming and I was always concerned about things like robustness and performance of throughput. The whole thing was wrapped into a single concept and for a long time the idea of a "software engineer" seemed to be just a fancy title, one which I was never quite sure I deserved to use, even though I knew I was a very strong problem solver in the code arena. But now... now the matter is coming into clarity. People who can only understand a system in terms of it's code, are coders. They fuss about the minute details of the code, it has to be "just so" in order to work properly. They call themselves software engineers, but they are infact just coders. They might be very good coders, they might of memorised a textbook of highly performant code patterns, they might be able to detect a code smell from 5 miles away without even having logged in. Still just a coder. A software engineer on the other hand, a real one anyway, is not so concerned about the absolute placement and ordering of code symbols. It's just data after all, data which is fed to a compiler to be converted into real instructions. Is it robust, is the throughput high enough for the intended workload, is it as secure as can reasonably make it? These are the sorts of concerns which bother a software engineer. Coders, I'm sorry but your days of usefulness to industry are numbered, software engineers using AI are the ones who are going to be replacing you.

"LLMs write code better than I do" is a quote I heard today from a developer who left github.This quote scares me, as I believe it is a fallacy that even the people against LLMs say too often. Yes, LLMs let us save time when creating an end-product. But those of us with experience often forget that, when you buy an end-product with your time, you get something for free along with it... Experience and understanding! The more you let LLMs write the boilerplate of design reports, writing big chunks of a codebase, debug issues in an embedded system, the more your skills get rusty, the more your understanding falters... the more things you will forget... As we lose this knowledge, without even fully realising it, the more we rely on LLMs to do our day to day work... the more our finger slips onto things such as the "Rewrite with AI" button on LinkedIn when making a post.. the worse we will become at doing what we are good at doing, what we love doing... Ultimately, this loss of knowlege will lead to the statement "LLMs write code better than I do" becoming truer every day, but in a way that honestly concerns me greatly... and in a way that I believe should concern us all.

From Syntax to Intent: Navigating Software Engineering 3.0 1. Shift from Syntax to Intent: In Software Engineering 3.0, the primary unit of work has moved from writing lines of code to defining clear intent. While SE 1.0 was about craftsmanship and SE 2.0 about abstraction, SE 3.0 is about using AI to bridge the gap between human ideas and machine execution. 2. Specification is the New Coding: In this new era, your "spec" is no longer just a Jira ticket—it’s a technical artifact. Precise prompt engineering and structured requirements are now essential engineering skills. A fuzzy specification leads to fuzzy output; precision in language is now as vital as precision in logic. 3. The Rise of the "Orchestrator": Senior engineers are evolving into orchestrators rather than just implementers. The focus is shifting toward designing systems that connect AI-generated modules, third-party APIs, and cloud primitives. It’s the difference between being a chef cooking from scratch and a culinary director designing the entire menu and sourcing the best ingredients. 4. Testing as Proof of Intent: When you aren't writing every line of code yourself, testing becomes your primary way to document and enforce what you intended the system to do. Test-Driven Development (TDD) is no longer a "nice-to-have"—it's a critical guardrail to ensure AI-generated code conforms to your requirements. 5. Human Judgment Remains the Core: AI doesn't replace the engineer; it reframes them as a curator, critic, and architect. The hardest problems—understanding user needs, making ethical tradeoffs, and debugging emergent behaviors—still require deep human expertise. The most successful developers will be those who think the clearest, not those who type the fastest. #SoftwareEngineering #AI #DeveloperExperience #Coding #FutureOfWork #TechTrends #SoftwareDevelopment https://lnkd.in/gTS9CiBY

I divide software development into layers. At the core I design code that is procedural and completely transparent. Each procedure tries to stay within a dozen lines of code. No chaining. Only one step per line of code. Only allowing one level of nesting per procedure. No classes accessed from within the procedure. No closures. Inputs and outputs must be immutable. No exceptions thrown. Only synchronous. Stateless. Thread-safe. No side-effects. Very strict and strong. I do allow simple structures and arrays. And all procedures return a structure containing both a enum (flags) status and a result value. One step above Core procedures are Gateway procedures that are mostly the same but are allowed to communicate with externals such as Internet services or the OS. These do allow asynchronous behavior. Both of these layers are intentionally raw and completely lacking in magic. Everything is as obvious as I can make it. Every detail is as rigorously unit tested as possible. And then above these I have an Adapter layer that wraps these raw procedures to fit various functional or oop patterns. At the adapter layer I don’t allow any raw inputs and outputs but instead require semantic typing. I’ll use language features such as generators to minimize boilerplate code. Throughout my code I keep the design organized into small pieces with a well organized namespace. I aim for highly-reusable, flexible, cross-platform components built on top of a secure, reliable, understandable foundation. It takes a little more work to develop this way but it minimizes errors and lets me accelerate development over time. And it is highly compatible with working with AI effectively. #softwaredevelopment #programming

⚙️ One backend lesson that keeps becoming more important over time: a working API is only the starting point. In real projects, backend work quickly goes beyond just making endpoints return the right response. A few things that start mattering much more in production: • Handling edge cases properly • Writing meaningful logs for debugging • Designing responses that stay consistent across features • Thinking about database impact before adding queries • Preparing for failures instead of assuming ideal conditions A feature may work perfectly in local development, but production usually introduces different questions: 🔹 What happens when traffic increases? 🔹 How does the system behave if one dependency slows down? 🔹 Can this query still perform well with large data? 🔹 Is debugging easy if something breaks later? One thing I’ve learned is that backend development often means thinking about reliability as much as functionality. The more systems evolve, the more small design decisions start showing long-term impact 📈 💬 What backend habit do you think developers appreciate more after working on real production systems? #BackendDevelopment #SoftwareEngineering #APIs #SystemDesign #Programming #Developers #TechLearning