If you have read any of my previous blog posts, you already know that I have been using ChatGPT for about a year while developing a personal application, a multi-layered encrypted password vault. I have written about that experience before, including both the good and the bad.
For most of that time, I was working only with ChatGPT for help with both the coding and the security features I wanted built into the application. Because ChatGPT never had direct access to the actual code files, everything had to be provided manually, either by uploading single files or zip files, or by pasting code directly into the chat.
From there, I would explain my requirements to the AI. Over time, those requirements had to become tighter and more specific. Or, more accurately, the work had to be broken down into smaller and smaller tasks, because I found that the AI would otherwise drift. That often meant rewrites, and rewrites meant lost time.
At this point in the development process, I would always ask that AI provide me either a full class file or a complete rewrite of the class file that was being modified. Which I would manually review for bloat or drift. Bloat might consist of either using multiple methods in different classes that did the same thing or techniques that were just overly complicated for the simple task that I defined. After AI had met my requirements, I would then provide the actual code update in Visual Studio.
The process I am describing was very detailed and broken into a number of steps for each change, which opened the door to mistakes on my part. I might miss something, copy code into the wrong class file, or run into errors that required multiple recompiles. If bugs were detected, I would then have to go through the same process again and again, copying files, pasting code, and reviewing code until the bug was isolated and corrected.
In other words, a great deal of time was spent on the overall coding process itself. On top of that, this workflow could burn through the resource limits of my Plus subscription very quickly during a single coding session.
What did come from working this way over the months, however, was that ChatGPT built up a solid memory of the application’s architecture, my requirements for the application, and the coding standards that I remained very strict about.
At one point, I hit a bottleneck in development because the changes I needed to make were pushing the limits of the coding process I was using. That is where Codex came into play.
I did try working with the Linux version first, but because I was dealing with so many code files, and because everything was command-line driven, it felt like I was making the process harder rather than easier. Not long after I abandoned the Linux version, OpenAI released a working Windows version of Codex.
That is the version I am using now, and what I am about to get into is how I use it and the process I have developed around it.
With only a basic understanding of Codex’s capabilities, I relied on ChatGPT to help guide me in learning how to use this new tool, and I still do. What I have found, however, is that by dividing responsibilities between ChatGPT, Codex, and myself, I have significantly sped up development and dramatically reduced the time spent making changes, tracking down bugs, and correcting them.
What follows is the process I have developed, one that works well for me.
Responsibility breakdowns of ChatGPT, Codex, and myself
I am the architect, project leader, and lead analyst. The design of this application is mine. The core security model and usability of the application are defined by me, and both have remained explicit and consistent throughout the entire process. I am also the one who reviews, approves, applies, and deeply tests the changes before anything becomes part of the live codebase. I have the first and last say in what gets done, how it gets done, and whether the change actually works the way I expected and required.
ChatGPT has shifted from being my lead coder to what I would now call my program lead. As before, I provide ChatGPT with my requirements and define the small task I want completed. The difference is in how that work now flows. Previously, I had to provide all of the relevant code files for ChatGPT to analyze before it could suggest changes and return full rewritten code for me to apply manually.
Now, ChatGPT provides specific directions to Codex for the initial analysis. That analysis does not require me to manually provide files, because Codex has access to the actual codebase. ChatGPT and I then review the detailed feedback from Codex. From there, we either correct or refine the analysis, or ChatGPT provides a new set of detailed directions for Codex to make the actual changes.
I still have to copy and paste those instructions from ChatGPT into Codex, but they are far more explicit and structured than anything I would provide on my own. That helps keep Codex restricted to the specific task at hand.
One important point is that I do not allow direct changes to the live code files. Codex creates temporary files instead, so there is no risk of file corruption during the process.
At this point, Codex has explicit, narrow, and highly specific instructions about what it needs to do. Because it has access to the project folder, there is no need for me to copy and paste code into it. It always has access to the most current information available, whereas that was always somewhat uncertain when I was working only with ChatGPT. That limitation was entirely due to ChatGPT’s resource constraints, nothing else.
Also, because of the explicit instructions coming from ChatGPT, Codex provides a detailed explanation of what it believes should be done, the order in which it should be done, what has been changed, and why those changes were made.
And remember, when Codex makes actual code changes, those changes are written to a file with _tmp as the leading qualifier. The rest of the filename remains the same as the original code file where the changes are intended to be applied.
I have found that I am now getting better analysis to support the decisions I need to make. I am also being provided with a list of individual tasks that can be completed one at a time, which keeps every change controlled. That leads to better management, makes problems easier to spot, and allows commits to be made in smaller stages so that, if something goes sideways, rollbacks are limited and controlled.
One thing that stands out in my process is that I have been using ChatGPT on this same project for a number of months. Because of that, ChatGPT has a working background with me and with the project that others may not have with their own AI tools. I have consistently bounced ideas off ChatGPT, listened to its responses, and then made decisions based on both my own IT experience, which spans more than 40 years, and its technological knowledge.
I know the way I use these two tools will not be how everyone else chooses to work, but I have found my process to be highly productive. In fact, it has even made me rethink whether some functionality I had planned to postpone for later versions should instead be included in the first release.
Why? Because I am now getting things done faster, cleaner, and more efficiently than I was before.
My bottom line is simple: these tools can be a solid win for coders, but only if the developer stays in control. You have to lead, and you have to know what you want.