From Notepad to Agents: Nearly Twenty Years of My Tools Doing More

Debugging used to mean scattering print statements and hoping for the best.

I started coding in Java in 2006, in Notepad. There was no syntax highlighting, no autocomplete, and no inline error checking. If you misspelled a variable, you only found out when you ran javac from the command line. Debugging meant reading your code slowly (often twice) and instrumenting it with printouts; there wasn't much else to rely on. Not out of nostalgia: development was slow, and much of the craft was tolerating the tedium.

Not long after, I picked up .NET: C#, VB.NET, and J#, working mostly in Visual Studio. That was my first real taste of an integrated debugger: stepping through code line by line instead of inferring behavior from logs. J# was Microsoft's attempt at a Java-like language on .NET. I learned most of it from tutorial DVDs because reliable internet was uncommon then.

Then came mobile development. I tried Symbian on Nokia phones using NetBeans but never really got good at it. Eventually I gave up on Symbian and moved to Eclipse to learn Android. That's where mobile development finally started to make sense to me.

The tools started taking away the boring parts

Notepad++ was probably my first real upgrade: syntax highlighting, tabs, and a find-and-replace that worked across files. It sounds trivial now, but those conveniences drastically sped up iteration and reduced the friction of switching contexts. Those small wins set the stage for later leaps: full IDEs, better debuggers, and, eventually, intelligent agents.

Then came IntelliJ, and later PyCharm. Autocomplete that actually understood the code you were working with, not just the word you were typing. Refactoring tools that could rename something everywhere it was used, safely, across the whole codebase. At the time, this felt like the tool was finally keeping up with how quickly I could think. Looking back, most of it was just removing friction from things that weren't really the important part of programming anyway.

The same thing happened with languages. You'd learn a new language, and along with the language you'd learn a whole new set of manual habits around how to work with it. Clojure was probably the clearest example of that for me. I spent a few years with it, roughly 2013 to 2016, and it was a completely different way of thinking about code compared to the Java and C# I was used to.

And Stack Overflow was basically part of the development environment. You'd hit an error, search for it, find the answer with the most upvotes, and try it. Except sometimes it wasn't the right answer for your problem. The votes told you that the answer had helped a lot of people, they didn't tell you whether it applied to your particular situation. That gap between the popular answer and the right answer is something we've spent years trying to close.

Then the tools started writing code

Generative AI changed this again, and this was different from autocomplete. Instead of finishing the line I was already writing, it could write the whole function. Sometimes an entire feature. And it was right often enough that ignoring it started to feel like a waste of time. There's a controlled study from Microsoft, GitHub and MIT Sloan that found developers using GitHub Copilot completed a coding task 55.8% faster than developers without it, a pretty significant improvement for a single tool.

But the bigger change wasn't speed. It was where my attention went. I spent less time typing boilerplate and more time asking: is what it just wrote actually correct? The work moved up a level.

I started using Copilot with VS Code in plan mode, letting it first work through the task and explain the approach before writing anything. Then I could switch to agent mode and let it make the changes, run the tests, and iterate on the result. It felt like a much bigger shift than autocomplete. The first few times, it honestly felt like I was giving up some of my power as a developer. I wasn't just asking the tool to help me write code, I was giving it enough context to make decisions about the codebase and carry out the work on my behalf. That was useful, but it was also unsettling. The work moved up another level: from writing code, to directing the work, reviewing the decisions, and deciding whether the result was good enough to keep.

Now the tools don't just write. They act.

This is where agentic AI feels different to me. An agent isn't just suggesting a line of code for me to accept or reject. I can give it a task and it can go through the repository, understand the code, make changes, run tests, fix things, and potentially open a PR. One I set up was handed nothing more than a one-line spec and came back with a working internal tool; another went looking through a production codebase on its own and reported back a set of N+1 query issues nobody had flagged. That's a very different relationship with the tool, and it took me longer to trust this than it did generative AI. There's a difference between reviewing a line of code suggested by an AI and saying, "Here, take this task and go do it."

I don't think the uneasiness around that is irrational either. You're giving up a certain amount of visibility and control. The system is making decisions while you're not necessarily watching every step. It's reasonable to be uncomfortable with that.

And the interesting thing is that adoption and trust seem to be moving in opposite directions. Stack Overflow's 2025 Developer Survey had AI usage among developers at 84%, up from 76% the year before, a figure also confirmed in their official press release. At the same time, trust in the accuracy of AI output went down. So we're increasingly using tools that we don't completely trust. That feels like an accurate description of where we are right now, and it's pretty close to how I felt when we started introducing agent-based tooling internally this year.

So what actually changed?

When I look back over nearly twenty years of development, the tools have changed massively. Notepad gave way to real IDEs, then autocomplete, then generative AI, and now agents. Each step removed more of the mechanical work.

But the thing that hasn't really changed is judgment. Knowing what good code looks like. Knowing what "correct" means. Knowing when something looks right but isn't. Notepad couldn't do that. Neither can the most capable agent. That's still our job, and I think that's probably going to be true for a while.

The part I'm still figuring out now is what this means for engineers earlier in their careers. I learned to code when the tools forced you to do almost everything yourself. They're learning in a world where the tools can do a lot of that work for them. What used to take weeks of trial and error, they can now get in seconds, code that looks plausible and often is. The skill I find myself teaching isn't how to write it anymore; it's how to tell when it's wrong. That's a very different way to learn software engineering, and I think it's probably a post of its own.