I've been around computers for over 30 years. My interest started when I was around 10 years old. Professionally, I've been doing this since I was 19 (24 years ago).
Back then, my actual job was network engineering. My PASSION was hacking. And when I say hacking, I don't mean posting screenshots from Burp Suite on LinkedIn while talking about "shifting left." I mean old-school offensive security culture. Tiny communities. IRC channels. Trading notes and software with people you didn't know, had never seen, and probably never would.
There weren't cybersecurity degrees. Heck, "cybersecurity" didn't exist as an industry. Now I meet cybersecurity graduates who don't know what Metasploit is.
Shudders in 1337.
But honestly? This is what always happens. A small group of obsessed weirdos build a discipline. Then tooling and access to information improve. A new job market surfaces. The industry scales. Abstractions rise. Money pours in. Conferences appear. Certifications happen. The field industrializes. Eventually most practitioners stop being artisans and become operators.
That's not me insulting anybody. That's just how industries evolve. I am a weirdo who turned into an operator. It's fine. It's natural, even.
Nobody makes their own screws anymore.
At one point, craftsmen did. Today screws are standardized, mass produced, abstracted away. Nobody building a house or a car sits around lovingly handcrafting fasteners. Mature industries stop obsessing over handcrafted primitives and start optimizing systems, throughput, reliability, and operations.
Software engineering is heading in the exact same direction.
The Artisanal Era of Software Engineering Is Ending
There's this romantic idea floating around engineering that software development is fundamentally handcrafted intellectual artistry. Sometimes it is. Most of the time it absolutely is not.
Most security engineers are not discovering entirely new classes of vulnerabilities. Most software engineers are not inventing databases. They are not writing operating systems or building elegant distributed consensus algorithms by candlelight while sipping pour-over coffee and listening to a podcast about software craftsmanship.
Most companies are trying to ship products. And most engineers, historically, were already doing production work: CRUD apps, internal systems, APIs, business logic, integrations, operational software. Valuable work, absolutely. But not artisanal mastery if we're being honest with ourselves.
AI is not creating this reality. It's exposing it.
The handcrafted era of software engineering isn't disappearing because AI suddenly became magical. It's disappearing because the economics of software delivery are changing and because most engineering organizations were already optimizing for throughput long before AI showed up. The difference now is that the abstractions are getting good enough to absorb larger portions of the labor.
And I think people are still underestimating what that means.
The Future of Engineering Looks More Like an Amazon Warehouse
If you want to understand where software engineering is heading, stop thinking about science fiction and start looking at modern warehouses.
Amazon warehouses are full of automation. Some are nearly entirely autonomous. Robots move products. Systems optimize routing. Machines coordinate massive amounts of operational work. But humans are still there. Not because the robots failed. Because highly autonomous systems still require:
- Oversight
- Governance
- Exception handling
- Troubleshooting
- Optimization
- Safety controls
- Operational management
That's the future I see for engineering. Not one super-intelligent AI replacing the entire engineering department. A managed autonomous workforce.
You'll have fleets of specialized agents:
- Software engineering agents
- Security agents
- QA agents
- SRE agents
- Compliance agents
- Functional review agents
- Functional testing agents
- … ready for it…. perhaps even PM agents!
Each with their own tooling, rules, context systems, memory models, skills, MCP integrations, evaluation pipelines, and operational constraints. And humans overseeing all of it. Not writing every line themselves. Managing the factory floor.
We're Already Living Inside This Transition
At DryRun Security, we already see engineering teams shipping significantly more work through AI-assisted editors and autonomous tooling. For VERY small, VERY low-risk changes, we'll literally assign issues to bots. Not as a joke. Not as a demo. As operational reality.
Here is the catch though… We use internally developed skills, rules, review systems, QA processes, security validation, and automation pipelines to govern how those systems behave. We still require human beings to attest that the non-human entities have done their work, correctly before that code will ever reach production.
And increasingly the pattern looks like this:
- A human drafts the design or intent.
- Autonomous systems implement large portions of the work.
- Specialized agents review the output.
- Humans validate that the systems behaved correctly.
That last part matters more than people realize. Because these systems drift constantly. This is one of the things people outside the operational reality of AI development still massively underestimate.
The newest model is not always better.
Sometimes performance gets worse. Sometimes behavior changes in subtle ways. Sometimes tools regress. Sometimes context handling degrades. Sometimes workflows that worked yesterday suddenly become unreliable because a model version changed, a tool changed, a memory system changed, or somebody decided skills are dead and now everything needs to be a "flippedy-widget".
Honestly, parts of the industry are a complete mess right now. Everyone is racing to standardize systems while simultaneously inventing the systems they're trying to standardize.
Rules became Claude files. Claude files became skills. Skills became agentic workflows. MCPs appeared. Now everyone is building portable agent ecosystems while praying the next model update doesn't light the entire workflow on fire. This is not a stable ecosystem yet. Which is exactly why human oversight becomes more important, not less.
The Real Job Is Becoming Governance
The future engineer will spend less time manually producing code and more time:
- validating systems
- reviewing outputs
- managing context
- tuning workflows
- debugging autonomous behavior
- handling exceptions
- governing operational pipelines
- and maintaining institutional knowledge
That last part is critical. Institutional knowledge is becoming machine-consumable infrastructure. Every organization is trying to encode their engineering standards, security practices, architecture decisions, operational processes, business logic, testing expectations, review patterns, and deployment safety rules into autonomous systems. And somebody has to own that.
I believe domain experts will increasingly manage domain-specific agentic workforces. Security experts managing security agents. SREs managing operational agents. QA experts managing testing fleets. Engineering leaders managing software delivery systems.
Not just prompts. Everything: models, reinforcement learning strategies, retrieval systems, skills, memory, context optimization, tool access, evaluation pipelines, governance controls, and cost management.
Because these systems behave less like deterministic software and more like employees. Highly productive employees. But employees nonetheless.
The Industry Is Moving Too Fast, Not Too Slow
One thing I don't actually believe is that the industry is resisting this transition. If anything, the opposite is happening. The bigger risk is companies going all in too fast.
People are wildly over-trusting systems they barely understand operationally. And the stakes matter. If your AI screws up a landing page headline, who cares. If your autonomous systems are touching financial systems, healthcare platforms, critical infrastructure, authentication, authorization, industrial controls, or medical devices, the consequences stop being theoretical very quickly.
Which means autonomous delivery requires governance. We're going to need:
- versioned skills and rules
- allow-listed tooling
- supply chain controls for MCPs and agent ecosystems
- evaluation frameworks
- observability into agent behavior
- rollback capabilities
- auditability
- verification systems
- and probably entirely new operational disciplines
Because yes, all the same supply chain disasters from package managers are absolutely coming for agent ecosystems too. Of course they are. Humans built those ecosystems too.
Juniors Will Learn Differently
I also think education itself is going to struggle badly with this transition. Honestly, I already think most education systems are flawed. We teach people fundamentals, then test memorization and deduction through standardized testing, while often failing to teach them how to use the actual tools they'll depend on professionally every day.
Imagine training (Building) architects how to design a building without teaching them CAD. You don't have to imagine because people right now are going six figures into debt for the privilege of that "education" (but I'll save my full rant on traditional education for a later date). That's effectively what a lot of engineering education still looks like.
Now, fundamentals still matter. The OSI model still matters. Systems thinking still matters. Networking still matters. Architecture still matters. But the operational interface to engineering is changing.
Most people will learn on the job, inside autonomous systems, while learning how those systems fail, drift, optimize poorly, hallucinate, and break under pressure. The higher-level engineer becomes the person who understands ambiguity, system behavior, scalability and performance, interconnected failures, optimization tradeoffs, and operational governance. Not necessarily the person manually typing the most code.
The typing was never the valuable part anyway.
The Deep Experts Aren't Going Away
There will still be exceptional engineers: researchers, exploit developers, compiler experts, distributed systems experts, people solving genuinely difficult computer science issues, people discovering entirely new classes of problems.
Just like there are still elite security researchers today. But most industries eventually industrialize around the work that happens 95% of the time. That's what's happening to software engineering now. Not because software engineering stopped mattering. Software is the infrastructure for today's civilization. And infrastructure eventually must be operationalized.
Nobody makes their own screws anymore. And soon, very few people will handcraft software either.
