The Hottest Topic in Tech Has Moved from Models to Agents
If you ask me to name the hottest technical topic on the internet right now, my answer is: AI coding agents.
Not “AI coding” as a broad phrase. Code completion has been hot for a long time, and it is no longer new. What has become truly hot is something more specific: developers are starting to hand a clearly defined engineering task to AI and expect it to read the repository, edit files, run tests, explain failures, keep fixing the problem, and eventually produce something a human can review.
In other words, the center of attention has moved from “can the model write code?” to “can the agent actually take work?”
This Wave Is Not Just About Stronger Models
Over the past two years, the easiest way to trigger a technical debate was to mention a model name: GPT, Claude, Gemini, Qwen, DeepSeek, Gemma. Whenever a model was upgraded, people immediately tested reasoning, coding, multimodal input, and context length.
Recently, the excitement has shifted.
Developers are talking less about whether one model scores a few points higher on a benchmark, and more about questions like these:
- Can tools such as Codex, Claude Code, and Cursor become part of everyday development for the long term?
- Can an agent safely operate on a repository, run commands, and create pull requests?
- Are automatic review, automatic CI fixing, and automatic test writing reliable enough?
- How should we design MCP, tool calls, sandbox permissions, and context compaction?
- How can a company allow AI to modify code while keeping human responsibility clear?
These questions are not as shiny as product-launch headlines, but they are much closer to real software development.
The model is the engine. The agent is what happens when that engine is installed in a car, then connected to the steering wheel, brakes, dashboard, and seat belt. The current discussion is about the latter.
Why I Put AI Coding Agents First
This is not just a gut feeling.
The Stack Overflow 2025 Developer Survey continues to treat AI tools as a core variable in developer workflows. Developers’ attitudes toward AI have moved from “let’s try it” to “how do we use it more reliably?” GitHub’s Octoverse also keeps discussing AI together with open-source collaboration and the changing shape of code contributions. Google Cloud’s 2026 AI Business Trends puts agents at the center of enterprise AI adoption. McKinsey’s Technology Trends Outlook 2025 also treats agentic AI as a major trend.
These reports come from different viewpoints, but they point in the same direction: the next step for AI is not merely answering questions. It is entering business workflows, development workflows, and operational workflows.
In the developer world, the most natural entry point is code.
The reason is simple: software development already contains a large amount of structured context. Code lives in files, dependencies live in configuration, problems live in issues, validation lives in tests, history lives in git, and collaboration lives in pull requests. Compared with many scenarios where AI is asked to “write a nice paragraph,” code tasks are easier to decompose, verify, and roll back.
That is why AI coding agents can become popular so quickly. They are not a pure thought experiment. They can be embedded directly into work that happens every day.
The Real Change: From Copilot to Temporary Teammate
Early AI coding tools were closer to copilots. You wrote half of something, and they completed the rest. You asked about an API, and they gave you an example. You pasted an error, and they suggested a possible cause.
Coding agents take a different posture.
They are more like temporary teammates. You can give one a task:
Searching by tool_id on this page is slow. Please investigate the cause, make a local fix if possible, run the tests, and give me a reviewable change.
Then it has to perform a chain of actions on its own: read routes, find query code, inspect indexes, run the local service, modify SQL or ORM code, add tests, and explain the remaining risks.
This is much harder than “write a function.” The hard part is not code generation. The hard part is context judgment.
The agent needs to know which files are relevant and which ones should not be touched. It needs to understand the style of the existing code. It needs to decide whether a failure is caused by the environment. When tests are incomplete, it needs to explain residual risk. Once this chain can run reliably, the productivity change is no longer 10% or 20%. The division of work itself starts to change.
The Hottest Branches Right Now
If we break AI coding agents down further, the hottest branches are roughly these five.
The first is code-task automation: moving from “help me write code” to “help me finish this issue.” This is where tools such as Codex, Claude Code, Cursor, and Copilot Workspace are most naturally compared by developers.
The second is automatic pull requests and automatic review. Teams want AI not only to write code, but also to explain why the change was made, which tests were run, and which boundaries remain uncovered. An agent that can enter a team workflow must leave an auditable trail.
The third is tool calling and MCP. A chat box alone is not enough. An agent needs to read files, query databases, control browsers, inspect logs, and run commands. The more tools it can use, the more capable it becomes. The more permission it receives, the more risk it carries.
The fourth is context engineering. In the past, people loved tuning prompts. Now the more important task is providing context. Whether an agent succeeds often depends less on how elegant the prompt is and more on whether it has the right files, the right error logs, the right business constraints, and a way to discard useless context in time.
The fifth is cost and speed. A coding agent may read many files, run many rounds of inference, and process long contexts. Token cost, cache hit rate, model selection, and task decomposition all determine whether it can be used over the long term.
These branches may look scattered, but they revolve around one question: how do we move AI from “it can talk” to “it can do work, and the work can be delivered”?
The Cold Water Behind the Heat
I do not think AI coding agents are mature enough to be trusted with everything.
On the contrary, the hotter they become, the more they expose several old problems.
The most obvious one is trust. AI-generated code may run, but it may not match the business intent. It may pass one test while leaving a more subtle problem behind. It may also touch areas that should not have been touched just to finish the task.
The second problem is safety. An agent that can read a repository, run commands, access services, and submit code is essentially a high-privilege automation actor. It needs permission boundaries, audit logs, sandboxes, approvals, and rollback mechanisms. Without these, stronger capability simply means greater danger.
The third problem is team workflow. Many teams are not short of people who can type code. They are short of clear requirements, stable tests, maintainable architecture, and explicit ownership. Putting an agent into such a team will not make those problems disappear. It will expose them faster.
The fourth problem is context pollution. If developers throw a pile of irrelevant files, old discussions, and outdated documents into the context, the agent will not magically become smarter. It may only become more expensive, slower, and easier to steer off course.
So I prefer to see AI coding agents as a new kind of engineering tool, not as magical coworkers. They are powerful, but they need process constraints.
How Ordinary Developers Should Keep Up
If you are a developer, the most useful practice right now is not memorizing one hundred prompt templates.
A more practical approach is to pick low-risk tasks and put an agent into a real workflow:
- ask it to explain an unfamiliar module;
- ask it to fix a small bug;
- ask it to add a test;
- ask it to organize a refactoring plan;
- ask it to investigate a CI failure;
- ask it to draft a pull request description, then review it yourself.
Each time, pay attention to three questions: did it find the right context, did it keep the change boundary under control, and did the validation result make you comfortable?
If all three pass, raise the task complexity gradually. Conversely, if it keeps touching random files even on small changes, do not let it handle large requirements yet.
The same applies at the team level. What teams really need is not simply “buy the strongest AI tool.” They need clearer issues, stronger tests, permission boundaries, and review rules.
Agents amplify engineering quality. If the engineering quality is good, they are accelerators. If the engineering quality is poor, they make the chaos run faster.
This May Be a Turning Point in How We Build Software
I think AI coding agents are hot not just because they are new, and not because they look cool.
They touch the core cost of software development: understanding context, changing systems, validating results, and collaborating with people.
We used to think the end point of AI coding was “automatic code writing.” Now it looks like code is only an intermediate artifact. The bigger change is that development tasks themselves can be decomposed differently. Part of the exploration, trial and error, and execution can be handed to agents, while humans focus more on judgment, constraints, design, and acceptance.
This will not happen overnight, and it will not make all programmers suddenly unemployed. But it will change how strong developers work.
People who know how to use agents are not handing over their brains. They are handing over repetitive exploration, mechanical edits, and validation scripts, while keeping their energy for harder judgments.
So if I could follow only one technical trend right now, I would choose AI coding agents.
Not because they are the loudest topic, but because they are the most likely to change the way we sit in front of computers and write software every day.
Follow ZiCode on WeChat
If this post was useful, you can follow later updates on WeChat as well.
X / Twitter
Follow @ax2_zicode
Faster technical notes, short thoughts, and new-post alerts are posted on X.
