The Agent That Builds Itself
I know the headline sounds clickbaity, but it isn’t.
As I’ve written before, I got really going on AI-assisted software development, and as also said, there is always one more thing to build. The problem is, some stuff still needs human intervention (and that will still take some time until the human isn’t needed anymore), but who has time for that?
So a couple of weeks back I sat down with Claude Code to work on a bit of semi-automation. Every few days I was invoking my Claude Code session with “Please check dependencies” and “Please check our logs if something broke/errored” or “we should check our PostgreSQL instance if pgwatch shows any problems”. All of those are simply agentic tasks: fetch data -> triage -> present to the user -> fix / do nothing / ask what to do -> action (implement, ignore, whatever). After some research and a Reddit post I saw about pi.dev (an agentic harness), we implemented a simple “agentic loop”.
So now, there are cron jobs that invoke a pi-agent with specific system prompts and a set of tools (git calling, web search, …) that run periodically and do exactly that: check logs, and check dependencies. The agent does its work, and I get either a full pull request or an email report on what is going on. That way I can look at the PR, approve it, or deny it and the work is done. The same goes for log errors; instead of me noticing something broke, the agent will raise an issue, and when I check it, I can point my Claude code directly at it, conserving precious context and, more importantly, tokens. Because instead of fully having to figure things out, a base analysis is there.
I also wrote about before how fascinated I am by https://andonlabs.com/ ’s fully autonomous radio stations and their cafe and shop. Impressive projects if you have unlimited (or near-unlimited) token budget. And https://moltbotai.chat/ shows how powerful agents are today if enough budget is available. Well, and it also shows how dangerous they can be (just take a look at the recent OpenAI/Hugging Face escalation https://openai.com/index/hugging-face-incident-and-the-road-ahead/).
But all of that is something a solo dev like me couldn’t build, or could I? From the pi-SDK experiments and small agentic flows I’ve now got, I found out deepseek/deepseek-v4-flash is extremely cheap to run. It also manages the pipeline mentioned above with ease, a run costing below $1. So Andon has an agentic radio, shop, cafe, and a “vending machine” benchmark. Interesting projects, but what about an agent that builds its own Twitch/YouTube live stream channel? There are some Twitch channels that stream Claude (or others) already playing games, but what about a full channel? An agent that has to build its own harness, its own shows, timeslots, and other stuff (similar to Andon’s radio stations)?
Meet Haidy777Bot
Years back I created a secondary Twitch account to hook Streamerbot into my main Twitch channel for moderation and similar things. So, after a few sleepless nights, now I’ve got exactly that. Two Git repositories (one for the agent harness, one for the agent’s workspace), both “visible” for the agent. But still with a human in the loop, the agent knows the general idea, but code changes have to be approved by me (for now at least).
How?
Of course you can’t just say to an agent, “Here is an idea; make it work” (well, you can, but the output probably isn’t ideal). So I (well, Claude) got to work again, and we built a base framework harness for such an experiment. You need a “runner loop” that keeps the agent from simply exiting after getting the system prompt, and you need “tools”. For example, as of today the agent knows about its “universe” (that it’s running in a dedicated VM, how many “turns” it has left, and how much budget is left). On the tool side it can edit files (just like Claude Code), run commands, and do other things associated with basic development tasks. It has a relatively simple memory it can write and read from; it has its own simple blog and journal it can document its work in. And some tools to interact with me, because the difference is I’m not actively sending one prompt after another -> I’m saying, “Here you’ve got time now to do work”, and once it runs out of turns, it updates its memory, and I get an email about what it did. Then I can review the produced code (in pull requests), check if it has any questions I need to answer, and merge those pull requests (or reject them).
Afterward, I can simply start the agent loop again; the agent once more sees, “Here you’ve got time now to do work.” It will probably read its memory, check open PRs, and then just continue without intervention from me.
Current State
Currently the agent has been running for a total of 10 runs, and there were some bugs to fix in the harness at first (as with every coding project lol). But so far the agent itself has built the following:
- a basic show idea (chess)
- code to have a “stage host” and dynamically load shows
- code to let the show communicate with the stage host (so it’s bidirectional)
- made its first change to its own harness to read CI error logs (before it could only read base Pull Request and Issue Infos)
- Asked for help on API keys (it can’t see them directly and also can’t create them; I don’t want to be bankrupt next week lol)
- and probably more things I forgot
Of course there are still some kinks to work out; sometimes DeepSeek needs a bit of steering, but overall it runs fully once I start it without me needing to check / help it right away. And it will also take at least a few weeks before it goes live with its first show, I think.
But while the agent was working, I had Claude build me a simple scene for OBS, which basically displays the current agent running. Because why not stream that already? You can find the Twitch channel over at https://www.twitch.tv/haidy777bot but I haven’t added a description and stuff yet. Also, the agent’s blog will probably get a dedicated subdomain so it has another “way” to expose it to the world.
The goal?
I don’t expect the channel to grab any traction anytime soon; it’s just another “fun” experiment seeing what LLMs can do on their own when there is only a small set of instructions and ideas. And since DeepSeek is so cheap, those first 10 runs didn’t even cost $2. It will be quite interesting to see what it comes up with. And if I abandon it in a few weeks? Who cares?
Eventually the code might be open sourced too, but that’s not my number one priority; the first thing I want to see is if it manages to build itself really toward being able to run a full stream on its own. As later down the line, it will get access to OBS’s Websocket API, probably Twitch API, and whatever comes into its mind. It will have a lot to figure out on its way, and it will be interesting to see how it navigates that journey with only gentle steering from me.
Why?
That’s simply answered: WHY NOT?