Raju Makwana’s Post

Vibe coding is over. Or maybe the debate is missing the point? Some engineers look at what is happening and say: this is not software development. They may be right. But the label does not change the mechanics. If you built useless stuff for cheap, it is still useless stuff. Now it just appears faster, and there is more of it. AI did not suddenly create better ideas. It removed friction from building. So execution got cheaper. Bad thinking got more expensive. That is why direction beats output now. When production becomes easier, the world does not fill with better products. It fills with more products. Users do not want an endless stream of half-invented apps, one more dashboard, one more “revolutionary AI copilot”. The bottlenecks moved: -finding real pain and cutting the rest -winning attention in a sea of “fake it till you make it” -embedding into workflows until value becomes repeatable -building a system, not a one-time hero story Soon, most code will not be written by hand. But democratising production does not democratise success. So the question is not “can you ship”. The question is: can you think, choose, and focus better than the noise? #AI #Vibecoding #SystemsThinking #Business

You wouldn't use a crane to put a nail in a wall. AI tools work the same way. Each primitive has a right use case. An explorer reads your codebase. A reviewer checks your changes. A task runner builds your code. Wrong tool, wrong result. But picking the right tool isn't enough. Software engineering is creative and iterative. Every developer has their own workflow. Every team has their own patterns. Generic AI tools and open-source skill repos are a good start. But they don't fit your workflow out of the box. They need to be tweaked, shaped, and engineered into YOUR system. Matched to your architecture. Your conventions. Your project's boundaries. Your org's standards. That's not prompting. That's engineering. Most engineers change their workflow to fit the tool. The ones who get reliable output do the opposite. Right primitives. Right fit. Right system. What AI tool did you have to customize before it actually worked for you? #AIEngineering #DeveloperProductivity #AgenticCoding #SoftwareDevelopment #CodingWithAI

Vibe-Coding: Speed without Validation is Just an Illusion GitHub’s latest report revealed a striking figure: 46% of code is now written by AI. This isn’t just an increment; it’s a paradigm shift happening at an unprecedented velocity, reshaping the very fabric of software development. The allure is undeniable: instant solutions, seemingly flawless code generated at the speed of thought. Developers are increasingly embracing ‘vibe-coding’ — that intuitive, rapid generation of code snippets, functions, or even entire components based on a prompt, often bypassing traditional architectural planning or extensive manual validation. It feels magical, dramatically shortening the path from idea to functional code. For teams under pressure, it promises to break bottlenecks and accelerate delivery like never before. However, beneath this veneer of rapid progress lies a substantial, often unseen, risk. Speed without robust validation isn’t progress; it’s accumulating ‘invisible technical debt.’ Unlike visible bugs or explicit errors, this debt manifests as subtle inconsistencies, architectural misalignments, or performance bottlenecks that only surface much later in the development cycle, or worse, in production. AI-generated code, while often syntactically correct, can introduce invisible technical debt if not properly validated for architectural fit, security, and consistency. The answer isn’t to slow down AI adoption, but to scale validation processes to match its pace, integrating automated architectural validation that understands context and implications before code is merged. The question for every CTO isn’t whether to use AI for coding — it’s whether their validation process scales at the same pace. Our ability to leverage AI’s speed will ultimately be defined by our capacity to ensure that speed translates into sustainable, high-quality, and maintainable systems, not just a burst of activity. #AI #CodeQuality #EngineeringLeadership #SoftwareDevelopment

Is AI creating more code than teams can realistically own? It effectively can remove one of the biggest bottlenecks in engineering: writing the actual code. When used within team and projects, code velocity is up. AI can now scaffold services, generate logic, and even write tests, streamlining the path to production faster than ever. But is the comprehension of what we are building keeping pace? We’re starting to see systems where: • large chunks of code are AI-generated • design decisions are implicit, not intentional • documentation exists… but isn’t always trusted or maintained You can already see early signs of this, in the flood of low-quality, AI-generated pull requests some open source projects on GitHub are dealing with right now. I’ve always been a fan of pair programming, even with senior engineers. Not because of oversight, but because it forces shared understanding. Design gets discussed. Trade-offs are visible. Knowledge organically spreads as the system is being built. With AI in the mix, that shared understanding doesn’t happen by default anymore. It needs to be intentional. From an SRE perspective, that means doubling down on: • clear ownership • well-understood failure modes • clear observability and known response paths when things go wrong Because reliability isn’t about how fast you can ship. It’s about whether your team actually understands what they’ve built when it starts breaking. And AI is not the problem. It is increasingly becoming a valuable progression in program development. But if our coding velocity keeps increasing while our comprehension drops, we’re going to feel that gap in production. Genuinely curious how others are seeing this in their teams or personal projects: Are your teams evolving how they design and own systems with AI, or just moving faster? #LookingForWork #SRE #DevOps #AI #SoftwareEngineering

