Debunking AI Liberating Coding from Programmers Myth

Great post! Unfortunately, the software craft and skillset required is not comprehensible to the person (typically, management) that only thinks in $$$. When a [P]M / PO / other starts to ask questions like: * Why does it take so long to ship? (no prioritization) * Why does it cost so much to build? (poor planning) * Why can't we ship all these features at once? (everything is needed; priorities) * Why can't we get this right the first time? (compounding issues; QC) * Why do we need to refactor? (not just for maintaining, but "sustaining") * Etc This person has no business managing software much less building it. Doctors don't invite everyone into the operating room. Equally bad, there is also a lot of delusions of grandeur in the field. Companies have bestowed titles to those who were less than ready to take on the responsibilities, who have the right skillset. Relatively speaking, you might be senior, staff, sr. staff, or even a principal / CTO after 20 years, maybe! Of course, there are always exceptions. Some are simply ahead of their time, but those individuals are far fewer than the number of people who think they are. Wearing a black belt does not make you a black belt. Many of us have written software long before we could spell many of the terms (e.g. polymorphism) indispensable to the craft. Learning, understanding and practicing the fundamentals is essential. I love that the craft is accessible. But, it is becoming somewhat of a lost art. AI will make it far worse before it gets better, or at least until it normalizes. But no matter, "If you are not part of the solution, there is good money to be made in prolonging the problem." - Despair.com

It has been saddening (and frustrating) to have actually heard real-life conversation where developers are labelled as "gatekeepers" to building apps. Newsflash: creating the app you always wanted was just a skill you had to learn. Still is, BTW.

The word I heard most about this is "technical". The understanding of logic, basic math, programming languages and coding was often the obscure "technical stuff" only a few wanted to approach.

This is a lie. A lie propagated by a set of people for whom the normative ways of learning programming were just fine, and therefore there was never any work being done to gatekeep knowledge and or learning. Try being Black. Try being a woman. Try being neurodivergent in a way that makes self-directed learning nearly impossible.

Also also, the FSF has existed since 1985. Stallman, think what you will of him, even created a license purpose made to protect your Freedom to use, distribute, and modify software to your liking, and even protects your ability to obtain the source code so you can do those things

Lessons from years of building, breaking and rewriting coding agents have been condensed into this new @cline SDK harness. There's a point in software engineering when incremental changes just don't cut it anymore and you are tempted to rewrite from scratch. You are almost always better off not giving in to that temptation. Except, coding agent codebases are small enough that it makes perfect sense to rework the core harness logic from scratch. Why exactly did we do this though? - We spent an ungodly amount of money on evals to squeeze the alpha of frontier models and we learnt that the new models are much simpler to use. This means: simpler system prompt, and fewer tools. We had to get out of the way of the model doing its magic. - There was just too much fluff and un-needed logic to handle the edge cases for previous models that wasn't needed anymore and it lead to a lot of dead spaghetti code - We wanted to make something really extensible that just about anyone can use to plug and play. Most good SDKs these days are closed source and you don't really know how they work, with the Cline opensource SDK people can really dive in how they can make incredible tooling on top of an agentic harness and we too get to learn from our incredible opensource community. This project is a labour of love and so many incredible ideas have been condensed into this. We have shown so much restraint both with what we added and especially with what we didn't add here. Please try this out and let us know how it feels. All you have to do is: npm install @cline/sdk https://lnkd.in/gubcJgVB

One of the most underrated problems in software development isn't writing code. It's understanding code that already exists. Rather than forcing you to read your way to understanding, this new open source tool analyzes your codebase and generates an interactive knowledge graph you can actually explore. Click on any node, see the underlying code, trace its connections, and read a plain-English summary of what that piece actually does. For anyone joining a new project, auditing an unfamiliar repo, planning a refactor, or trying to understand the blast radius of a change before making it, that kind of visual clarity is genuinely valuable. It's also a smart way to give an A.I. coding agent better context before letting it touch anything. The principle behind it is simple and worth holding onto: understand the system before you change it. Worth bookmarking if you work with complex codebases regularly. https://lnkd.in/en5DxKgd #SoftwareDevelopment #OpenSource #DeveloperTools #CodeQuality #AITools #EngineeringLeadership #TechLeadership #Programming

💻 𝒀𝑶𝑼𝑹 𝑪𝑶𝑫𝑬 𝑺𝑯𝑶𝑼𝑳𝑫 𝑺𝑨𝒀 𝑳𝑬𝑺𝑺 𝑨𝑵𝑫 𝑫𝑶 𝑴𝑶𝑹𝑬. One programming principle I’ve come to appreciate deeply is this: 📌 Clean code is not about writing more code. 📌 It’s about writing smarter, clearer, and more maintainable code. Early in my development journey, I used to think longer code meant more sophistication. But over time, I realized that overly verbose code often creates: ❌ Unnecessary complexity ❌ Difficult debugging ❌ Poor readability ❌ Maintenance problems ❌ Technical debt Good engineering is not just about making code work — it’s about making code easy to understand for the next developer (including your future self 😅). One thing I now ask myself while coding is: > “Can this achieve the same result with better clarity and less complexity?” Example in React code snippet below 👇 ❌ Verbose Approach ```jsx const UserStatus = ({ isOnline }) => { if (isOnline === true) { return <p>User is Online</p>; } else { return <p>User is Offline</p>; } }; ``` ✅ Cleaner & Concise Approach ```jsx const UserStatus = ({ isOnline }) => ( <p>User is {isOnline ? "Online" : "Offline"}</p> ); Both examples work. But the second version: ✅ says less ✅ improves readability ✅ reduces noise ✅ becomes easier to maintain Of course, concise code should never sacrifice clarity. The goal isn’t to write “short” code — it’s to write intentional code. 💡 Because in real-world software engineering: 👉 Simplicity scales better. 👉 Clean code reduces technical debt. 👉 Readable systems survive longer. 🚀 #SoftwareEngineering #CleanCode #ReactJS #FrontendDevelopment #Programming #WebDevelopment #MERNStack

Agentic coding is great — unless it's your first time. There are barely any courses, videos, or guides out there that actually help you get started properly. You're mostly on your own: reading docs, digging through GitHub issues, trial-and-erroring your way to something that kind of works. I spent weeks figuring out how to structure instructions, which skills are worth having, and how to keep setups consistent across Claude Code, Codex, and OpenCode. A lot of that time felt wasted — rediscovering things others had probably already figured out, with no good way to share it. So I built no-more-bs ("no more byte soup") to change that — at least a little. It's already published and useable. Nevertheless, it's still a prerelease. One command bootstraps your behavioural instructions and a curated set of reusable skills across all three tools, globally or per project: npx no-more-bs@latest init It's opinionated and meant to give you a real head start instead of another blank config file. 📦 npm: https://lnkd.in/eNFhTX2N 🐙 GitHub: https://lnkd.in/ezSBAm84 Feedback and contributions are welcome — more experience from different people = better tooling

Why Developer Tools Are the Unsung Heroes of Coding Let’s face it: coding can sometimes feel like you are trying to tame a wild digital beast armed only with a toothpick. Developer tools are those magical gadgets that help programmers not only survive but thrive in the jungle of syntax errors and endless testing. From code editors that make your code look like art to debugging tools that turn mysteries into solved puzzles, these helpers are the real MVPs behind every successful software project....