The 80% of Dev Work That Happens Before Commit

Something interesting happened in April. Cursor shipped version 3 on April 2 and rebuilt the entire interface around parallel agent orchestration. Claude Code redesigned its desktop app on April 14 around the same idea. Two of the most used AI coding environments converged on the same mental model in twelve days. The shift is quiet but real. The default mode for AI-assisted coding is changing from prompt-and-wait to run several and triage. A year ago, the loop was linear. Write a prompt, watch the output, review the diff, and move on. Now the expectation is that you have three or four things running at once, and your job is to check in when each finishes. You are not coding. You are dispatching. Most engineers have not rewired for this yet. Most teams have not either. A few things that change when this becomes the default. Context switching turns into a skill. Holding three half-finished pieces of work in your head and moving between them without losing the thread is going to separate productive engineers from frustrated ones. Some people are naturally good at it. Some are not. It is teachable, but it needs to be taught. Ticket design starts to matter more. If you want agents doing useful work, tasks have to be self-contained enough to hand over without a thirty-minute briefing. Most teams are still writing tickets for humans who will ask clarifying questions. Agents do not ask. They guess. Review cadence has to handle interrupts. If agents are finishing work at unpredictable times, your day fragments unless you shape it deliberately. Tools will catch up. Habits take longer. Cursor and Claude Code did not land on the same design by coincidence. The shift is happening. I think it's worth thinking through the plan before the chaos. #AIAgents #AgenticAI #AICoding #SoftwareEngineering #EngineeringLeadership #DeveloperProductivity #DeveloperTools #FutureOfEngineering #EngineeringManagement #TechLeadership

Claude Code isn't replacing software engineers. It’s exposing which engineering skills matter most right now. For a while, AI coding tools acted as helpful assistants focused on: 🔹 Autocomplete 🔹 Generating snippets 🔹 Explaining concepts 🔹 Making small, local edits But the shift is rapidly moving from assisted to agentic. Today’s tools can increasingly: 🚀 Understand broader codebase context 🚀 Coordinate complex, multi-file changes 🚀 Run commands and tests autonomously 🚀 Execute longer, multi-step workflows What does this mean? The value is moving up the stack. There is decreasing value in manually typing every single line of code, and massive value in orchestrating the process. The core skills are shifting toward: 🧠 Problem Framing — Designing the right context and constraints 🏗️ Architecture Review — Making high-level design choices and managing trade-offs 🔍 Testing & Evaluation — Rigorously validating AI-generated outputs 🛡️ Governance & Reliability — Ensuring security, safety, and stable infrastructure The engineers who stand out in this next era won’t just be the fastest typists. They’ll be the ones who can guide intelligent systems, review outcomes, and apply deep technical judgment at scale. Claude Code didn’t start this shift — but it is absolutely accelerating it. The role of the software engineer is changing in a very real way. #SoftwareEngineering #ArtificialIntelligence #ClaudeCode #FutureOfWork #TechTrends #SoftwareDevelopment #AgenticAI #EngineeringLeadership #DevTool

Six months after the demo, someone is debugging at 2am. Not because the code was wrong. Because nobody wrote down what "right" was supposed to mean before the AI started generating it. Vibe Coding is real and I understand the pull. You open Claude Code, drop a prompt, and forty minutes later there's a working system. Tests pass. The PR gets merged. It feels like velocity. What it actually is: borrowed time. The model doesn't know the difference between code that works today and code that survives real load. Left alone, it picks patterns that are locally reasonable and globally fragile. It won't warn you when those choices fall apart. That's not a model failure — it's a process failure. You didn't give it a contract. You gave it a vibe. Spec-Driven Development is the correction. Not a methodology, not a framework — just the discipline of writing down what you actually need before anything gets generated. The problem. The architecture. The non-negotiables. How the system should degrade when something breaks. Hard constraints, not suggestions. Chip Huyen's framing in AI Engineering is still the clearest I've seen: getting from 0 to 60 is almost trivial now. Getting from 60 to 100 is where the real work is. The spec is what makes that second half possible. Without it, you're not building software. You're hoping the hallucination was a good one. What breaks first on your team — the spec or the evaluation side? #AIEngineering #SpecDrivenDevelopment #SoftwareArchitecture #TechLead #ClaudeCode #LLM

The IDE has been the central nervous system of software engineering for 30 years. But we are officially entering the 'Post-IDE' era. We're moving from tools that assist us to autonomous agents that act as collaborative partners. This isn't just about better autocomplete; it's a fundamental shift in the developer's role. Key shifts to watch: - From Syntax to Intent: Coding is becoming a high-level reasoning task rather than text manipulation. - From Editor to Architect: Developers are evolving into 'Reviewers-in-Chief,' orchestrating intelligent systems. - Repository-Wide Context: Agents now index entire codebases to understand dependencies and business logic, not just the open file. While the efficiency gains are massive, the challenges — like security and technical debt at scale — require us to double down on system design and architectural knowledge. Are you ready to stop writing code and start managing it? https://lnkd.in/ejk54gpf #SoftwareEngineering #GenerativeAI #FutureOfWork #AIProgramming #SystemDesign