If AI writes the code that developers themselves don’t fully understand, are we boosting productivity today or quietly creating tomorrow’s technical debt? AI is enabling teams to ship faster than ever. Features that once took weeks to develop are now completed in days. Boilerplate code is generated instantly, and patterns are auto-generated. However, a challenging question is emerging beneath this speed: Who truly understands the code we are deploying? When developers copy, adapt, or accept AI-generated code without fully considering design choices, edge cases, performance trade-offs, and security implications, we may be outsourcing not just typing, but thinking. In the short term, productivity appears fantastic, but long-term risks begin to surface, including: - Systems that are difficult to debug - Fear of modifying code that “works but no one understands” - Maintenance costs quietly surpassing development speed Some questions worth reflecting on include: - Are we reviewing AI-generated code with the same rigor as human-written code, or just doing it faster? - Are junior developers learning the fundamentals or merely mastering “prompt-and-paste”? - Do we measure productivity by lines delivered or systems understood? AI can serve as a productivity multiplier or a technical debt accelerator. The distinction lies not in the tool itself, but in the discipline surrounding its use. I am curious to hear from others: How are you balancing AI-driven speed with long-term code health? #AIInEngineering #TechnicalDebt #SoftwareArchitecture #DeveloperProductivity #AIAdoption #EngineeringLeadership

𝐄𝐯𝐞𝐫𝐲 ~𝟔 𝐦𝐨𝐧𝐭𝐡𝐬 𝐭𝐡𝐞 𝐜𝐞𝐢𝐥𝐢𝐧𝐠 𝐟𝐨𝐫 𝐰𝐡𝐚𝐭 𝐀𝐈 𝐜𝐚𝐧 𝐝𝐨 𝐢𝐧 𝐒𝐨𝐟𝐭𝐰𝐚𝐫𝐞 𝐄𝐧𝐠𝐢𝐧𝐞𝐞𝐫𝐢𝐧𝐠 𝐦𝐨𝐯𝐞𝐬 𝐚𝐠𝐚𝐢𝐧. Not incrementally. Architecturally. A simple way to see this is to look at how AI coding capabilities have evolved in just a few years. 2023 → Functions 2024 → Files 2025 → Features 2026 → Task loop agents We have quietly moved from assistants to agents. Assistants help generate code. Agents take an objective and run the loop: read the repo, plan changes, edit files, run tests, fix failures, and open the PR. Tools like Cursor, Claude Code, Devin and Windsurf are converging toward this model of #AIAgents and modern #DeveloperTools. Most discussions focus on the obvious outcome: it is becoming dramatically faster to turn ideas into working code. But something deeper is happening. When the cost of producing code collapses, the 𝐧𝐮𝐦𝐛𝐞𝐫 𝐨𝐟 𝐩𝐨𝐬𝐬𝐢𝐛𝐥𝐞 𝐢𝐦𝐩𝐥𝐞𝐦𝐞𝐧𝐭𝐚𝐭𝐢𝐨𝐧𝐬 𝐞𝐱𝐩𝐥𝐨𝐝𝐞𝐬. Architectures that once took weeks to prototype can now be explored in minutes. Refactoring paths can be tested in parallel. Entire design spaces can be searched instead of debated. The engineering loop starts to shift. Instead of build → test → iterate, it increasingly looks like explore → evaluate → converge. Systems can now traverse parts of the solution space that humans simply never had time to explore before. Once exploration becomes cheap, the leverage moves to how intelligently we navigate that search space. That is fundamentally a #SystemDesign problem. The best engineers I know are starting to think a little less like programmers and a little more like system designers guiding an optimizer. It reminds me of something I wrote about earlier: many complex systems eventually collapse into finding the right variable to optimize. AI assisted development might quietly be pushing AI Engineering in that direction too. #SoftwareEngineering #Developers #Coding #Programming #DevTools #DeveloperTools #AIForDevelopers

