From Chatting to 24/7 "Working": A Senior Developer's Journey of Advancing with AI
God Translation Bureau is a compilation team under 36Kr, focusing on areas such as technology, business, the workplace, and life, and mainly introducing new technologies, new ideas, and new trends from abroad.
Editor's note: Stop treating AI as just a dialog box. True efficiency doesn't lie in "your ability to ask questions," but in having agents work for you after work. This is a paradigm revolution in the workflow. This article is a compilation.
In my experience, when adopting any truly meaningful tool, there are inevitably three stages: (1) the inefficient stage; (2) the mediocre stage; and finally (3) the stage of exploration and discovery that transforms your workflow and life.
In most cases, I have to force myself to get through the first and second stages because I usually already have an existing workflow that makes me feel comfortable and satisfied. Adopting a new tool seems like adding to the workload, and I don't want to invest that extra energy. However, to become a well - rounded developer, I usually choose to persevere.
This is my journey of discovering value in AI tools and my future exploration direction. In an environment filled with extreme exaggeration and hype, I hope this article can represent a more detailed and rational perspective, explaining my views on AI and how they have evolved over time.
Step 1: Abandon Chatbots
Immediately stop trying to do substantial work through chatbots (such as ChatGPT on the web, Gemini, etc.). Chatbots do have their practical value and are part of my daily AI workflow, but their utility in programming is very limited. Most of the time, you're just hoping they'll give the correct result based on their previous training, and once they make a mistake, you (as a human) have to repeatedly tell them what's wrong. This is extremely inefficient.
I think everyone's first experience with AI starts with a dialog interface, and when everyone first tries to use AI to assist in programming, they probably ask it to write a piece of code in the chat box.
When I was a firm AI skeptic, my first "aha" moment was when I sent a screenshot of Zed's command panel to Gemini and asked it to reproduce it using SwiftUI. I was extremely shocked by the result; it did an excellent job. The command panel in the macOS version of Ghostty now only has very minor modifications compared to the version Gemini generated for me in just a few seconds.
However, when I tried to apply this method to other tasks, I was greatly disappointed. When dealing with existing projects, I found that the dialog interface often underperformed, and repeatedly copying and pasting code and terminal output between interfaces was very frustrating. Obviously, it was far less efficient than doing it myself.
To discover real value, you must use "Agents." An Agent is a commonly used term in the industry, referring to a large - language model that can have continuous conversations and call external actions. As an agent, it should at least have the following capabilities: reading files, executing programs, and initiating HTTP requests.
Step 2: Replicate Your Own Work
In the next stage of my progression, I tried Claude Code. To put it bluntly: at first, I didn't think it was that great. In actual use, I didn't get the desired results. I felt that I had to re - polish everything it generated, and this process took more time than writing it myself. I read blog posts and watched videos, but still felt underwhelmed.
Instead of giving up, I forced myself to use the agent to replicate all the submissions I had done manually. It was like doing the work twice. I would first complete the work manually and then instruct the agent to produce a result with the same quality and functionality (of course, the agent couldn't see the ready - made solution I had written).
This process was very painful because it hindered the progress of my work. However, I've been in the non - AI tool field for a long time and know that this kind of pain during the adaptation period is natural; if I don't try my best, I can't draw a reliable conclusion.
However, professional intuition was thus formed. I quickly verified through first - principles the experiences that others had already summarized, and hands - on practice gave me a deeper understanding of these basic logics.
Break down tasks into independent, clear, and executable subtasks. Don't expect to "draw the whole owl in one go" through one long conversation.
For vague requirements, split the work into two independent stages: "planning" and "execution."
If you provide the agent with a way to verify its work, it can usually fix errors on its own and prevent functional degradation.
From a broader perspective, I also figured out - at that stage - what agents are good at, what they're not good at, and how I should operate to get the desired results for the tasks they're good at.
All this significantly improved my efficiency, to the point that I started using agents naturally and felt that their speed was comparable to mine (but I still didn't think they were faster because I spent most of the time watching the agent).
There's an "unspoken" experience worth reiterating here: part of the efficiency improvement comes from knowing when "not" to use the agent. Using the agent for tasks where it's highly likely to fail is obviously a waste of time; having the awareness to completely avoid these pitfalls is itself a time - saver.
By this stage, I found that the value of the agent was enough for me to be willing to incorporate it into my workflow, even though I didn't feel any net efficiency improvement yet. But I didn't care; at this point, I was already satisfied with AI as a tool.
Step 3: Use Agents "Before Leaving Work"
To further pursue efficiency, I started a new mode: setting aside 30 minutes at the end of each day to start one or more agents. My hypothesis was that if the agents could make some positive progress when I'm not working, then I'd gain in terms of efficiency. Simply put: instead of trying to do more within the existing time, try to use the time when I'm not around to do more.
Like my previous attempts, at first, I thought this approach was neither successful nor frustrating. But soon, I again discovered several very helpful work scenarios:
In - depth research: I'd ask the agent to research a certain field, such as finding all libraries that use a specific protocol and are developed in a specific language, and generating multi - page summaries for each library, covering advantages and disadvantages, development activity, community reviews, etc.
Parallel exploration: Let different agents try out the vague ideas in my head that I don't have time to work on. I don't expect them to produce something ready for release, but maybe when I start the task the next day, they'll have helped me identify some previous knowledge blind spots.
Sorting and reviewing issues and pull requests. Agents are very good at using gh (GitHub CLI), so I manually wrote a script to quickly start a bunch of parallel tasks to sort issues. I won't let the agent reply directly; I just want a report the next day to guide me to do high - value or low - workload tasks.
It should be noted that I don't let the agents run in a loop all night like some people do. In most cases, the agents can complete the tasks within half an hour. However, in the second half of the workday, I'm usually very tired, easily out of the flow state, and extremely inefficient. So, shifting my energy to starting these agents allows me to have a "hot start" the next morning and get into the state much faster than usual.
I'm very satisfied and starting to feel that I'm getting more things done than before the advent of AI, even if it's just a little bit more.
Step 4: Outsource Tasks You're Confident In
By this point, I'm very sure about what AI is good at and what it's not. For certain specific tasks, I'm confident that AI can come up with a generally correct solution. So, the next step in my journey is: let the agent handle all these tasks while I do something else.
Specifically, when I start work each day, I'll take the results from the sorting agent that ran the previous night, manually filter out the issues that the agent can almost definitely handle well, and then let them run continuously in the background (one at a time, not in parallel).
Meanwhile, I'll handle other things. I don't scroll through social media (at least not more than I did before AI), and I don't watch videos. I'm still in my normal, pre - AI era deep - thinking mode, dealing with the work I want to or have to do.
A very important point at this stage is: turn off the desktop notifications of the agent. The cost of context switching is extremely high. To stay efficient, I've found that as a human, my responsibility should be to control when to interrupt the agent, not to be led by it. Don't let the agent disturb you. During the natural breaks in your work, check the progress and then continue with your work.
More importantly, I think this strategy of "doing something else" helps offset the negative impacts mentioned in Anthropic's widely - circulated research on skill formation. It's actually a trade - off: you no longer need to hone your skills for the tasks outsourced to the agent, but for the tasks you continue to do manually, you'll still naturally improve your skills.
At this point, I've firmly entered the "can never go back" stage. I feel more efficient, but even if I'm not, my favorite thing is that I can now focus my programming and thinking on the tasks I really love while still decently completing the trivial tasks I don't like.
Step 5: Build a Supporting System
It's obvious: if the agent can generate the correct result on the first try, or at least only needs minimal manual polishing, its efficiency will be much higher. The most reliable way to achieve this is to provide the agent with fast and high - quality tools to automatically tell it when it makes a mistake.
I don't know if there's a commonly used term in the industry, but I'm used to calling it "Harness Engineering." The core idea is that whenever you find the agent making a mistake, you spend some time solving it through engineering means to ensure that the agent never makes the same mistake again. I don't intend to invent new terms; if there's an existing one, I'm very happy to borrow it.
This is mainly manifested in two forms:
Better implicit prompt words (AGENTS.md): For some simple problems, such as the agent repeatedly running the wrong command or finding the wrong API, you can update AGENTS.md (or similar files). Here's an example from Ghostty. Each line in that file is summarized based on the agent's previous poor performance, which almost completely solves all similar problems.
Real - world programming tools: Such as scripts for taking screenshots, running filtered test sets, etc. This usually needs to be combined with modifications to AGENTS.md to let the agent know about the existence of these tools.
This is my current situation. Whenever I see the agent doing something wrong, I'll seriously invest energy to prevent it from repeating the mistake. Or conversely, I'll do my best to ensure that the agent can verify on its own that it's on the right track.
Step 6: Always Have an Agent Running
While implementing Step 5, I'm also working towards a goal: to keep an agent running all the time. If there's no agent working at the moment, I'll ask myself: "Is there anything an agent can help me with right now?"
I especially like to combine this mode with slower, more deeply - thinking models, such as Amp's deep mode (essentially GPT - 5.2 - Codex), which may take more than 30 minutes to make some minor changes. But the good thing is that the results it produces are usually very good.
I currently don't (or rather, don't plan to) run multiple agents. I think keeping one agent running is a good balance for me, allowing me to enjoy the fun of in - depth manual work while also taking care of my somewhat clumsy but incredibly efficient robot friend.
"Keeping an agent running all the time" is currently just a goal. I'd say I can only keep an agent running in the background for 10% to 20% of my working time at present. But I'm actively trying to increase this proportion.
I don't want to run agents just for the sake of running them. I only want to start them when there are tasks that can really help me. One of the challenges of this goal is to improve my own workflow and tools so that I can generate high - value task flows for the agent to execute. This is actually very important even without AI!
Current Situation
This is my state today.
Through this journey, I've personally achieved success in using modern AI tools. I believe I'm looking at it from a realistic and well - measured perspective. I actually don't care if AI will always be popular; I'm just a software craftsman who wants to create things out of love.
The development of the entire industry is changing rapidly. I believe that when I look back at this article in the near future, I'll definitely laugh at how naive I am now. But as people say, if you're not embarrassed by your past self, you may not be making progress. I just hope I'm progressing in the right direction!
I have no personal interests in this matter. Of course, apart from practicality, there are definitely other reasons for people to avoid AI. I fully respect everyone's personal decisions. I'm not here to persuade you! For those who are interested, I just want to share my personal approach to exploring these new tools and give you a glimpse of how I face any new tool, whether it's related to AI or not.
Translator: boxi.