I walked past a colleague’s desk and stopped.
Not because he was doing anything dramatic.
Quite the opposite.
He was sitting very still.
His monitor, however, was having a nervous breakdown.
Code was appearing everywhere.
Functions.
Files.
Terminal output.
Tests.
More code.
Then different code replacing the first code.
The screen was working harder than most departments I have ever seen.
My colleague was just watching it.
So naturally, I started watching too.
There is something deeply strange about seeing code generate on somebody else’s monitor.
When it happens on your own screen, you feel involved.
You gave the prompt.
You know what you asked for.
You are emotionally invested in whether the agent destroys your project.
But when you see it happening on a colleague’s giant office monitor from two meters away, it looks completely different.
It looks like the computer has become an employee.
And your colleague is supervising a very fast, very strange child.
I stood behind him for a few seconds.
The AI created a function.
He said nothing.
It modified another file.
Still nothing.
It ran something in the terminal.
He leaned slightly closer.
This was now television.
I had no idea what the project was.
I had no idea what the function did.
But suddenly I needed to know whether the tests would pass.
The terminal paused.
We both stared at it.
Something failed.
My colleague sighed.
I sighed too.
I had joined the project emotionally.
He turned around.
“What?”
“Nothing.”
We looked back at the screen.
The agent started fixing its own mistake.
This was better than Netflix.
Because Netflix does not occasionally rewrite authentication middleware while you watch.
I said:
“Does it always do this?”
“What?”
“Just… keep going?”
“Pretty much.”
Another file appeared.
I pulled a chair closer.
At this point, I was no longer passing through the office.
I was attending a performance.
The code kept coming.
There was something slightly indecent about the speed of it.
Developers spent decades building an entire visual language of work.
Typing.
Scrolling.
Swearing quietly.
Opening Stack Overflow.
Closing Stack Overflow because someone walked behind them.
Opening it again.
Now here was my colleague sitting with both hands nowhere near the keyboard while several hundred lines of code appeared in front of him.
If you had walked into the room without understanding what was happening, you might have thought:
Poor guy.
His screensaver is extremely complicated.
But he was working.
Every few moments he would stop the agent.
“No.”
The AI would change something.
“No, not that either.”
Change.
“Yeah. Keep that.”
And off it went again.
That was when I realized I was watching perhaps the first form of programming that resembles training a dog.
“Stay.”
“Rewrite.”
“No.”
“Good.”
“Tests.”
“Why did you do that?”
The agent never became embarrassed.
An underrated quality in a coworker.
I asked:
“So what are you doing right now?”
He looked at me as if the answer were obvious.
“Watching.”
I laughed.
“No, seriously.”
“I am serious.”
And the annoying thing was, he was completely right.
Watching had become part of the job.
Not pretending to watch.
Actually watching.
Watching the diff.
Watching the tests.
Watching whether the agent quietly decides that your database schema was merely a suggestion.
Watching for that magical moment when the machine produces something so confident and so wrong that you briefly question your own education.
The code kept moving across the screen.
At some point another colleague walked past us.
He looked at the monitor.
Then at the two of us sitting there silently.
“What are you doing?”
My colleague said:
“Programming.”
The guy looked at his hands.
His hands were holding coffee.
Then he looked at me.
I was also holding coffee.
Then all three of us looked at the screen.
The AI generated another block of code.
For several seconds, nobody spoke.
This is how cults begin.
The tests ran again.
Green.
My colleague smiled.
Not a big smile.
The tiny satisfied smile developers make when a machine finally does what it was told after first doing seventeen other things nobody requested.
I said:
“Congratulations.”
He said:
“Thanks.”
Neither of us had typed anything.
We laughed.
Then the agent started another task.
And I stayed.
That was probably the strangest part.
I genuinely wanted to see what it would do next.
There is something hypnotic about watching somebody else’s AI code.
It is half engineering, half spectator sport.
You do not know enough to intervene.
But you know just enough to become judgmental.
“Oh, I wouldn’t have done it that way.”
Would I have done it another way?
Absolutely not.
I didn’t even know what we were building.
But after five minutes beside that monitor, I had opinions.
By minute seven, I was basically code review.
The agent opened another file.
I said:
“That seems unnecessary.”
My colleague looked at me.
“You have no idea what that file is.”
“Still.”
He stared at me for a second.
Then the agent deleted the change.
I pointed at the screen.
“See?”
We both started laughing.
Eventually I had to go back to my own desk.
Which suddenly felt disappointing.
My monitor was just sitting there.
Waiting for me.
Very old-fashioned.
I looked back once.
My colleague was still in the same position.
Coffee in one hand.
The AI coding furiously in front of him.
And for the first time in my life, I understood what the future of software development might actually look like.
Not robots marching through offices.
Not humans dramatically losing their jobs.
Just one developer sitting very quietly in front of a huge monitor while code pours down the screen.
And another developer passing by, stopping for absolutely no reason, and saying:
“Wait. Let me see what it does next.”