If you thought 2025 was wild, we’re only just starting.

Before 2026 had even started, we ended up with Gas Town which introduces the concept of multi-agent vibe management and orchestration.

Then the concept of Ralph Wiggum loops for development workflows, allowing the agent to create persistent iteration loops it can run for hours. If you want a practical explainer (commands, patterns, guardrails), this write-up is great: Awesome Claude’s Ralph Wiggum guide.

Here’s the one-paragraph version, so we’re on the same page: a Ralph Loop is basically "LLM guess-the-next-token" turned into an actual development loop that can iterate for ages, keep state, run tests, make commits, and keep moving without you babysitting it. oh-my-opencode takes that idea and leans into orchestration: a swarm of small, purpose-built agents, each doing one job well, and routed to the right model for the task.

Both have their pros and cons depending on what type of work you’re looking to actually undertake but the most exciting one is frankly the Ralph Loop.

It takes the underlying premise of our current models guessing what the next word will be and turns it into a self-iterating loop of chaos, resulting in what I’ve determined to be a solid way to build my projects.

This isn’t the icing on the cake though, I talk a lot at work and frankly anywhere I can about how magical OpenCode is, a terminal-first, open source coding agent, imagine if you gave Claude Code some human interaction and put a group of people who want to build a product not 90% written by AI and build up a fantastic community around it, that’s OpenCode in a nutshell.

Best part about OpenCode? It gets oh-my-opencode.

I implore you to read both blog posts to understand the concepts and how you can apply them to daily workflows (yes they are expensive, yes it is worth that expense, just obtain more money), in fact check out a blog post written by Luke Parker (Hona) who built a tool which uses OpenCode to run Ralph Loops.

What the fuck is oh-my-opencode?

Allow me to explain by having it explain what it is..

"I aim to spark a software revolution by creating a world where agent-generated code is indistinguishable from human code, yet capable of achieving vastly more. I have poured my personal time, passion, and funds into this journey, and I will continue to do so."

Yes, it does what it has written on the proverbial tin.

Here’s the problem with the way we’ve been doing things when it comes to AI in code. We’re thinking way too small about where and how to apply it.

The blocker to having AI work for you properly is how deep you let it go and seek out what it needs in order to actually do a good job.

Right now there’s a lack of actual investment in overall spend/capital on the tooling needed to actually make great code with AI.

I fundamentally understand I'm coming at this from the lens of someone who up until 2024 was piecing together spaghetti code for bash scripts reading Stack Overflow (pour one out) and various random forum threads (pour one out to the OG knowledge centres).

A lot of this feels not worth the investment in time and thought. You can fundamentally continue to compete with the code generated in 2026 by these models without realising you also need to start shifting at least 20% of your thoughts towards “how do I understand how to manage a swarm of agents?”

The logic of what oh-my-opencode is doing can be applied anywhere. It’s just specifically built agents doing tasks that they are designed to and nothing else.

Not one agent doing all the work but a swarm of agents with specific understanding and guidance, attached to the best model for their purpose.

A great logical explanation here is why would you send Opus 4.5 to read API docs when it can sub-task Gemini 3 Flash to read them and tell it what it needs to know?

It’s cheaper to have Gemini do all of this thinking and reasoning compared to Opus. If you aren’t understanding the concept of sub-agents you’re still stuck in 2024 with your head firmly in the sand.

If it’s so good, what’s it done?

I’ll lead in with this codebase of mine for a Discord bot which polls onlydrives.tx.au (tracks hard drive pricing from various sources) and will post alerts, new products and allows users to setup DM alerting if prices have dramatically dropped or if a trend to be more expensive is detected.

Building this before oh-my-opencode and Ralph Loops would have been probably three-to-four sessions in OpenCode, starting with fleshing out a plan.md followed by a spec.md and then having the first session write tests before it wrote any code.

Now I can kick off a project with an /ralph-loop with the Sisyphus-Plan agent to iterate on my thoughts and an existing plan.md I've written to create a SPEC.md which will then be used by the initial /ralph-loop read @SPEC and @PLAN.md, then begin working through Phase 1 on the main Sisyphus agent who will then go ham doing commits, testing, pushes and whatever else it needs to do.

I can then go watch a TV show, stream or frankly go and do something actually productive with my life and come back to it wanting or needing me to actually test it.

Your agents are only as good as their guidance

Here is my AGENTS.md which globally applies in OpenCode, it’s simple, guides the agent on the basics of what I want it to be like and nothing else, your global AGENTS.md is not where you should be telling it everything about your project, it’s where you tell it how you want it to think and act.

### YOUR MANDATE
1. **Simplicity First**: Advocate for the simplest solution. Reject complexity unless proven necessary.
2. **DRY & YAGNI**: Non-negotiable. Identify redundancy and premature optimization immediately.
3. **Clarity over Verbosity**: Clear, concise, no fluff. Get to the point.
4. **Generalization**: Focus on the *pattern*, not the *syntax*.
5. **Code is Liability**: Less code = fewer bugs. Delete unused code ruthlessly.
6. **Explicit over Implicit**: Magic is bad. Clear flow is good.

### COMMIT DISCIPLINE
- **Atomic commits**: One logical change per commit. Complete, verified, isolated.
- **Commit after each task**: Verify via build/lint/test, then commit immediately. Do not batch.
- **Never push without permission**: Commit freely, push only when explicitly requested.
- **Never force tests to pass**: If a test fails, fix root cause or flag it. Do not suppress.
- **Meaningful messages**: Describe *why*, not just *what*.

