The Future Of Software Development In Engineering

One of the boldest takes from AI Engineer World’s Fair 2025:  𝗪𝗲’𝗿𝗲 𝗵𝗲𝗮𝗱𝗲𝗱 𝘁𝗼 𝗮𝗻 “𝗔𝗴𝗲𝗻𝘁𝗶𝗰 𝘀𝘁𝗮𝗰𝗸 𝘄𝗵𝗲𝗿𝗲 𝗰𝗼𝗻𝘁𝗲𝘅𝘁 𝗴𝗿𝗮𝗽𝗵𝘀 + 𝘁𝗼𝗼𝗹 𝗱𝗶𝘀𝗰𝗼𝘃𝗲𝗿𝘆 𝗿𝗲𝗽𝗹𝗮𝗰𝗲 𝘁𝗼𝗱𝗮𝘆’𝘀 𝗳𝗶𝘅𝗲𝗱 𝗨𝗜𝘀; 𝗵𝗮𝗿𝗱-𝗰𝗼𝗱𝗲𝗱 𝗨𝗫 𝗮𝗻𝗱 ‘𝗔𝗣𝗜-𝘄𝗿𝗮𝗽𝗽𝗲𝗿 𝘀𝘆𝗻𝗱𝗿𝗼𝗺𝗲’ 𝘄𝗼𝗻’𝘁 𝗹𝗮𝘀𝘁.” This resonates deeply with what I’m seeing across software delivery, especially in the bigger enterprises. My take is that we’re witnessing 𝗮 𝗳𝘂𝗻𝗱𝗮𝗺𝗲𝗻𝘁𝗮𝗹 𝘀𝗵𝗶𝗳𝘁 𝗮𝘄𝗮𝘆 𝗳𝗿𝗼𝗺 𝗿𝗶𝗴𝗶𝗱 𝗨𝗜𝘀 𝘁𝗼𝘄𝗮𝗿𝗱 𝗮𝗱𝗮𝗽𝘁𝗶𝘃𝗲, 𝗰𝗼𝗻𝘁𝗲𝘅𝘁-𝗮𝘄𝗮𝗿𝗲 𝘀𝘆𝘀𝘁𝗲𝗺𝘀 that dynamically compose workflows based on intent and available tools. The developer of the future won’t want to navigate predetermined menus and forms. They’ll express intent (“deploy this service with these requirements”) and have the system intelligently orchestrate the right tools and workflows, dynamically. Some shifts I believe should happen in engineering teams is: • Internal developer platforms need to evolve from static portals to intelligent orchestration layers  • Software delivery toolchains must become composable and discoverable, not just integrated  • Teams investing heavily in hard-coded workflow tools may find themselves rebuilding sooner than expected The question isn’t whether this shift will happen - it’s how quickly organizations will adapt their delivery infrastructure to support truly flexible, agentic workflows. What’s your take? Are we ready to move beyond the comfort of predictable UIs toward more adaptive systems?

Most conversations about AI in software development stop at code completion. At AMD, we’re going much further.   Over the past several years, we’ve worked closely with both junior and senior developers across our software teams to understand what really drives productivity, velocity, and code quality. Their needs go far beyond autocomplete. Junior engineers want faster onboarding and guided exploration. Senior developers asked for help reasoning about architectural trade-offs, optimizing complex pipelines, and managing risk at scale. Productivity gains don’t come from keystroke savings, they come from intelligence embedded throughout the stack.   This is where agentic AI comes in. Instead of passively suggesting snippets, AI agents now play active roles in design exploration, automated validation, performance profiling, and release optimization. These are not just assistants - they’re collaborators, co-engineering systems alongside us.   By aligning these AI systems with our hardware accelerators and open software stack, we’re reimagining what development looks like from writing code to reasoning about it. The future of software engineering isn’t about typing faster - it’s about augmenting every stage of engineering with intelligence, purpose-built for the problems we solve.   Read my new article for IEEE Spectrum, “AMD Takes Holistic Approach to AI Coding Copilots”: https://lnkd.in/gNfyg2xJ #softwaredev #IEEE #AgenticAI #softwareengineering

