Loading...

Skip to main content

Agentic Migrations on an Agentic OS - Story Time

· 12 min read
Sandor Muranyi
Sandor Muranyi
Principal Architect at Aliz

I don't know how many people I've told what my approach to AI and the whole industry was (and still kinda is). In short: with over 25 years in IT, having grown up on the C64 and Debian Potato, and loving coding, I really hated it. I still hate some parts. Not just because I thought it takes away the part of my job I love (or thought I loved), but also because the industry is at its lowest point right now in a lot of ways. And if that's not enough, it's all (mainly) driven by FAKE money and business. Yes, I like some conspiracy theories.

This post is about how and why I've recently taken a bit of a different direction: why I now use Omarchy at home, an agentic OS created by DHH, a deeply polarizing figure who praises AI like a god, and why I trusted AI agents to migrate my Java simulation game to C# and have been developing heavily with agents ever since.

The Problem​

As a hobby, I'm writing a Stardew Valley-like simulation game, which I started in Java a few months ago. I've restarted it many times, because it's hard to get off to a great start with something this complex. Around July and August, I decided to use agents for coding. It was a disaster; I even wrote a blog post about it.

In the end, I decided to drop the codebase and start again from scratch, copying over the existing simulation parts and doing everything else by hand, without any agents. After ~2 months, I had to realize that, besides my work at Aliz, I simply don't have enough time (not even close) to advance with this game at the pace I wanted. Writing a raindrop shader, for example, is not a one-hour job. Also, every now and then I had to remind myself that I have a bucket list item: publish a game on the Nintendo Switch. Which is kind of impossible with Java. I'm a bit of a maximalist sometimes, so concerns like this demotivated me as I have minimal C# (and Monogame) knowledge, which adds again a moderate learning time.

The Bright(?) Solution​

When GPT 6.1 Sol and Opus 5.5 came out, I started actively using them at Aliz, and I had to realize that...

Meme: a woman shouting "It's not shit!"

Seriously, these models started producing really good results when I used them for coding.

So one day I decided: what the heck, if I ever want to publish a game on Nintendo, I have to switch to C# (MonoGame), even though I fell in love with Java 15 years ago. But... that's a tedious job, so... the dark side of the Force grabbed me...

I decided to try it out. I gave a detailed prompt to both GPT 6.1 and Opus 5.5, both at high reasoning, both on a private Plus/Pro subscription. The prompt said that I'd like to port all of my code (~10k LoC) over to C#. I wanted to keep the architecture and the rendering logic, but have the code be C#-ish and MonoGame-ish. Both asked questions about the architecture, my future plans, which directions I'd like to take, etc. I answered all of them and waited.

  • GPT, interestingly, got stuck after 3 hours. It just started asking irrelevant questions, even after a restart. I also checked what it had generated up to that point: it was shit. It didn't keep the conventions, invented new architecture layers, etc. I mean, it might be OK for some, but it wasn't good enough for me.
  • Opus 5.5, however, after 1.5 hours, generated code that made me say: "hmmm, that's not bad at all". With a few fixes and adjustments, the code was C# the way I wanted.

Seeing this, I decided to give it a try and continue the development with Opus 5.5 instead of by hand. I set up skills, a workflow, etc.

Agentic Feature Development​

