After graduating with degrees in computer science and business in hand, I entered the software industry with the energy and optimism of someone ready to create great software. My first job wasn’t called “software developer”—I was hired as a systems engineer. And that title mattered, a lot more than I first realized.
Right after being hired, I was sent through a formal systems engineering program and was immediately placed on a project that would become the foundation of a new division: Future Banking Systems. After two years of heads-down redesigning and building banking systems in Garden City, New York, I was shipped to Dallas, Texas, for an “exciting opportunity” in a new group just being formed.
Turns out the new group began with me and one salesperson, starting from zero, to form the foundation for a group that would create banking systems for an industry experiencing massive disruption due to deregulation. Our current customers were disappearing because of acquisitions, which were rolled up to become financial institutions that were beyond the scale and capabilities of our current products and business model.
Inventing Without A Net
There was no approved business plan. No product definition documents. No product roadmap. No backlog. Just a vision document, leaders with foresight standing beside us, and the knowledge that the industry was headed somewhere new and our current path wouldn’t get us there. However much we thought it would cost, we instinctively knew it would probably cost 4x more. It was our responsibility to build systems for much larger financial institutions in an industry still very much in flux.
We weren’t just creating next-gen banking applications. We were inventing systems for where the industry was going to be, not where it was. It was early, messy, and it was foundational. And it eventually led me into my first experiences with AI, developing in Lisp, Prolog, and expert systems while teaching database theory. Those formative experiences taught me something that’s stayed with me ever since: Creating software isn’t just about shipping code. It’s about inventing what comes next.
That mindset—the instinct to look ahead, to build with intent—is what real engineering is about.
Today’s AI Moment
Fast forward several decades…We’re now in one of the most disruptive and transformative moments in software history. AI can write code, scaffold entire applications, generate test cases, and devise solutions to problems in seconds. Developers are using copilots, models, and mega-prompts to accelerate their work at a pace we’ve never seen. And agents are coming online, backed by models with reasoning capabilities, to automate development tasks and tackle harder problems.
And with this combination of exuberant expectations and feverous innovation in AI, comes a familiar claim: “We won’t need developers anymore.”
I couldn’t disagree more.
Yes, AI can generate code. But just code isn’t the application, system, or product. Underlying every working application is a complex system. There are architectural decisions, engineering challenges, design trade-offs, failure modes, built-testing, security constraints, integration boundaries, long-term lifecycle concerns, and, oh yes, operability. Those don’t just come from better context and prompts.
AI massively expands what’s possible. And software development is the landing zone for AI innovations. (See Tech Vendors See the Future – Software Development Is the Agentic AI-Proving Ground.) But someone still has to know what to build, why to make it, when to create what, and for whom, and how to keep it working when the world around it continuously changes. Today’s design decisions are tomorrow’s technical debt.
What Software Engineering Really Means
Leading software teams taught me that engineering is the art behind software. It’s where experience, discipline, creativity, and instinct converge.
When a team is deep in shipping the release with heads down, checking in code, solving bugs, driving toward delivery, engineering leaders raise periscope. You have to scan for the problems that haven’t surfaced yet, the threats and opportunities forming at the edge of the horizon, and verify that our instrumentation matches course, depth, and speed. That’s engineering. It’s not just watching the project plan or tracking how many issues are in Jira. It’s reading the signals others might miss.
I’ve learned to trust that instinct: the kind of bugs we’re finding, the questions we’re not asking, the problems we haven’t had to solve yet. These are clues. They tell me if we’re still on track, or if we are behind, even when the project status says otherwise. Engineers know to pay attention to how we’re progressing, not just what we’ve done and how fast.
Engineering is more than shipping by a deadline. It’s knowing when the real blockers will hit and deciding when to face them. It’s applying instinct in tangible ways: adjusting the design, pulling forward a hard dependency, probing deeper when something hard is too easy. This isn’t about perfectionism. It’s about intent. It’s about leading a system into existence, not following a script or just building what’s asked.
We Lead the Loop
I’ll say it again: I take issue with the idea that AI will simply replace developers. We hear the phrase “human in the loop” tossed around like it’s some kind of failsafe. But that’s not what this is.
Humans aren’t destined to just be in the loop, supervising AI. We lead the loop, and where the loop is going.
We define the problem. We decide what great, good, and bad looks like. We understand when to trust, when to probe, when to double-check, and when to ask if we are asking the right questions. We raise the periscope. And that’s what this moment means more than ever.
Skating to Where the Puck Will Be
AI is where the puck is. But engineering? That’s how we skate to where the puck will be.
And more than that, it’s how we set the puck on a new arc entirely. That’s what we’re here to do now: not just follow the capabilities of AI, but lead us into new innovations in how software is created, new architectures, new apps, and systems we wouldn’t have imagined. We are the force. AI is the force multiplier.
That’s what excites me about this moment. We’re not automating ourselves out of relevance. We’re stepping into a higher role: engineers with expanded reach, clearer intent, and tools that extend our vision—not replace it. The AI IDE of the (near) future looks more like the game Starcraft, engaging through language, voice, and keyboard, versus today’s code editor and NLP interface hybrid.
We’re Being Called Forward
For those of us who’ve built real systems, who’ve led teams through impossible delivery schedules, who’ve watched the intangibles reveal deeper design flaws—we know what this era asks of us.
It’s not about writing every line. It’s about knowing that what we are doing ultimately matters.
It’s about being the one who sees the storm before it hits. The one who adjusts course, not because it’s easy, but because it’s necessary.
AI will continue to evolve. And so will we. So will all the roles across the software development lifecycle. AI is raising the bar for engineering, but remember…
We lead the loop.
Mitch Ashley is VP and Practice Lead of Software Lifecycle Engineering at The Futurum Group. The voice of “AI across the SDLC”, Mitch is a serial-CTO, speaker, advisor, entrepreneur, and product creator. He leads analyst coverage of the Software Development Cycle (SDLC), with emphasis on AI-native and agent development, cloud-native, DevOps, platform engineering, and software security.
See Mitch’s analyst research on the Futurum website.
Subscribers can access Mitch’s Software Engineering Lifecycle practice
decision-maker data, insight reports, and advisories through the Futurum Intelligence Platform.