The software engineer of 2025 won't look anything like the software engineer of 2020. Here's what I see coming, based on building and selling three software companies: The pure programmer is becoming extinct. Think about it - coding is getting easier. AI handles basic implementation. Low-code platforms are getting better. But solving real business problems? That's getting harder. This is why at Full Scale, we're already evolving how we develop engineering talent. We're looking for a new kind of engineer:. Someone who can: - Understand business context - Think in solutions, not features - Translate user needs into technical decisions - Know when simple beats sophisticated The next generation of software engineers won't be measured by their coding skills. They'll be measured by their ability to solve the right problems. The future belongs to engineers who can: - Think beyond tickets - Challenge requirements - Propose solutions - Own outcomes Pure coders will be replaced by AI. Problem solvers will run technology organizations. This isn't just theory. Companies are already struggling to find engineers who can think this way. That's why the smartest technical leaders are developing these skills in their teams now. Because in three years, product thinking won't be a nice-to-have for engineers. It will be the only thing that matters. Is your engineering team ready for this shift?

What is the future of software engineering with AI? AI is capable of automatically generating code, and the quality of this code is increasing over time. This is raising questions over the future role of software engineers, and some companies have slowed or stopped hiring junior engineers entirely. My own (controversial) opinion is that in the near future, all software engineers will be software managers. Software engineers do a lot more than writing code. A typical software engineer gathers requirements, writes designs, plans sprint tasks, maintains backlogs, implements tests, reviews code, provisions hardware, manages deployments, monitors operations, authors SOPs, diagnoses issues, mentors juniors, performs interviews, and much more. The time spent on actual coding tends to decrease as an engineer becomes more senior. My expectation is that many core software engineering activities will soon be performed by AI agents, including writing/reviewing/testing code, provisioning and deploying systems, and monitoring and root-causing issues. The role of the software engineer will then shift to identifying requirements, prompting agents to perform tasks, and auditing outputs from the agents. In essence, a software engineer will manage a team of AI agents to perform their core job functions. As someone who has made the career shift from engineer to manager, there are benefits to this transition. A key feature of management is the ability to force multiply, which is to achieve bigger things by leveraging teams to execute ideas. This will also hold for teams of AI agents, enabling software engineers to achieve greater outcomes than would be possible on their own.  I anticipate senior engineers will be capable of managing larger teams of agents than junior engineers. The shift to AI Agents does not necessarily mean less software engineers. The role of software engineers has been continually evolving, and AI-based software systems are getting rapidly more complex. Cloud computing previously caused a shift from low-level coding to building systems from APIs and services, but did not reduce demand for software engineers. I am personally optimistic about the future of software engineering, and looking forward to seeing what teams of AI agents will be able to accomplish. [Note that the above is entirely my own opinion, and in no way represents the views of Amazon] #ai #agents #engineering #management

How Coding Agents Are Redefining Software Development The landscape of software engineering is changing faster than ever, and coding agents are at the heart of this transformation. Over the past months, several powerful trends have started to reshape how teams plan, build, and deliver software. This actively changed my team (Uber AI Platform team): [From Assistant to Automated Execution] The quality of coding agents has improved rapidly. Engineers are now offloading smaller, repetitive tasks from “human-in-the-loop” to fully automated flows, stepping in mainly for final reviews and decision-making. This shift boosts velocity and lets engineers focus on higher-level design and innovation. [System Design with Agent Capability in Mind] When defining project scopes or estimating timelines, teams now include coding agents as part of their resourcing strategy. Architecture discussions often bring up a question : “What can the agent handle autonomously?” — redefining what efficiency and scale mean in engineering. [Connected Systems through the newly introduced the tools such as MCP and Skills] New functionalities like MCP (Model Context Protocol) and Skills are connecting coding agents to internal tools, repositories, and systems — reducing friction and making everyday development tasks easier, faster, and smarter. As a manager, I am excited to have a tool to move our engineering talent focuses on high-impact, creative problem-solving, not repetitive work. Instead of assigning valuable developer time to routine or migration-related tasks, we're designing the system to let coding agents to intelligently handle these areas, allowing engineers to concentrate on innovation and system evolution.

