What I realized after 40 hours of development with ChatGPT and Codex, despite not being able to write code

Hello, I'm Reiji Kuga.

The other day, I suddenly wondered: how much time have I spent on the AI workspace I'm currently building?

When I first counted, I thought it was about 30 hours. But after that, I continued to think about specifications, make revisions, and run checks, so it's now up to about 40 hours.

40 hours.

That's a decent amount of development time.

However, looking at that number, I had a slightly strange feeling.

I cannot write code.

I started development, even though I can't write code

I am not a programmer. I don't have the specialized knowledge to develop software on my own.

Until a little while ago, I never even thought about creating my own software. Even if there was a feature I wanted, I couldn't build it myself. Hiring someone would cost money, and I didn't have enough time to learn from scratch.

That was where it ended.

The AI workspace I'm building this time didn't have a grand vision from the start either.

I wanted to be able to consult with an AI that already understands Project Alive and "Crossroad" without having to explain everything every time. I wanted to make it easier to find the notes I've written in the past and the things I've thought about during production. I wanted to connect conversations to memories and tasks, rather than just letting them end as conversations.

It started from such small inconveniences that I felt every day.

The old me would have just looked for a convenient service and left it at that. If I couldn't find something that fit me perfectly, I would either put up with it and use existing tools, or give up. Those were the only two options.

Now, there is another option.

Build it myself.

To be precise, it's not the option of writing code all by myself, but the option of dividing roles with an AI to build it.

Talking to ChatGPT before throwing ideas at Codex

Recently, I've been seeing the term "vibe coding" quite often.

If you explain what you want to build in words, AI will write the code for you. Even people who cannot write code can now build apps and tools.

I think this is a truly significant change.

However, as I continued to develop, I felt that because you can give instructions in words, there is a considerable difference in the final product.

For example, just telling it to build an easy-to-use dashboard.

The AI will build something. It might tidy up the appearance, place buttons, and return a screen that works reasonably well.

But for whom is it easy to use?

What do I want to do on my computer? What do I want to see first on my smartphone? How does it connect with existing AI chats and task management? Where should I not touch during this modification?

If those things aren't decided, even if you can make something that works, it won't be something you want to keep using.

Moreover, AI will return a plausible finished product even with vague instructions.

When the appearance is polished, we also feel like we have created the right thing. It is only after we start using it that we realize similar functions are duplicated, the saving mechanisms are separate, or the structure makes it difficult to add features later.

That is why I almost never throw an idea for a feature directly at Codex.

I consult with ChatGPT first.

What is the problem? In what situations will it be used? How does it connect with existing functions? What will be considered complete with this development?

I organize the vague requests in my mind little by little while having a dialogue.

I summarize the content into an instruction document before passing it to Codex.

Codex performs the implementation and testing, and I check the results that come back. If it is different from what I expected, I work out the corrections with ChatGPT again and create a new instruction document.

In my view, this is less like 'vibe coding' where you turn ideas into form with momentum, and closer to a style of running a specification-driven process at high speed through dialogue with AI.

I am not just writing long command sentences instead of code.

I am turning things I don't even understand myself into specifications through conversation with AI.

I feel that is the biggest part.

The specification was not complete from the beginning

When you write a specification, it might look like you create a perfect blueprint at the start and follow it through to the end.

In reality, it is quite different.

Features that I thought were necessary while thinking in text can look like distractions once they are on the screen. Conversely, things I initially thought were small auxiliary features can become central once I try them out.

Seeing what has been implemented changes my own thinking.

Therefore, a specification is not something you create once and finish.

It is closer to a map for advancing to the point that is visible at that moment.

If you advance a little, the scenery changes again. There, I stop, talk with ChatGPT, rewrite the map, and pass it to Codex.

This is the repetition.

Things that would have kept me lost in my head for days in the past now come back as something on the screen. Because I can rethink while looking at the actual product, the way I get lost has changed itself.

Instead of starting after creating a perfect specification, I make it into a form even with an incomplete specification, and make the next decision from there.

Because it took shape, I was able to move on to the next sense of discomfort.

Work decreased with AI. But, judgment did not disappear