𝗡𝗼𝗯𝗼𝗱𝘆 𝘂𝗻𝗱𝗲𝗿𝘀𝘁𝗮𝗻𝗱𝘀 𝘁𝗵𝗲𝗶𝗿 𝗼𝘄𝗻 𝗰𝗼𝗱𝗲 𝗮𝗻𝘆𝗺𝗼𝗿𝗲. This is emerging from AI-generated development workflows powered by tools like :Opus 4.6 models and systems like : Claude Code. These tools can generate working code instantly. But the trade-off is subtle. Engineers are no longer writing every line. They are reviewing outputs. That shift changes everything. 𝗖𝗼𝗱𝗲 𝗼𝘄𝗻𝗲𝗿𝘀𝗵𝗶𝗽 𝗶𝘀 𝗺𝗼𝘃𝗶𝗻𝗴 𝗳𝗿𝗼𝗺 “𝗰𝗿𝗲𝗮𝘁𝗶𝗼𝗻” 𝘁𝗼 “𝘃𝗮𝗹𝗶𝗱𝗮𝘁𝗶𝗼𝗻”. *And validation is not the same as understanding.* The real risk is not bugs. It is loss of comprehension. 𝗪𝗵𝗲𝗻 𝘁𝗲𝗮𝗺𝘀 𝗱𝗼𝗻’𝘁 𝘂𝗻𝗱𝗲𝗿𝘀𝘁𝗮𝗻𝗱 𝘁𝗵𝗲𝗶𝗿 𝗼𝘄𝗻 𝘀𝘆𝘀𝘁𝗲𝗺𝘀, 𝘁𝗵𝗲𝘆 𝗰𝗮𝗻’𝘁 𝗰𝗼𝗻𝘁𝗿𝗼𝗹 𝘁𝗵𝗲𝗺.

The era of shipping apps with just a "vibe" and a prompt is evolving. We’re moving from the "magic" of AI generation back to the rigors of software engineering. Here are the key takeaways from the latest piece by <devtips/>: 🔹 Prompt Engineering isn't Software Engineering: While AI can generate snippets and MVPs, it often lacks the architectural depth, security considerations, and scalability required for long-term maintenance. 🔹 The "Prompt Jockey" Ceiling: The market is quickly shifting. While anyone can prompt, the real value is moving back to engineers who understand how the code works, not just how to ask for it. 🔹 The Return of Fundamentals: Debugging AI-generated hallucinations requires a deep understanding of logic, memory management, and system design—skills that "vibe coding" often bypasses. 🔹 Hybrid is the Future: The goal isn't to stop using AI, but to stop letting AI be the "architect." Use it as a powerful co-pilot, but keep your hands firmly on the wheel of actual engineering. The hype is settling, and the industry is looking for engineers who can bridge the gap between AI speed and production-grade stability. Read the full breakdown here: https://lnkd.in/gKTBppdA #SoftwareEngineering #WebDev #AI #Coding #Programming #VibeCoding #TechTrends #SoftwareDevelopment #EngineeringExcellence

The uncomfortable middle ground in vibe coding. You still need to be technical. You still need to understand how a business solution is built for sustainability and how software actually works, including architecture, dependencies, constraints, and trade-offs. A specification written without that understanding isn’t a workable blueprint. Each unit should be testable in isolation and backed by a stable specification, not something that shifts every time AI regenerates it with new assumptions. Otherwise, you’re not building reliable systems. You’re introducing variability where consistency is expected, especially in large enterprise environments where Product Owners play a critical role in grounding ideas into something buildable and testable. #VibeCoding #SoftwareEngineering #ProductOwnership Image source - developers.redhat.com

Developers working with AI in 2026 are spending less time writing code and more time thinking about structure. Not because coding doesn't matter, but because that part is increasingly handled. What actually takes effort now: → Deciding how agents should hand off work to each other → Setting the right roles, boundaries, and permissions → Knowing where human review needs to sit in the loop → Designing what happens when something breaks The prompt still exists. It just lives inside a larger system now. Software development has always moved toward higher abstraction. Memory management, infrastructure, deployments....each generation stopped thinking about the layer below. Code generation is that layer today. What moves up the stack is design thinking Understanding how pieces connect, where they fail, and what the system is actually supposed to do. Not a new skill. Just a more important one.

The first wave of AI coding made it easy to generate quick prototypes. But enterprise software development asks for more than a good prompt. It requires planning, testing, iteration, security, governance, and the ability to work inside real engineering workflows. That’s the shift this carousel explores: why vibe-driven coding hits a ceiling, what agentic development actually means, and how the developer role changes alongside it. If you’re thinking about AI in software engineering beyond one-off code generation, the full blog is worth a read. #GitHubCopilot #AgenticAI #SoftwareEngineering #EnterpriseAI #AIDevelopment