What keeps me up at night
It is 2 AM. I am staring at the ceiling again.
This used to happen before big releases or when something was broken in production and I could not figure it out. Now it is something else. It is the quiet thought that shows up after all the noise fades.
AI can write code.
Not toy examples. Real code. Code that looks like something I would have written after years of doing this job.
I am a senior software engineer. I have spent years getting here. Late nights, messy systems, strange bugs that made no sense until they suddenly did. That experience used to feel like a moat. Lately, it feels thinner.
For a while, I leaned on that experience. I told myself there were things AI would never understand: the weird decisions buried inside old systems, the half-broken logic that only exists because something else depends on it, the kind of knowledge you only get from being there when things went wrong.
The Ground is Moving
Then I started seeing things that did not fit that story. I watched an AI refactor a block of code I had been avoiding for days. It was not perfect, but it was clean and readable and better than what was there. A few days later, it pointed out a subtle concurrency bug. The kind that usually takes time and patience to track down. It caught it in seconds.
That was the moment something shifted for me. The machine does not “understand” the way we do. But it does not need to. With enough context, it can trace patterns across a codebase and arrive at something that works. It can hold more of the system in its head than I ever could. And it does not get tired.
That is the part that keeps me up sometimes. Not fear in a dramatic sense. Just a quiet realization that the ground under the role is moving. We are not competing with tools anymore. We are standing next to systems that can generate more output in a minute than we can review in an hour.
The math is different now.
Where Experience Still Matters
For a while, I kept asking myself the same question: If the machine can write the code, what exactly am I being paid for?
That question forced me to look at my work in a way I had not before. I do not get paid to type fast. I do not get paid to remember syntax. The value has never really been in the act of writing code. It just looked that way because that was the visible part.
The value is in deciding what should be built. In knowing when something is wrong even if it compiles. In understanding the tradeoffs that are not written anywhere. In taking responsibility when things break. Those are the moments where the cost of being wrong is high. That is where experience still matters.
A modern commercial jet flies almost entirely on autopilot, but we still pay pilots a premium to handle that 1% of pure uncertainty. Software development is rapidly shifting toward this exact model.
I started changing how I work. I let the AI handle the parts I used to grind through: setting up endpoints, filling in repetitive logic, getting a rough draft of something on the screen. I use it to scan through files when I have a vague idea of where a bug might be hiding. It is fast. It clears space.
Directing the Process
The interesting part is what happens after that. I spend more time deciding if the feature should exist at all. I look at how it fits into the system instead of just how to implement it. When something breaks, I am not just fixing a function. I am tracing how data flows through multiple services and figuring out where the assumptions failed.
There is also a new kind of work that did not exist before. Guiding the AI. Breaking a vague problem into something it can handle. Knowing when to trust the output and when to throw it away. It feels less like writing code and more like directing a process.
That shift took some time to accept. It felt like I was letting go of something I had worked hard to get good at. But the alternative is worse: holding on to a version of the job that is slowly disappearing.
The Right Side of the Line
The role is changing whether we like it or not. Some parts of software development will shrink. The kind of work that is repetitive and predictable is already being absorbed by these tools. There is no point pretending otherwise.
What remains is harder. You need to see the system as a whole. You need to make decisions with incomplete information. You need to deal with people, not just code. You need to take responsibility for outcomes that go beyond a single pull request. That is where the job is moving.
I still wake up at 2 AM sometimes.
The feeling is different now. It is not just worry. It is curiosity mixed with a bit of pressure. There is a version of this field where the people who adapt get to build things faster and at a scale that was not possible before.
We don't need 10x engineers anymore. We just need 1x engineers with 10x leverage.
There is also a version where you get left behind because you kept doing things the old way. I am trying to stay on the right side of that line.
The tools have changed. The expectations have changed. The core question has not:
What problems are worth solving, and how do you solve them well?
