Hi, I’m Nam. I’m a Software Engineer with over 6 years of experience, currently working for an Australian company.
I write this blog simply to share my personal perspectives - some of which might be right, and some might be wrong.
Nothing can be predicted with certainty in an era where AI is evolving at such a frantic pace. After all, the AI we have today is vastly different from what it was just six months ago.
For the last few months, I haven’t written much code by hand.
I describe what I want, an AI agent writes it, and I review it, question it, and ship it. When I started working this way, I expected to become much faster. In one way, I did - code now arrives faster than I can read it.
What surprised me, however, is where my time went instead. The work didn’t disappear; it just moved. Writing code used to be the slow part. Now, the slow part is everything only a human can do: understanding, checking, deciding, and trusting.
We expected AI to remove our bottlenecks. Instead, it shifted the bottleneck from machine capacity to human bandwidth. Here is what that looks like in practice.
1. Shift from “Prompting to Code” to “Architecting the Workflow”
To be clear, I don’t sit around prompting an AI all day just to write functions.
My actual workflow has shifted up a level. I use prompting mainly for investigation, reading legacy code, and researching architecture. When it comes to building, I focus almost entirely on writing clear specifications and implementation plans.
Once the spec is ready, the agent pipeline takes over through an automated workflow:
- It implements the code based on the plan.
- It runs tests and linter checks automatically.
- It performs an automated self-review before even opening a Pull Request.
You would think that having such a streamlined, hands-off pipeline would free up all my time. But ironically, it created a new problem: because the entire workflow is automated, code lands in front of me faster and in larger volumes than ever before.
The bottleneck didn’t disappear - it just moved entirely to my capacity to review the plan, verify the results, and trust the outcome.
2. The Shift from Creation to Review
I can’t understand as fast as the agent can produce
An agent can finish a complex change in minutes. But understanding that change well enough to put my name on it can take hours - especially in unfamiliar domains. Looking back at my chat history, about one in ten messages to the agent was some version of “What does this mean?” or “Why did you do this?”.
At one point, I was asking the agent to write explainer documents just to help me keep up with the code it had already written. That was when I realized the bottleneck wasn’t my typing speed anymore. It was my head.
More output means a lot more code review
When writing gets cheap, you write more. But every extra Pull Request (PR) needs a reviewer.
Recently, I opened many more PRs than I would have written by hand, and I reviewed just as many from colleagues. Each PR goes through continuous integration (CI), bot review comments, fixes, and another round of review.
Even deciding how to split the work became a puzzle:
- Small PRs are easier to review, but you end up with dozens of them.
- One large PR means fewer reviews, but each one is overwhelming.
Either way, the effort lands back on people.
3. Communication and Trust Barriers
Everything is too long
Docs, Slack messages, PR descriptions, and summaries all came out longer than anyone wanted to read. A big share of my follow-up prompts were simply: “Shorter,” “Make it a TL;DR,” or “Give me five bullets.”
Long text doesn’t remove work; it just pushes the work onto the reader. When a message was going to a colleague, I spent extra time rewriting it to sound like me. I don’t want my team or partners to feel like they are talking to a robot.
I can’t trust it until I’ve checked it
“Read the code, don’t assume” became my most repeated sentence.
I’ve had an agent tell me a task was finished several times in a row before it had actually run a single command. I’ve also seen an agent confidently claim that a working feature was broken because it was reading an outdated file checkout.
None of this means AI tools are bad. It simply means verification is now the expensive part. Producing code costs almost nothing. Knowing it is correct costs what it always did.
4. Decision Latency and Context Management
Waiting for decisions
An agent never runs out of work, but people run out of time to make decisions.
Product questions, team sign-offs, security approvals, and access requests all queue up while the code sits ready. A surprising amount of my day became writing short, clear questions for stakeholders and waiting for their answers.
Key takeaway: The team moves at the speed of its slowest decision, not its fastest AI agent.
I’m the agent’s memory
Long chat sessions fill up and get compressed. As work moves between sessions, context gets lost.
Every time this happened, I had to make sure essential details survived: writing handoff notes, saving architectural decisions in a durable place, and telling the next session what to read first. Keeping the agent oriented became a core part of my daily routine.
Steering takes constant attention
Many of my prompts started with “Wait” or “Stop.”
Agents tend to over-deliver in the wrong direction: fixing things nobody asked them to touch, editing multiple repositories for a single-repo change, or charging ahead on incorrect assumptions. Keeping them on track requires active attention. You cannot fire and forget.
Time and cost are hard to predict
A minor tweak could trigger a sub-agent to run for nearly an hour, burning through thousands of tokens. Because long-running jobs were expensive to leave unmonitored, I had to watch them myself. I couldn’t always predict whether a task would take five minutes or fifty.
The Way Forward
If we want software teams to deliver more, simply adding more AI agents won’t help much. The real constraint is how fast human beings can understand, review, decide, and trust.
If we want to build faster in the AI era, this is where we should focus our effort:
- Smaller, focused changes: Keep PRs small so code review stays cheap and manageable.
- Shorter output by default: If an explanation is too long, it isn’t finished yet.
- Automated proof over claims: Require real test results and clear evidence in the PR. Prefer “Show me” over “Trust me.”
- Faster decision loops: Establish clear ownership, ask precise questions, and reduce approval waiting times.
- Durable context: Maintain clear documentation so neither human team members nor future AI sessions have to start from zero.
AI made writing code cheap. Our job now is to make understanding, reviewing, and decision-making cheap, too.
What This Means for Us as Software Engineers
I’d be lying if I said this didn’t make me nervous. If an AI agent can write most of the code, what am I for? Will there be fewer developer roles in a few years? Should I keep going in this career, or start planning a different one?
I don’t have a confident answer, and frankly, I don’t trust anyone who claims to. But living with these bottlenecks every day has shaped how I think about the future.
The bar is moving up
The expanding role of a software engineer
The definition of a software engineer has fundamentally shifted. With an agent handling execution, we’re no longer just writing code - we’re the business analyst defining specs, the QA engineer hunting edge cases, the product owner weighing trade-offs, and the communicator aligning teams. AI didn’t shrink the role; it turned it into a full-spectrum discipline.
The part being automated is the part we used to take the most pride in: typing out a feature from scratch, remembering complex syntax, or knowing a framework inside out. That mechanical skill is getting cheaper fast. If my primary value was simply “I can write code,” then yes - that value is shrinking.
The work that remains is harder, not easier. Every bottleneck highlighted in this article relies on a human skill:
- System understanding: Grasping a complex codebase you didn’t write by hand.
- Critical judgment: Knowing whether a change is genuinely correct, secure, and maintainable.
- Clear communication: Asking the right questions and explaining technical concepts simply.
- Ownership: Making a decision, carrying it forward, and standing by it.
AI didn’t eliminate the need for engineers. It simply removed the easy half of the job and left us with the hard half. A developer who understands the domain, reviews code rigorously, and breaks through organizational bottlenecks is now the exact constraint everyone else is waiting on - more valuable than ever.
Should we stay or switch?
My honest take comes down to what you enjoy most about this craft:
- If you enjoy solving high-level problems: This is still a great career to be in. The problems are getting bigger, and with AI, we can now accomplish far more than we ever could alone.
- If what you loved was purely the mechanical act of typing code: That is worth thinking about seriously, because that part of the job is undergoing the biggest transformation.
Regardless of your choice, the core skills are portable: judgment, communication, domain expertise, and verification are invaluable in almost any career. Investing in these skills isn’t just a bet on staying in software - it’s a bet on yourself.
For me, I’m staying. Not because I’m certain the job title will look the same in five years, but because the hardest and most interesting parts of building software are still ours.
AI made writing code cheap. What’s left for us is understanding, judgment, and trust - and that work is still very much worth doing well.
Beyond Software: This Isn’t Just About Coding
While I write this from the perspective of a software engineer, I don’t think this reality is limited to tech. Developers are just the first wave of workers testing what it’s like to co-exist with AI agents every single minute of the workday.
What is happening to software will happen to almost every knowledge-based profession:
- Designers are no longer limited by their drawing speed. Their bottleneck is now art direction - curating, judging taste, and knowing which of the 100 AI-generated variations actually aligns with a brand’s identity.
- Writers and marketers aren’t struggling to generate words anymore. Their bottleneck is editing, fact-checking, and tone - removing the dry AI fluff to ensure the message sounds authentic and trustworthy.
- Lawyers, doctors, and financial analysts will see AI digest documents and data in seconds. But their bottleneck remains responsibility and high-stakes judgment - because an AI cannot be held accountable when a decision goes wrong.
In almost every field, creation is becoming cheap, while verification, taste, and accountability are becoming expensive.
If your work relies solely on executing a repeatable process, AI will press you hard.
But if your work relies on critical thinking, connecting with people, knowing what to build, and taking responsibility for the outcome - your value isn’t disappearing. It’s becoming the most critical link in the chain.
P.S. I wasn’t drunk while writing this blog - it just took me one delicious coffee on a hot Sunday in Sài Gòn. ☕☀️