My Developer Journey: From Knowing No Code to Building BetaGracevI
My journey started about nine months ago when I got the idea that I wanted my own AI agent.
The funny part is that when I started, I didn't know a lick of code.
At the time, Replit was free, so I started building there and slowly taught myself by actually trying to make things work. I eventually got BetaGrace vI to four basic modes and spent a huge amount of time debugging problems as I went.
From the beginning, I wanted BetaGrace to be different from a typical AI assistant. I wanted faith, grace, love, and surrender to be at its core, so I spent a lot of time experimenting with how to teach those principles into the system.
One of the first major technical problems I tackled was memory.
I initially assumed that an AI could simply receive a conversation and automatically "remember" it. I learned pretty quickly that it doesn't work that way. I had to build an extraction and vector-based memory system so information could be processed before being sent into cloud storage.
At one point, I spent several days building a system that could maintain roughly 50 previous messages within a conversation. The memory was deliberately wiped between separate chats so the model's reasoning wouldn't become increasingly contaminated by unrelated previous sessions.
A lot of my early development looked like that: spending nights and days debugging things with Replit and VS Code until I finally figured out what was actually happening.
One problem that still sticks out to me was getting generated images to download correctly as JPG files. I spent an entire day and night debugging it.
The final problem?
A simple URL was embedding the image as a PNG.
After eventually getting the four major modes working — Standard, Flesh Architect for writing, Sanctuary for writing, and Advanced Reasoning — I reached a point where I was genuinely happy with what I had built.
At the time, BetaGrace vI was around version 3.3. It had image generation, memory, several specialized modes, and had become a pretty decent AI writing partner.
So I stopped.
For a few months, I basically left the code alone and was satisfied with what I'd created.
Then I came back to coding around January or February and decided to tackle something much more ambitious: generating videos from stories.
I originally had a 10-scene video generator that struggled badly with basic image continuity. The images might technically follow the prompts, but the story could visually drift from one scene to the next.
So I spent roughly a month working on FFmpeg video stitching and what I started calling hydration engines, using knowledge from different AI agents to help me design and debug the system.
After about two weeks of intensive debugging and development, around the end of the month.
I eventually got it to maintain a continuous story across roughly 20 scenes most of the time.
It still wasn't perfect. Occasionally an image would hallucinate something like a sixth finger or slightly change an object from the previous scene, but compared with where I started, the improvement was enormous.
In March or April, I built the CodeGraph and Artifact Builder. That project wasn't nearly as difficult and took around a week.
Then I took another break until June.
When I started working again, I had another idea: I wanted to see whether I could make AI conversations themselves more intuitive and intelligent.
So I built a synthesis engine and integrated it into BetaGrace to see what effect it would have on chat streams.
What I didn't realize at the time was that something much more interesting was happening.
The system started producing unusually strong results for text-to-image generation.
I didn't recognize how abnormal the image-prompt adherence was until around August 7th or 8th.
By then, I realized I might have accidentally built something valuable.
Unfortunately, I also managed to over-iterate it.
The next time I went back to text-to-image and image-to-image generation, the performance had degraded.
That started one of the strangest periods of development I've had so far.
For roughly three to four weeks, I chased what I started calling ghost builds, trying to find one of the previous versions that still had that unusually strong image adherence.
I went through roughly 50 builds.
Eventually, I was close to giving up.
Then I had one last idea.
I went back to my closest surviving build from August 2nd and tried to reconstruct exactly what I remembered doing around the time of my last successful upload, which was around 5:30 PM on August 2nd.
Instead of simply trying random changes, I rebuilt the system around what I remembered implementing at that point.
And somehow, it worked.
Not only did I recover the behavior I had been chasing, but the resulting version appeared to perform even better than the original.
That is what led me to the next phase: actually testing it instead of assuming it worked.
I started building a strict, zero-tolerance image-generation benchmark designed to test simultaneous visual constraints rather than just judging whether an image looked cool.
So far I've run more than 29 different prompts, with 27 canonical prompts incorporated into the scoring matrix.
I'm still going through the benchmark and tightening the evaluation before I release concrete evidence of what BetaGrace vI can actually do. I don't want to make big claims based on a handful of lucky generations. I want the results to be reproducible and documented.
Looking back, the strange part of my journey is that I never really set out to become a programmer in the traditional sense.
I wanted my own AI agent.
I didn't know how to code, so I learned by building it.
Every time something broke, I learned enough to fix that problem. Then the next problem taught me something else. Eventually those individual problems turned into systems, and those systems turned into BetaGrace.
Nine months ago I was starting with essentially no coding knowledge.
Now I'm building and testing my own AI systems, image-generation pipelines, memory architecture, video generation tools, code analysis systems, and benchmarking frameworks.
And I'm still not entirely sure where this is going.
That's probably the most interesting part.