Developing with agents while having such a strong opinion about the whole industry is a bit contradictory. So since I started doing this, I've followed this workflow. It's very simple:

  1. I have a plan in mind for what I'd like to add to the game. Let's say I want to add a "rain to snow" flow, where, depending on the weather's state, rain slowly turns into snow. I discuss the details with the LLM: how the weather works in Nordic areas (the game is set in the Nordic seas), whether I know something wrong, etc. I create a little spec out of it with decisions. I do NOT use SDD (Spec-Driven Development); in my experience it's way too slow, and these new models simply don't need it. A simple spec is enough.
  2. I ask the agent to start implementing it. Implementation includes testing and(!) play-testing. So the agent actually opens the game, plays it, and tests whether everything is fine. I didn't even ask for that, by the way.
  3. When the agent is done, I also test whether it works the way I expected. Like whether it "feels" good when the rain turns into snow. If I don't like something, I tell the agent and we iterate until it feels good.
  4. When everything looks good, I open my IDE (yes, I haven't uninstalled it and never will), and start going through each changed file. There are some parts I don't care about (like debugging overlay UI or math-heavy shaders), but I do care about most parts, so I check each and every file. Do the new interfaces look right? Is the code clean enough? Will this logic hold when I introduce this or that feature in the future? Is this API call a good fit here? This step takes time, but for me, it's a must. What I see is that approx. 80% of the code I get is already in good shape and needs only minimal adjustments.
  5. Whatever I find in the previous step, I give back to the agent as feedback, and we argue until we reach a conclusion. Then the fix is applied and added to the relevant skills, and if needed, a new ADR is created to avoid similar issues in the future.
  6. At this point, we're still not finished. I developed a review skill that looks for code smells, duplication, overengineering, unnecessary comments, etc. I run it with Opus 5.5 again (sometimes with GPT), review what it finds, and may or may not ask for fixes.
  7. Commit, push!

Using this methodology, I advance very fast despite the minimal time I can put into this project. Also, I have 100% knowledge of the code I'm interested in, while I really don't care about some other parts. That's a key point. Who cares how my texture atlas gets generated from my source images? I do, however, care about how the rendering works and how the ECS evolves for example.

Why isn't it more complicated?

  1. This project does not need to comply with anything, so I need no guardrails.
  2. DHH says: "today's models are good enough to do things on their own. Giving them long prompts and skills may make the result worse". I'm not saying I've bought into this, but it's an interesting approach, and it looks like it works most of the time.

Agentic OS?​

"W.T.F." and "bullshit!" were the two words I said to Gergő Halmi, who first introduced me to Omarchy. He told me I should check out some podcasts with DHH (David Heinemeier Hansson, co-owner of 37signals and creator of Ruby on Rails) too. I started listening to this guy, and within the first 10 minutes I told myself many times: what bullshit is this guy talking about, he's simply crazy as hell and bought by either Anthropic or OpenAI. Or both.

But the more I listened to him, the more I realized that we (or at least I) have two paths ahead:

  1. I become more and more depressed about the state of the industry, reject more and more of the new stuff coming out, and communicate in an increasingly negative way; or
  2. I try to accept that, even if this is driven by pure money as of today. Because, what if this technological shift leads us to something good? I really hope so, because the other path is simply killing ourselves and our planet long term. So I'd rather bet on the utopia. Also, as DHH talks about fun and excitement, I remember how excited I was when I got my first C64, then my first 486 and Pentium PCs. This excitement, this fun, can still be part of my life, and when I use his OS, it comes really close to that same feeling.

I'm not gonna explain what this Agentic OS really means; you can check it out yourself, the controversial things as well as the goodies and the hype. All I can say is that I tried it out in a VM to be safe, then on a temporary laptop, and now it's on my main desktop and will soon be on my personal MacBook too. It's just soo good to use. And not just because it's Arch, or because it has Hyprland. It's the sum of all his customizations plus the AI integration: it just clicks for me.

Concerns​

You, DHH and the whole industry are delulu

For sure. I'm as delulu as I was when I got my first 56k dial-up internet connection. I was obsessed with it. I wanted to be online 24/7. I think for everyone with a technical interest, this whole thing must be at least super exciting. Again, I try to see the positive side of the whole thing.

Quality doesn't matter anymore

It does. Before AI, there were bad coders as well who didn't care about quality. Or they did, but couldn't produce quality code. I've led many teams during my career and met a lot of engineers producing just okay code. Quality does matter, and it's your responsibility to ensure it as much as possible, even if you use AI, even if you're vibe coding.

Agents can't write good code

That was really true last year. It was kind of true for the first part of 2026, but now? Not really a problem. The new models are really, really good. I'm not saying they're perfect, but I'm sure they write better code than most engineers.

Hallucination?

They do. Have you ever had a colleague whose favorite team lost yesterday, or who had a personal problem? In my experience, that always resulted in bad code too. We could say they "hallucinated". Now imagine the reviewer having the same bad day. And if you mentioned such things to them in the golden age of IT, they would simply quit: "If you don't like my work, I'll find a better place to work."

The whole thing is a security hole

At this point, yes. For example, Omarchy has its own plugin system, which heavily relies on GitHub. They do verify certain commits of a plugin, but it's up to you to check the code of the plugins you install. I think the industry has a massive handicap here.

100% not viable for serious production use

For some areas, yes. Nuclear reactors and airplanes still need human supervision, IMHO. But I'm sure we'll soon reach a point where human supervision is just pushing a button. Or buttons.

It's only hyped, because it's cheap

True! But I'm sure that as the technology evolves, it will get even cheaper and cheaper (even with some bumps on the road until we get there).

You'll lose your skills

That's an interesting question. As of today, I think: yes. Whether it's inevitable or not, I'm afraid of depending only on these tools and losing my own skills. I've always told juniors that if they start using a framework, they should build their own at home, so they can fail and see how a framework (UI, backend, whatever) works. Or take Unity: adding shadows is kind of a checkbox, but a lot happens behind it. If you don't know what cascaded shadow maps are, you'll be surprised when your game suddenly gets FPS drops.

Skills and human understanding are still a must IMHO, and you must keep them as up to date as possible, but as the technology itself is very new in this form, this is an open and important problem. Also, as my project shows, understanding is no longer required at every point and every time. Sure, this is a hobby project, but the trend is clear.

Conclusion​

I think we've arrived at a point with this technology where it's not optional to use it, not optional to know about it, and not optional at all to master it. From a practical, job standpoint it was already a must-have this year, and I think it will become the de facto standard (if it isn't already). Some companies and people will deny and ban it, and some already have, but I'm not sure that's a safe bet long-term. One man covering a whole team's job... looks like that's the future.

Further Reading​