Tag: systems thinking

  • We’re Not Being Replaced. We’re Inventing What Comes Next, Including Ourselves.

    We’re Not Being Replaced. We’re Inventing What Comes Next, Including Ourselves.

    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.

  • DevOps and Systems Thinking: The Farmer, His Tractor and Olive Garden

    DevOps and Systems Thinking: The Farmer, His Tractor and Olive Garden

    As a DevOps and Agile consultant, I work with many technology leaders who see DevOps as this big tangled mess of which they are trying to make sense. When I talk to them, I have to teach them to lead in a systems-thinking manner, a key tenet of DevOps. Making sense of systems thinking is no easy task, but to make it a little simpler, let’s tell a tale of farm-to-table that includes the characters of tractor, farmer and popular Italian restaurant Olive Garden.

    A tractor is at the very most multi-purpose—it can till the field, spread fertilizer, pull a trailer to return a harvest, etc. The farmer, on the other hand, might be interested in things such as the acidity of the soil, water levels and local weather forecasts, but his ultimate goal is singular (to produce a yield of crops) and his domain expertise is narrow.

    Let’s say this particular farm provides tomatoes to Olive Garden. Olive Garden views the relationship between farmer and tractor from a completely different perspective. It cares about purchasing tomatoes to add in a variety of dishes, and cares much more about getting the tomatoes delivered to the store than how those ingredients were produced. After these tomatoes leave the farm, they become part of a complex process of delivering quality ingredients to the plates of customers.

    Now that the picture has been painted, let’s pretend that the farmer is really a member of the development team, the tractor is Jenkins, and Olive Garden represents the leadership team or their business priorities. The farmer, or developer, is thinking very narrowly and tactically. Jenkins, or the tractor, can’t prove the farmer is moving business value from one end to the other. Contrastingly, leadership wants to see everything done in a holistic way, connected to metrics and business value. This scenario leaves farmers and Olive Garden working in silos and thinking differently about how to reach goals. Sound familiar?

    This is where systems thinking, or holistic thinking, can help unite leadership and technical teams, improving culture, customer satisfaction and more. So, how do we get from this blasé transaction of tomatoes to table (or code to customer)? In general, if we only focus tactically on what we’re trying to accomplish, we aren’t thinking holistically. Holistic thinking means looking at the entire delivery toolchain and how a single piece of code ultimately will affect the end user or customer.

    The goal of leadership is to try to drive vision and to make decisions based on real data. Developers need to try to prove to leadership, especially when they start talking about tools, automation or cultural changes, that there’s going to be value in those initiatives. Sounds easy enough, but sometimes leadership doesn’t provide a good vision for how they want developers to think outside of the box, and so, they’re stuck. We’ve seen this picture before. We have DevOps engineers that are just another silo in the process; not intentionally, but because leadership doesn’t set a good vision. Systems thinking isn’t in place.

    As a consultant for Agile teams, I often see Agile and DevOps mixed together. And what I don’t agree with is that the intersection point is small; that’s a common misconception. But when we want to think outside of the box, we need to focus on ideas and capabilities and we need to be able to make data-driven decisions.

    So, what is the intersection of Agile and DevOps? Agile is just a component of DevOps. DevOps is the extension of Lean and other methodologies that came before it. In other words, Agile and DevOps can’t live without each other. In organizations that are trying to do both, I’m coaching them to try to utilize both frameworks and both cultures to do what they need because they’re ultimately the same.

    Providing a taste of data-driven DevOps to leaders is how to get them to turn their head in the direction that you want it to go.

    Ultimately, systems thinking breeds continuous improvement because, if you have a holistic view, you’re monitoring all parts of your process, and so you can have more meaningful retrospectives and you’re thinking about what you can improve all along the way. And you’re on a journey to make your organization, or your team or yourself, epic.

    — Logan Daigle