We are witnessing one of the most profound shifts in technology — The convergence of software engineering and AI engineering. Traditionally, AI and ML were siloed functions — built on separate workflows, different tech stacks, and often isolated from mainstream software pipelines. But with the rise of Generative AI, compound applications, and autonomous agents, that boundary is rapidly disappearing. In the near future, every software application will be AI-embedded by default. AI will no longer be a bolt-on; it will be baked into the core architecture — powering user experiences, internal logic, and decision-making. This will transform how we build and deploy technology: 1. The software development lifecycle (SDLC) and the AI/ML lifecycle will merge into a unified pipeline. 2. "Prompt engineering," "agent orchestration," and "model fine-tuning" will become core engineering skills — just like API design or cloud deployment are today. 3..DevOps will evolve into AIOps, managing not just software systems, but AI behaviors and learning loops. McKinsey’s recent survey shows that companies adopting AI-native software pipelines are outperforming peers by 20–30% in speed to market and innovation. The implication for engineers, builders, and leaders: The future isn't just about writing code — it's about designing, building, and managing systems that learn, adapt, and evolve. We're entering the era of AI-Native Engineering. And those who adapt early will define the next decade of innovation. Curious to hear: How is your team preparing and adjusting for this shift in the structure of their platform teams and integrating AI and the SDLC together? #AI #SoftwareEngineering #AIOps #FutureOfWork #Innovation

We have roughly 10–15 years to fundamentally rethink and adapt our roles in the IT/software industry. By the mid-2030s, the day-to-day responsibilities of many software professionals will look very different from today—much of routine coding and implementation will be automated by AI tools and agents. High school students should only pursue computer science (or software-focused paths) if they genuinely enjoy problem-solving, building systems, working with emerging technologies, and continuous learning—not just if they like "coding" as it exists now. Pure implementation work (what many entry-level and mid-level roles involve today) is rapidly becoming commoditized and more accessible via AI, similar to how spreadsheets reduced demand for manual number-crunching. The most resilient and valuable roles will demand creativity, deep architectural thinking, domain knowledge, collaboration with AI systems, and handling complexity that AI still struggles with. In short: Software development isn't going away, but the bar is rising fast. Treat it like a craft that evolves—not a guaranteed high-status white-collar path forever.

The future is here, just not evenly distributed. At companies like ours, our senior developers see anywhere from 15,000 to 20,000 lines of code committed in a week, up from a mere 200 to 400 that was standard in 2021. And now, by Q2 to Q3, we expect that to double again, not because developers are typing faster, but because the entire software engineering pipeline is becoming fully automated. This automation changes what “being a developer” actually means. Instead of heads down typing, they sit in the meetings that matter, stay tight to customer and product direction, work the problem framing, do the stand ups, review the tradeoffs, and make the judgment calls, while the code is being produced in parallel in the background. Manual edits happen only when it’s faster to tweak in review than to re prompt the system. The result is that the new “developer” contributes dramatically higher value work to the codebase. Less time spent on syntax and scaffolding, more time on architecture, interfaces, correctness, security, performance, and integration. The codebase doesn’t just grow faster, it matures faster. And the maturity rate becomes a function of your digital OODA loop: Observe, Orient, Decide, Act. You observe reality in production and with customers, orient by updating your understanding of what matters, decide what to change, then act by shipping. When code generation and validation are increasingly automated, the loop compresses, and the product evolves at the speed of that loop, not at the speed of keystrokes. This is a balance sheet story. When your pipeline is automated, output becomes a function of infrastructure. That opens the door for a meaningful OpEx to CapEx offset: rather than scaling engineering primarily by adding headcount (recurring cost), well capitalized teams can augment the programming function with more and faster hardware (and the systems to run it). In practice, that can speed up growth and help maintain it, because your marginal “engineering capacity” is no longer constrained to hiring cycles and org charts. The old playbook assumed software output scaled roughly with people, and EBITDA was a function of how tightly you managed headcount growth relative to revenue. In the new model, engineering throughput can scale with infrastructure investment and internal systems maturity. For companies that are well capitalized and have serious infra skills in house, this becomes a gigantic lever for EBITDA management and acceleration. And here’s where the analysts are already behind. They don’t have the resources or the feedback loops to track this pace, and the client base they typically interview is adopting too slowly, meaning their “consensus view” is anchored in the rearview mirror. Part two: how to build an enduring codebase and an enduring company on top of this, not just by “vibe coding,” but by creating the ecosystem, network effects, adoption motion, and enterprise grade trust that actually compounds.