⚡ AI is changing how fast we build software Recently I’ve been exploring tools like GitHub Copilot and some emerging AI agents that assist developers during the development process. What I’m noticing is simple but powerful: AI doesn’t just help us write code faster — it helps us build solutions faster. A few things that are making a real difference 👇 🤖 Less repetitive coding AI tools quickly generate boilerplate code, APIs, and basic structures. 🔍 Understanding code faster AI can explain complex code or summarize files, which saves a lot of exploration time. ⚙️ AI agents helping in workflows New AI agents can assist with tasks like refactoring, writing tests, or suggesting improvements. 💡 My takeaway AI is not replacing developers. It’s becoming a smart teammate that helps us move faster. For engineering teams, the real benefit is more time for design, architecture, and solving real problems. And honestly — it’s an exciting time to be building software. 🚀 #AIinSoftwareDevelopment #GitHubCopilot #AIAgents #TechLeadership #DeveloperProductivity

Will AI replace the programmer? No. But it will replace the "typist." ⌨️🤖 Software development is no longer about typing syntax; it's about architecting solutions. AI tools like GitHub Copilot are removing the friction of boilerplate code, allowing teams to ship features faster. But speed without safety is just technical debt. In our latest video, we explore the balance between velocity and verification in the AI era. We cover:  🔹 Drafting: Using autocomplete to skip the "blank page" phase. 🔹 Refactoring: Cleaning up legacy codebases in minutes. 🔹 The Catch: Why "Human Code Review" is more critical now than ever before. 📺 Watch the full breakdown: https://lnkd.in/gMTMZBB3 #SoftwareEngineering #DevOps #GitHubCopilot #AI #TechLeadership #Coding #FutureOfWork

AI is quietly killing one of the biggest advantages developers had: implementation speed. For years, we were valuable because we could: • write clean code • know frameworks deeply • build APIs faster • understand tooling better That layer is collapsing. AI can already generate: components, APIs, migrations, tests—even glue code. But here’s the uncomfortable truth: Most developers are still optimizing for speed… while the market is shifting toward judgment. AI removes effort. But it increases responsibility. Because now: Anyone can generate code, but very few can decide if it should exist. The real value is moving up. Not in writing code… but in deciding what should be built. The hard problems now look like this: • What should we build—and why? • What trade-offs are we accepting? • What breaks at scale? • What constraints are we missing? • Is this architecture sustainable? And here’s the shift most people are underestimating: Bad code used to fail fast. AI-generated code fails silently at scale. This is no longer just engineering. This is systems thinking. The engineers who win will be the ones who can connect: product + architecture + reliability + cost + user behavior Because in the future, you won’t be paid for writing code. You’ll be paid for making the right decisions about it. Curious how other engineers are seeing this shift.

Couple of months ago, I went from leading engineering teams to going hands-on and that required working a lot on AI coding agents — Claude Code, Copilot, Lovable, Replit — on real projects, daily.   As someone who's built and scaled teams at tech giants, I thought I'd pick these up fast.   I was wrong. The gap between using these tools and using them well is enormous.   Four things changed my output quality dramatically:   𝟭. CLAUDE.md / AGENTS.md A markdown file at your project root describing your architecture, conventions, and constraints. Without it, the agent guesses. With it, it follows. The agent stopped inventing its own naming conventions overnight. Highest-ROI setup I've found.   𝟮. Task decomposition Early on I'd describe an entire feature and get something that looked done in 10 minutes. Fascinating — untill code base grew and bugs increased exponentially in generated code. Breaking features into small, testable chunks improved agent effectiveness significantly.   𝟯. Model selection I burned two days on iteration cycles before realizing I was using a fast model for a task that needed deep reasoning. The fix: reasoning models for architecture, fast models for implementation. Auto-routing isn't there yet.   𝟰. Prompt quality The most underestimated lever. 5 minutes structuring a prompt saves 30–45 minutes of back-and-forth. Every single time.   The tooling is here. The craft of using it well is still emerging.     #SoftwareEngineering #CodingAgents #EngineeringLeadership #DeveloperProductivity