In the past six months, I’ve transitioned from completely manual coding and typing to fully agentic
I have many projects, but the biggest one in code, written by me manually and lately by Codex alone 100%, is
https://www.ctrify.com
Before the advent of ChatGPT and even OpenAI GPT3, it utilized machine learning and AI. Once OpenAI launched the GPT 3 API, I began gradually implementing it. Initially, I wasn’t coding; I was merely generating a small amount of text (I had my own text generation system at that time).
Over 250,000 lines of code were meticulously written by me, line by line (excluding any lines of code from external libraries). The first line of code written by ChartGPT that met my standards was with GPT 5.
With Chat GPT 5.1, I started conducting code reviews as well. This practice helped me refine a few of my methods. Interestingly, it also helped me identify and correct a couple of bugs caused by typos that were silently failing.
With GPT 5.4, I began to fully trust Codex to manage entire methods and classes, even new features that were meticulously planned in detail.
It was during this time that I truly began to trust Codex’s performance and management capabilities. I even allowed it to manage all my AWS infrastructure, from updating servers and managing AMI backups to interacting with the database securely. Every line of Codex’s thinking was carefully supervised and directed towards achieving my desired outcome. At that time, I considered Codex to be a great colleague, intelligent enough to comprehend my requests (since I had previously had to correct every single thing and rant frequently to its predecessors).
I must admit that transitioning to every new model isn’t always a significant leap forward. Sometimes, early versions of a new model outperform the final version, which is developed weeks later after quantization, resulting in responses that reflect incorrect thoughts. (I refer to this as the dualization phase of every new model. Therefore, I make an effort to do as much as possible during the initial days until I notice that I start ranting again and redirecting the model, haha. That’s the essence of it.)
The key point is that since GPT 5.4, I haven’t had to write a single new line of code. The code base of CTRify has grown to 550,000 lines of code. I’ve implemented MCP, developed a comprehensive API, improved the design, content, and added numerous new features to the product.
I still vividly recall all the 250,000 lines of code I wrote. I can mentally visualize each function I created, and I know their locations. During my peak development phase, many of these functions were conceived in my mind while I was asleep. It was quite common for me to solve problems that had eluded me the previous day while I was asleep.
image @ismonkeyuser
Now, the 250K+ new lines of code are a complete mystery to me. I understand that they function correctly and how they should interact with the core API. I am certainly capable of reading and even making changes manually if necessary. However, I don’t have them in my mind as the ones I wrote. This is crucial.
Because when they fail, it could fail in a way that is unpredictable, just like when you program, you try to consider every possible interaction, but you know, users.
Well, let’s be honest… sometimes, the fault lies with us. Bugs can be challenging to locate, and AI often commits them, which only become apparent later in the production phase. Additionally, if you’re unfamiliar with your code and unable to reproduce the issue, it can be quite difficult. You can’t simply ask Codex to “fix that bug” if you lack the knowledge to explain the problem. In my opinion, the primary challenge for a Vive coder who wasn’t previously a programmer is that bug hunting is not merely a part of the development process; debugging is an ongoing endeavor in any project.
image @ismonkeyuser
The thing is, I preferred the initial 5.4 over 5.5 SOL and, in fact, I think I preferred the initial 5.5 SOL over Astra. And I’ve spent billions of tokens on it.
Why? Because I believe they’re evolving towards a more forced autonomous work model.
This might be beneficial for vive coders or programmers who haven’t managed large projects independently. However, it’s a pain for those like me who start by planning the development with the model, planning every aspect of the feature, creating a development plan in phases, and crafting the Agent.md file to follow everything in a continuous loop from start to finish without any divergence.
Recently, I’ve noticed that they’re following their autonomous lead more than my plan, which ends up wasting a lot of millions of tokens on something that didn’t adhere to the documentation and resulted in a complete waste of time. It was then completely redone with an older model, which unfortunately became dumber since the launch of the new flagship. As a result, we’re stuck in an endless loop where things aren’t getting done as they used to. This forces us to adapt to the new situation and change the way we work with them.
I organize everything by projects and features by threads, each with its own work tree. A global plan is shared among all, and they all follow it in order to know where their part will merge and connect with the others.
Previously, my approach was similar: one thread for every feature, but all sharing the same work tree. The precaution was to ensure that they didn’t work simultaneously and always closed the commit before starting to implement the next one.
The truth is, you need to plan and have a clear understanding of your architecture from the outset. Instead of letting the AI make all the decisions, you risk forcing things that may never be completed or will be completed but in a broken state.
My advice for anyone considering vive coding is that this might be the best time to start working on an app or project. However, don’t expect the AI to do everything for you. It can certainly create many things like “Make me an Instagram clone” or “Clone that feature.”
It can certainly make many things like that, but you still need to be in control and have a basic understanding of various aspects. Because AI will try to fulfill your requests, but it will never inform you that something is impossible. As a result, you may end up with a project that has many “not working buttons.”
So, don’t rush into creating that dreaming app. First, talk to Codex. Tell him what you like and discuss every feature with him. Ask him to tell you what is possible and what is not. Discuss your real budget, based on which you can decide the architecture. Remember, code doesn’t leave alone; you need hardware to run it, and there are many approaches to achieve the same. You may not need a server for a simple app, and sometimes, you may even not need a database. Discuss all these aspects thoroughly.
Once you have discussed everything, make a project plan, a development plan, and an implementation plan. Review all of them to ensure that they contain everything you agree on and not more or less. (Even during the planning stage, AI may overdo or skip some things.)
Then, create a thread for the Project Manager and instruct it to create other threads to implement each part of the development plan. Once the plan is finished, create a new thread to audit whether everyone has done their job. If so, start merging all the threads. After that, conduct a full code review.
Now, it’s time to create another thread to test all the features live. Because until that moment, what may “work for the AI” in code may break in real-world execution.
Then, test all the features again yourself or with your beta testers.
So, this is how I’ve transitioned from completely manual coding and typing to fully agentic code.
I hope this helps you in your journey. ;)