"We're in the third golden age of software engineering - thanks to AI" Recently, Anthropic CEO Dario Amodei predicted that software engineering could be fully automated in 12 months. The industry panicked. But Grady Booch, the "Father of UML" and a 70-year veteran of the craft has a different take: Dario is fundamentally misunderstanding what software engineering actually is. If you think software engineering = writing code, you’re looking at the tip of the iceberg. 🧊 According to Booch, we’ve been through this "automation panic" twice before: 1️⃣ The 1st Golden Age (Algorithmic): We moved from plugging wires into boards to Fortran. People feared losing the "closeness" to hardware. Instead, the industry exploded. 2️⃣ The 2nd Golden Age (Object-Oriented): We moved from procedural logic to Classes and Objects. We solved the "Software Crisis" by building systems of unprecedented complexity. 3️⃣ The 3rd Golden Age (High-level): This is where we are now. AI isn't replacing the engineer; it's the new "compiler" that allows engineers to expand and evolve with AI abstracting the algorithms and OOP into natural languages. Why AI won't take your job (if you're a real engineer): Software Engineering is the art of decision making and balancing four forces: 🔹 Science & Technology 🔹 Human Collaboration 🔹 Economic Constraints 🔹 Ethics & Law AI can generate a CRUD app in seconds. But can it decide if a system architecture can solve real-world problems such as climate change, global health, and economic inequality? Can it negotiate technical debt vs. time-to-market? Can it lead a team through a series of pivots? No. The shift here is: Old Skill: Writing the most efficient loop. New Skill: System-level thinking, requirements definition, and "Imagineering." As Booch says: "The only thing truly limiting us now is our imagination." Don't fear the tools. Use them to leap. It’s time to fly. 🦅 AI isn’t ending Software Engineering. It’s ushering in its 3rd Golden Age. What do you think of this his take? Commend below. #SoftwareEngineering #AI #Programming #TechTrends #GradyBooch #FutureOfWork #GenerativeAI

Recently, Mark Zuckerberg claimed AI will replace mid-level engineers by 2025. Bold claim … but it's misleading. There's no doubt that AI tools like ChatGPT and Copilot can reshape workflows. They can generate boilerplate code, debug simple issues, and automate repetitive tasks. But AI tools can't replace human engineers (and they aren't designed to). Mid-level engineers are the backbone of engineering teams. They debug complex issues, mentor juniors, and build scalable systems that actually work. AI, on the other hand, can only predict and calculate. It can't: → Weigh trade-offs or handle edge cases → Solve nuanced problems creatively → Adapt strategically when things go awry In fact, AI just makes human skills like problem-solving, collaboration, and judgment even more valuable. Only humans can review AI-generated solutions for accuracy, spot edge cases AI can't identify, and turn automated outputs into scalable, reliable systems. The future of development isn't fewer engineers … it's engineers who know how to work with AI and fill in where machines fall short. AI and human ingenuity together will drive innovation. And mid-level engineers will always be at the heart of that collaboration. #FutureOfWork #AI #SoftwareEngineering #Meta