What I learned after 800 hours of Claude coding

 

A person in an orange superhero-style suit performing physical labor with a shovel at a construction site, symbolizing the necessity of human effort and hands-on execution alongside automated work.

Have you heard of vibe coding? Developers used to type out complex code to build software, but now you just speak your idea and the AI writes the code for you. It feels exactly like someone who used to cram for an English exam suddenly hiring a native speaking assistant to handle their international business meetings. Because the AI takes care of the high level technical execution, we have officially entered an era where ideas and imagination matter far more than syntax.

I actually spend about an hour every evening vibe coding after work. Not because I have to, but because it is genuinely fun. I do not have any plans to monetize what I build, and honestly I do not have the skill set to do so even if I wanted to. But the thrill of watching something I imagined come to life through AI is real.

I am a heavy Claude user. I am not certain of the exact number, but I think I have logged somewhere around 800 hours on it by now. Spending that much time with it, and talking to other people doing the same thing in various communities, I started noticing something important. The entire way we use AI is changing under our feet. We used to type out every single prompt, ask for a favor, and if the output was wrong, type another command to fix it. Lately, everyone seems to be drifting toward something different: dropping a single goal and letting the AI run on its own from there.

I am not the only one noticing this. Boris, the creator of Claude Code, and other developers working at the frontier of this space are saying the exact same thing. Boris has mentioned that he no longer gives Claude step by step instructions. His actual job now is designing the systems that let it run on its own. The creator of OpenClaw said something similar, that he wanted to build a system that writes prompts for the agent instead of having a human type them out. When the people building this stuff are all converging on the same idea, that tends to mean something.


From Chatted Commands to Autonomous Execution

To put this in perspective, think about how AI interaction has evolved. It started as a simple back and forth. You ask, it answers, the conversation ends there. Then AI became a tool user, capable of searching the web or running small tasks before giving you a response. From there it moved to handling multi step tasks, where you hand it a broad goal and it breaks the work down, executes each step, checks its own results, and delivers the final product without you stepping in along the way.

The destination we are arriving at now is full autonomy. The AI wakes up on a schedule, detects new inputs, calls outside services, and finishes complex work entirely on its own. You set the goal once and just check in on the result later.

The leap to full autonomy is not about waiting for a smarter model. It is about building the right architecture around the model you already have.

This is no longer a debate about which tool is best. It is a shift in how work itself gets done. The underlying logic is simple: find, plan, execute, verify, and if something fails, repeat. That is the entire loop. Everything else is just figuring out how to build that cycle well. Your skill used to be measured by how well you wrote a prompt. Now it is measured by how well you design the structure around it.


The Core Elements of an Automated Loop

So what do you actually need to build something that runs itself?

The first piece is an automatic trigger. It needs to start on its own based on a schedule or a condition, so it keeps running instead of stopping after a single pass. You can even set it to loop until a specific condition is genuinely met, like telling it to keep going until every authentication test passes and the code review comes back clean.

The next critical piece is writing down your project's knowledge somewhere permanent. If you have to re-explain your architecture and build process every single session, you are basically working with a goldfish. Put it in a file the AI reads every time it starts. Skip that step, and the AI has to guess everything from scratch on every run. Document it properly, and that knowledge compounds over time. It feels tedious, but writing it down clearly is what lets the AI work from accurate information instead of guesswork.

A diagram showing an AI agent connected to various professional tools including a database, a messenger app like Slack, and a code repository, illustrating an automated workflow system.
Connecting AI agents to your real-world workflow

A structure that only reads files is still too limited though. To get real work done, you need to connect it to the tools you actually use, your database, a messenger app like Slack, whatever fits your workflow. And because an AI that writes its own code tends to be pretty generous when grading its own performance, you need a second AI to audit it. The first one thinks the job is done well enough. The second one catches what the first one missed. In my own setup, I split this into three roles: one plans, one implements, and another checks whether the result actually meets the original requirements.


Keeping Memory Outside the Brain

The final piece, and honestly the most important one, is memory that lives outside the conversation itself.

AI naturally forgets everything once a session ends. If a long task runs past its context limits, it loses track of the original goal and the decisions it already made along the way. The fix is surprisingly simple. Keep an external memory, a markdown file or a separate repository, and write down what has been done and what is still left.

The AI might forget. The storage will not.

The model loses everything between executions, so memory has to live on disk, not inside its head. You have to force it to write down its decisions after every major step, summarize its progress whenever the conversation gets too long, and hardcode the most essential information directly into its very first instruction so it is always available. This is exactly why agents with built-in memory and self-evolving systems, like Hermes, are getting so much attention right now.


The Blind Spots of Total Automation

If you want to try this yourself, do not jump straight into building something massive. Run the process manually first, turn what you learn into a knowledge file, and then wrap it into a repeating loop. Start with a path you have already defined. Let the AI explore freely on its own from day one, and it will burn through your tokens fast.

An icon representing an AI agent surrounded by tokens, illustrating the concept of token consumption and costs associated with automated AI loops.
The hidden cost of automation: Keeping an eye on your token consumption

And speaking of tokens, I need to be honest here. This kind of repeating process eats through them quickly. Running something once is already expensive enough, but a self-running structure is constantly reading, retrying, and exploring, which adds up fast. The good news is that with cheaper models like Kimi entering the picture, the cost problem is slowly easing.

None of this means everyone needs to build this right now either. It only really pays off for repetitive daily tasks where the AI can check its own results. For something you only do occasionally, just typing a normal prompt is faster and cheaper. Do not try to automate everything at once. Start with one small task that actually fits this kind of loop.

And most importantly, just because something runs on its own does not mean you should trust it blindly and walk away. An AI claiming it finished a task is a claim, not proof. The better these loops run, the more code piles up that you personally never wrote, and at some point you may not fully understand your own system anymore. Always check the AI's work yourself, and never hand off the final judgment call entirely.

So here is where this all lands. The AI market right now is moving away from people typing individual prompts and toward designing structures that run on their own. But I want to leave you with one more thing. Two people can build the exact same structure and walk away with completely different results. A friend and I tested this firsthand. Same setup, same content, and the output still varied depending on each person's style and underlying intent.

The work has not gotten easier. The center of gravity has just shifted.

Ride the wave, but keep your hands on the wheel. What I really wanted to say today is that one reliable structure beats a hundred perfectly written prompts. In this shift, where do you find yourself standing right now?


Curious about the real stories behind big tech, crypto, and everyday economics? 👉👉👉Subscribe to The Techtonic for your weekly dose of easy-to-read business trends.      

Latest Insight: [Why OpenAI is losing money as the AI leader]

댓글 쓰기