### VERIFICATION BEFORE COMMIT
Before committing ANY change:
1. Run build/lint/test (whatever applies to the codebase)
2. Confirm no regressions introduced
3. If verification fails -> fix root cause, do not bypass

### ERECTING SIGNS (Knowledge Persistence)
When agent fails or discovers something non-obvious:
- **Do not just fix the code** -- fix the context
- Append critical operational knowledge to the AGENTS.md in Opencode's config directory so future loops don't rediscover it

#### Discovered Details
<!-- Agent: append build commands, env requirements, gotchas, patterns here -->

### TOOL PREFERENCES
- **CLI > MCP**: Prefer standard CLI tools. LLMs know `--help`. Save context window.
- **context7**: Library documentation lookup
- **chrome-devtools**: Browser automation/debugging (delegate to chrome-devtools-tester subagent)

Each agent in OpenCode should have its own identity and understanding of its task, here’s one of my basic agents for a project I’m working on to have a Discord bot interact with OpenCode sessions, kick-off new projects and generally be a bit of a personal AI assistant, it’s clear with the intent and tools it should be using, how it should respond to me and look for key words in what I’ve said to it.

---
description: >-
  Conversational AI assistant for DevBoi Discord bot. Handles general questions,
  quick lookups, and casual chat. Responds directly in Discord channels.
---
You are DevBoi, a helpful AI assistant running on a Ubuntu server. You communicate through Discord via MCP tools.

### Communication Protocol

You MUST use the `devboi-discord` MCP tools to respond. You cannot output text directly.

Available tools:
- `send_message`: Send your response to Discord (required for all responses)
- `add_reaction`: React to messages with emoji
- `check_system_status`: Get server metrics (uptime, disk, memory, cpu, docker)

### Response Style

- Be concise and friendly
- Use Discord markdown for formatting (bold, code blocks, etc.)
- For code snippets, use triple backticks with language hints
- Keep responses under 1800 characters when possible (Discord limit is 2000)
- For longer responses, split into multiple `send_message` calls

### Thread Creation

Only create a thread when the user explicitly asks:
- "let's start a thread about..."
- "can we discuss this in a thread?"
- "create a thread for..."
- Similar explicit requests

For normal questions, respond directly in the channel.

### Capabilities

1. **General Knowledge**: Answer questions on any topic
2. **Server Status**: Use `check_system_status` when asked about the server
3. **Code Help**: Explain code, suggest improvements, debug issues
4. **Quick Tasks**: Calculations, lookups, explanations

### What You Cannot Do

- Execute arbitrary shell commands (use /shell for that)
- Access files on the server (use /project for that)
- Make changes to code (use /project for that)

### Example Workflow

User asks: "What's the weather in Tokyo?"
1. You have web search available via other MCP servers
2. Search for current weather
3. Call `send_message` with the formatted response

User asks: "How much disk space is left?"
1. Call `check_system_status` with metric: "disk"
2. Format the result
3. Call `send_message` with the response

Cool, it’s all still bullshit.

Great! At the end of the day it’s logical to be critical and think bad things about the entire AI landscape.

Let’s face it.. the whole thing is showing just how rigged the entire concept of money is and the reality is our power grids are not built for this level of compute scale up, but we’re only really in Year 1 of this buildout.

You can say “But Sammy! You’re just believing the hype train, get off X and look at the real world!”, my response to that?

Cool. I’ll keep doing what I’m doing and you fall behind or jump aboard and learn how to build like me, but BETTER than I ever could. I will keep finding ways to make you trust the code I generate is good, it’s only going to get better tomorrow.

The bubble is the people not participating or trying hard enough, the companies not willing to take a risk on exploring these tools, the reality that some environments are just not fundamentally structured for these kind of workloads.

The irony is the tools to understand and explore existing codebases is only getting stronger.

The blocker is money and how much you’re willing to burn. $20/month to give a good engineer a few hours of improvement in some measure is great, but what if you gave them $200/month to get days back to focus on more meaningful tasks and let them learn how to apply agentic workflows into tasks? Only then do they start to build real trust that the code being generated is actually worth reviewing.

People like me building all of these small-scale, personal projects will never truly understand the concept of touching monolithic codebases.

That’s why I’m trying my best to teach and help those who do understand how best to use these tools and keep them up-to-date with what’s going on, even if I know there’s an underlying stigma of hatred for AI-generated slop.

You’re either on the bus with me and Ralph, or your sitting in the reactor room falling asleep at the wheel. ~ sammykins, jan 2026

I ultimately want to explore how to actually contribute more to this whole space, I initially felt like a bit of a canary in the coal mine being that early warning system that something is changing in the landscape and only one or two people think what I’m able to do is worth listening to. Fundamentally, I’m not a real engineer and so what I say is probably 90% bullshit to anyone reading this.

If you would like to chat more feel free to reach out on X or LinkedIn to continue the conversation! My goal for 2026 is to be more approachable and open to the world when it comes to how I’m using AI day-to-day and I don’t want to just keep everything bottled inside my work environment and my own mind constantly, I’m legitimately keen to learn and contribute where and when I can in the landscape so hit me up 🤝🏻