Today I had a software engineering class and while the teacher was explaining system architecture at the front of the room, I looked over and saw one of my friends building something entirely different on his laptop.
At first I thought he was just messing around with some AI coding tool during class.
But after watching for a while, I realized he was actually building a real workflow almost entirely through prompts. He had multiple windows open at the same time, testing APIs, connecting services, debugging outputs, changing logic, then reprompting the AI again whenever something broke.
The whole process looked strange honestly.
Not because it didn’t work.
But because it barely looked like traditional programming anymore.
There wasn’t much time spent writing code line by line. Most of the time he was describing intent, reviewing outputs, adjusting the direction, then letting the system continue from there.
At one point I asked him if he fully understood every part of the stack he was building.
He laughed a little and said:
“Honestly… not completely. I’m mostly coordinating it.”
That answer stayed in my head for the rest of the lecture.
Because a few years ago, software engineering usually meant deeply understanding the systems you were building. You manually wrote the logic, traced execution flow yourself, debugged every layer, and knew exactly why the application behaved the way it did.
But lately I’ve started feeling like the relationship between developers and software is quietly changing.
Especially after spending more time reading about vibecoding workflows and some of the operational AI ideas around @OpenLedger.
The more I look into it, the less it feels like AI is simply helping people code faster.
Instead, it feels like humans are slowly shifting into the role of coordinators supervising autonomous systems.
And honestly I think that’s a much bigger change than most people realize right now.
Because generating code is becoming surprisingly easy.
The difficult part is everything happening after generation:
keeping workflows stable,
understanding runtime behavior,
managing execution across different systems,
making sure autonomous processes don’t slowly break once the environment becomes messy.
That’s partly why @OpenLedger caught my attention recently.
The more I read into projects like OctoClaw and operational agents, the more it feels like they’re exploring something deeper than just AI interfaces or coding assistants.
They seem to be thinking about environments where autonomous workflows can continuously operate, coordinate tools, maintain execution loops, and adapt over time instead of simply generating outputs once and stopping.
And I think that distinction matters a lot.
A chatbot only needs to generate a response.
But an operational system needs to continuously monitor state, maintain workflows, handle failures, and keep executing while conditions underneath keep changing.
The weird thing is I’m starting to notice this behavioral shift everywhere now.
People are spending less time manually building systems from scratch and more time managing AI-driven workflows that build and operate parts of the system for them.
I’m not even sure we fully understand yet what software engineering looks like once that becomes normal.
But it definitely feels like the role of the developer is starting to change.