If you use AI, development becomes quite easy.

Before I started, that is what I thought.

In fact, the implementation itself is fast. Codex gets past places in a short time that might have stopped me for days if I were proceeding while researching from scratch.

However, one day, I passed a quite long instruction document to Codex.

Since it seemed like it would take time for implementation and testing, I decided to go to sleep. I had a feeling it might be finished by morning.

However, when I woke up, it was still running.

The display at the bottom of the screen was blinking at regular intervals. It looked like it had stopped, and it also looked like it was progressing. The usage display also hardly changed.

Should I stop?

Should I wait a little longer?

Even though I am not writing the code, in the end, nothing moves forward unless I make the decisions.

Looking at that screen, I wondered if this, too, counts as development time.

Even during the time my hands aren't moving, the implementation progresses.

On the other hand, even when I am not in front of the computer, I am thinking about the next specifications in my head.

Development using AI has become something that is a bit difficult to measure solely by how many hours I spent touching the computer.

It was a bit like being the director of 'Crossroad'

I remembered this feeling.

It was when I was making the metaverse drama 'Crossroad'.

A Project Alive work cannot be completed by me alone. There are people who act out the voices, people who move the avatars, and people who create the music. Because so many people are involved, it changes into something a little different from the script I first wrote.

Just because I am the director does not mean I can do all the work myself.

In fact, there are more things I cannot do.

Even so, I must decide what to keep in the work.

Even a good performance might not fit the overall flow. Conversely, a suggestion that seemed small at first might significantly change the atmosphere of the work.

Delegating to someone and letting go of the decision-making process were two different things.

Development with AI is a bit similar.

ChatGPT organizes the vague ideas I have. Codex implements those specifications and even proceeds to testing.

It covers a very wide range of the parts I cannot do.

But, what should I include? What should I cut? Should I prioritize convenience, or should I prioritize safety?

The final decisions that remained were, after all, my job.

I used to think that as more things could be left to AI, the human role would disappear.

In reality, it might just be that the role is changing.

What I wanted to create was an environment that wouldn't stop my creative process.

As I continued development, the number of features I wanted to add kept growing.

AI chat, conversation history, long-term memory, article search, task management, suggestion features, development logs. If I just listed everything that seemed useful, there would be no end to it.

But, I stopped for a moment along the way.

I wondered, was an AI tool with many features really what I wanted?

Probably not.

Being able to immediately return to past thoughts before writing a note.

Being able to consult about Project Alive or "Crossroad" without having to explain them from scratch every time.

Being able to see the work that needs to be done now and move directly to the next action.

What I wanted was an environment that wouldn't stop my creative process.

The moment adding features becomes the goal, the meaning of it being for my personal use fades. I don't want to add things just because they seem useful; I want to keep only what I can explain as being necessary for my activities.

Since I started thinking that way, the content of my instructions has also changed.

I started writing not just what to add, but what not to change.

Which screen to connect to. Whether existing mechanisms can be reused. What to display when there are zero features.

I spent more time thinking about how not to be a hindrance when used daily than about flashy features.

This time, what troubled me when counting the development hours was that I didn't know what to count as the 40 hours.

The time spent thinking about specifications with ChatGPT. The time spent writing instructions. The time spent checking the implementation results from Codex. The time spent thinking about the next fix while doing other work.

If I include everything, it might be more than 40 hours.

Conversely, I am not sure if I can count the time Codex spent running tests on its own as my working time.

That is why next time, I want to include a development log within this AI workspace.

Not just how many hours I spent, but what specifications I thought of that day, what I implemented, and what I decided to skip.

Perhaps it would be better to keep not only the instructions that worked well, but also the ones that failed.

Because even if you look at the completed features, you cannot tell why those features were necessary.

With 'Crossroad' too, if you only look at the finished video, you cannot see how many times it stalled, what was remade, or whose words changed it along the way.

The AI workspace is surely the same.

Even if this system evolves into something completely different in a few years, I want to preserve what I thought about during those first 40 hours, where I got lost, and why I kept those features.

I want to make sure that part, at least, does not disappear.

Recommended for you!