Nowadays, the ability of AI to write code is no longer in question. However, new concerns have arisen: Coding Agents seem to have taken over the most interesting part of the development process (writing code), while leaving all the tedious chores and “grunt work” to humans—tasks like environment configuration, deployment, maintenance, and so on. It feels as though humans are now working for the Agents.
If this were truly the case, life would be quite bitter. After experimenting for a while, I’ve discovered that besides writing code, these related chores can also be completely handled by Agents. In fact, when an Agent “wraps up” the entire workflow, the overall results are actually better.
Of course, the prerequisite is that you need to design an Agent-friendly workflow.
This article will share some of my practical experiences, including how to let the AI handle:
- Testing
- Code Review
- Project Management
- Deployment and Operations
- Debugging
Testing
Testing is perhaps the most urgent task that needs to be completed by the Agent itself. The reason is simple: as AI brings a sharp increase in development efficiency, the workload for testing has also skyrocketed. If we continue to let AI write code while humans perform manual testing, humans are destined to be exhausted.
Fortunately, tests are also code. Since an Agent can write code, it can also write tests.
At this point, many people might think of unit tests or Test-Driven Development (TDD). However, I have found that in the era of AI programming, what we need most is not unit testing, but End-to-End (e2e) testing.
End-to-end testing starts from the overall functionality of the system, testing the complete functional chain. For example, calling an API, running it with all functional logic and the database, and observing whether the results meet expectations. When an AI takes over code writing, obsessing over every unit test becomes a futile exercise in “carving a mark on a moving boat to find a dropped sword.” Only e2e tests allow us to examine the various functions of the system and control the AI-written code from a macro perspective.
The TDD approach I use is also driven by e2e tests. When asking an Agent to develop a new feature, I have it write the e2e tests first. This way, every time the code is modified, the e2e tests are re-run for verification. Such automated testing not only checks various edge cases but also catches issues immediately when code changes break something.
Code Review
To be honest, I almost never review AI-written code directly anymore, because AI is better at reviewing code than I am.
My favorite code review tool is Codex on GitHub. Codex’s review is included in the ChatGPT subscription package, making it convenient to use, and the quality of the review is very high—it often spots blind spots in the code.
The only requirement is that you need to use it on GitHub and trigger the review by opening a Pull Request (PR).
To adapt to this, I changed my personal projects from pushing code directly to submitting PRs. Unexpectedly, the PR method turned out to be even more convenient; not only do I get Codex code reviews, but I can also run the aforementioned e2e tests via CI. With this combination, low-level issues in the code are easily rooted out, and I no longer have to worry about accidentally breaking the system.
Therefore, the biggest trick to using AI for code review is not which tool you use, but standardizing your development workflow.
Incidentally, you don’t need to monitor the review comments yourself. I usually let the Agent go into the PR to read the review comments, then fix and reply to them on its own:
Process the Codex review comments for the current PR by following these steps:
1. Observe the review status and wait for the review to finish.
2. If there are no issues and all review comments are resolved, end the task.
3. Analyze all review comments and determine if fixes are needed.
4. For comments that do not require a fix, comment directly and resolve them.
5. For comments that require a fix, resolve the issue, then comment and resolve the review.Project Management
How much of your time is spent acting as a “porter” for projects? For requirements and bugs, you first move information out of the system to feed it to the Agent. After the Agent solves the problem, you synchronize the changes back into the system…
Wait a minute. Since your code and reviews are already on GitHub, why not move project management to GitHub as well? The answer is GitHub Issues, and if the project is complex, GitHub Projects.
With the help of the versatile GitHub CLI, when you encounter a bug, you just need to record it as a GitHub issue, add relevant information in the comments, and then tell the Agent: “Fix issue 123. After the fix is complete, submit a PR and link it to the issue.” The Agent can retrieve all relevant information itself and write the code. During the PR submission process, reviews and tests are naturally triggered. Once the PR is merged, the issue can be automatically closed.
Indeed, this is the project management workflow that GitHub has standardized over many years. AI is already intimately familiar with this process. As long as you give a few simple instructions, it can complete the entire sequence for you. In this case, why bother starting from scratch and suffering as an information porter?
Often, it’s not that the Agent can’t do these things, but that you have configured it with unsuitable systems and tools.
Deployment and Operations
If the previous sections were standard operations, this is where we hit the real difficulty. Deployment and operations tasks are often scattered across different systems with various one-off operations. How do we integrate this into an Agent?
This is where our heavy hitter comes in: Terraform. Its philosophy is Infrastructure as Code (IaC), meaning the state of the infrastructure is abstracted into configuration files (code). The process of deployment and maintenance becomes the process of modifying code. Originally, Terraform was a tool for a niche field, but in the AI era, its characteristics align perfectly with Agents:
Isn’t it “Infrastructure as Code”? Writing code is what I, the AI, do best!
Exactly. For various O&M (Operations and Maintenance) processes, you don’t need to give the Agent any special features; you just need to set up the Terraform project and let the Agent write HCL configuration code. Whether it’s an AWS cluster, Cloudflare, or a GitHub repository, everything can be operated this way. Once the code is written, a single terraform apply completes the deployment.
You might wonder: why go through the trouble of turning everything into code? This whole process might be slower than just clicking around on a dashboard.
The answer lies in “task integrity” and “context.”
If you always perform O&M actions manually, you limit the Agent to only writing code. When a task requires interleaving code writing and O&M (for example, writing a version of code, deploying it, observing the results, and then continuing to improve), you must manually participate: let the Agent finish part of the code, then manually handle the deployment, then let the Agent continue.
This process is not only tedious, but the Agent also never knows exactly what you did manually during the O&M phase. Because the context is missing, the Agent might make incorrect decisions. For example, if the Agent knows you deployed the site on Cloudflare Pages, it will know you want a purely static site and won’t write dynamic routes.
Therefore, the best way to let an Agent work is to give it complete tools and context, allowing it to finish a task from start to finish. This saves effort and improves the success rate of the task.
Debugging
In many people’s minds, the person with the strongest debugging skills is the most senior member of the team—the one who knows every obscure quirk of the system and can pinpoint a problem instantly based on unspoken experience when a mysterious bug appears. In contrast, an Agent, often compared to an “intern,” learns the project background on the fly. How could it possibly compete with an experienced human?
Not so! Is it possible that the person’s experience isn’t just about knowledge, but because the system has no documentation, major decisions are passed down by word of mouth, and troubleshooting relies on guesswork due to a lack of logs? New employees can’t figure out how to start investigating, so they rely on veterans to guess based on fuzzy memories.
The same applies to Agents. The effectiveness of an Agent in troubleshooting depends on how complete the context it receives is.
I used to just describe the symptoms of a problem to the Agent for analysis. Without any means of observation, the Agent could only look at the code. In such cases, it often gave incorrect conclusions; only something like GPT-o1, after long periods of “thinking,” could provide a relatively accurate answer.
Now I find that after giving the Agent complete contextual information, the probability of it identifying the root cause increases significantly. This context includes:
- Project deployment status (directly show it the Terraform code mentioned in the previous section)
- Log directories
- Database connection information
When an Agent can look at the code while analyzing logs and the database, it can usually synthesize information from multiple sources to find the cause. About 80% of problems can be diagnosed this way.
For more difficult problems where existing logs might not provide enough evidence, I let the Agent think like a human would during troubleshooting:
- First, propose several hypotheses for the cause based on the symptoms.
- For each hypothesis, add log-printing code in key locations.
- Run it again and, based on the new logs, see whether to maintain or discard those hypotheses.
I have written this hypothesis-analysis workflow into a “skill.” You can install and access this skill here:
https://github.com/nettee/ai-collection#skills
If you can master the automated debugging workflow for Agents, you will truly be among the experts in the field of AI programming.
Summary
The benefit of AI programming lies in liberating productivity—freeing people from the tedious process of writing code so they can create more interesting and valuable software. If AI only takes the “good parts” and leaves the “dirty work” to humans, what is the point of embracing AI?
If you are still stuck doing chores for the AI and helping it solve various messy tasks, please stop immediately. We should not spend our precious energy on these things; instead, we should command the AI to complete the work comprehensively, allowing ourselves to exercise our creativity.
With this mindset, you can truly step into the next stage of AI programming.